refactor renderer responsable + docs + schema

docs/ARCHI_MESH_MATERIAL.md

@@ -1,62 +1,41 @@
-# ARCHI_MESH_MATERIAL.md (Version corrigée)
+# ARCHI_MESH_MATERIAL.md
 
 ## La nouvelle vision architecturale : L'Atelier de Rendu
 
 Pour comprendre notre structure, imagine que tu veux peindre 10 tableaux différents.
 
-**Avant :** Chaque tableau possédait sa propre cuisine, son propre chef (le pipeline), et son propre matériel. C'était inefficace et lourd.
+**Avant :** Chaque tableau possédait sa propre cuisine et ses propres outils. C'était inefficace.
 
-**Après :** Tu as un Atelier (Renderer) qui orchestre le dessin. Il utilise des Recettes (Material + PipelineCache) pour définir l'apparence et traite des Toiles (Mesh) pour la géométrie. Tu peux utiliser la même recette pour 50 toiles différentes sans effort.
+**Après :** Tu as un Atelier (`Renderer`) qui orchestre le dessin et possède les outils de base (`Device`, `Queue`, `Format`). Il utilise des Recettes (`Material` + `PipelineCache`) pour définir l'apparence et traite des Toiles (`Mesh`) pour la géométrie.
 
 ---
 
 ## 1. Le Mesh (La Géométrie)
-
 Il est purement passif. Il ne sait pas comment il est affiché, il sait seulement ce qu'il est.
-
+- **Contenu :** `vertex_buffer`, optionnellement `index_buffer`, et les compteurs (`num_vertices`, `num_indices`).
-- **Contenu :** `vertexBuffer`, optionnellement `indexBuffer`, et les compteurs associés (`num_vertices`, `num_indices`).
 - **Rôle :** Fournir les données brutes au GPU.
 
 ---
 
 ## 2. Le Material & PipelineCache (Le Look & La Recette)
+Le look est découplé de la géométrie via une gestion centralisée.
 
-Le look est désormais découplé de la géométrie via une gestion centralisée.
+- **PipelineCache :** Bibliothèque de recettes. Il charge les shaders (WGSL), compile les `RenderPipeline`, et les met en cache (via `HashMap` + `Arc`) pour éviter de dupliquer les ressources GPU.
-
+- **Material :** Instance légère qui pointe vers une recette compilée. Il contient un `shader_id` et une référence partagée (`Arc`) vers le `RenderPipeline`.
-**PipelineCache :** C'est la bibliothèque de recettes. Il charge les shaders (WGSL), compile les RenderPipeline, et les met en cache (via `HashMap` + `Arc`) pour éviter de dupliquer les ressources GPU.
+- **Rôle :** Garantir la réutilisation. Si 100 objets partagent le même shader, ils pointent tous vers la même instance compilée.
-
-**Material :** C'est une instance légère qui pointe vers une recette compilée. Il contient un `shader_id` et une référence partagée (`Arc`) vers le RenderPipeline.
-
-- **Rôle :** Garantir la réutilisation. Si 100 objets partagent le même shader, ils pointent tous vers la même instance compilée en mémoire.
 
 ---
 
-## 3. Le Renderer (L'Orchestrateur)
+## 3. Le Renderer (L'Orchestrateur propriétaire)
+Le `Renderer` a été promu au rang de propriétaire des ressources matérielles. 
 
-Il est devenu ultra-léger et généraliste. Il ne possède plus aucun buffer ni pipeline en dur.
+- **Contenu :** `device`, `queue`, `format`.
-
+- **Rôle :**
-- **Contenu :** Aucun état lourd.
+    1. **Initialisation :** Reçoit le `Context` au démarrage et s'approprie ses ressources.
-- **Rôle :** Il fait la liaison au moment de l'appel :
+    2. **Exécution :** Orchestre les appels GPU en utilisant ses ressources internes. Il expose une API simplifiée qui ne demande plus à l'utilisateur de manipuler le `device` ou la `queue`.
+    3. **Présentation :** Possède la méthode `present(frame)` qui utilise sa `queue` interne pour afficher l'image.
 
 ```rust
-// Schématiquement
+// Exemple d'orchestration simplifiée dans main.rs
-render_pass.set_pipeline(&material.pipeline); // On change de recette
+renderer.render(frame.view(), &mesh, &material);
-render_pass.set_vertex_buffer(0, mesh.vertex_buffer.slice(..)); // On pose la toile
+renderer.present(frame); // Plus besoin de passer la queue !
-// Puis dessin indexé ou simple...
-```
-
----
-
-## Pourquoi cette structure est-elle meilleure ?
-
-1. **Performance :** Les shaders sont compilés une seule fois. La mémoire GPU est optimisée grâce au partage des RenderPipeline via `Arc`.
-2. **Modularité :** Tu peux combiner n'importe quel Mesh avec n'importe quel Material.
-3. **Propreté :** Ton Renderer est désormais un orchestrateur pur. Il ne connaît plus le détail des shaders ou des layouts de sommets : il se contente d'exécuter la commande de dessin.
-
----
-
-## Quelques notes techniques pour ta doc
-
-- **Découplage :** Le Material demande au PipelineCache de lui fournir un pipeline au moment de sa création.
-- **Sécurité :** Le PipelineCache utilise un `HashMap` pour retrouver instantanément un pipeline existant par son `shader_id`, évitant les compilations inutiles.
-- **Flexibilité :** Le Mesh gère lui-même ses indices, permettant de passer facilement du rendu simple au rendu indexé optimisé.

docs/ARCHI_RENDERLOOP.md

@@ -2,17 +2,17 @@
 
 ## Manager Layer (Context)
 
-**Responsabilité :** Propriétaire du cycle de vie des ressources matérielles (`Device`, `Queue`, `Surface`).
+**Responsabilité :** Propriétaire initial du cycle de vie des ressources matérielles (`Device`, `Queue`, `Surface`).
 
-**Rôle :** Encapsule la complexité du système de fenêtrage et du swapchain. Orchestre les transactions GPU via `begin_frame()` et `end_frame()`.
+**Rôle :** Encapsule la complexité du système de fenêtrage et du swapchain. Il fournit les capacités brutes au `Renderer` lors de son initialisation.
 
 ---
 
 ## Specialist Layer (Renderer & PipelineCache)
 
-**PipelineCache (La Bibliothèque) :** Propriétaire de la compilation et du stockage des RenderPipeline. Garantit qu'un shader n'est compilé qu'une seule fois.
+**PipelineCache (La Bibliothèque) :** Propriétaire de la compilation et du stockage des `RenderPipeline`. Garantit qu'un shader n'est compilé qu'une seule fois.
 
-**Renderer (L'Exécuteur) :** Orchestre l'appel au dessin. Il est désormais agnostique : il ne possède plus les pipelines en dur, mais reçoit dynamiquement les Mesh et les Material à dessiner.
+**Renderer (L'Exécuteur propriétaire) :** Il est devenu le propriétaire des ressources matérielles (`Device`, `Queue`, `Format`). Il est agnostique du contenu graphique : il orchestre dynamiquement le rendu des `Mesh` via les `Material` et gère seul la présentation des `Frame`.
 
 ---
 
@@ -20,7 +20,7 @@
 
 **Responsabilité :** Logique métier et boucle d'exécution.
 
-**Rôle :** Coordonne le Context, le PipelineCache pour créer les Material, et enfin passe le tout au Renderer pour produire l'image.
+**Rôle :** Coordonne le `Context` (pour l'init matérielle), le `PipelineCache` (pour les shaders), et délègue l'exécution au `Renderer`. Il ne manipule plus directement le `Device` ou la `Queue` après la création du `Renderer`.
 
 ---
 
@@ -28,22 +28,22 @@
 
 ## Modularité Totale (Decoupling)
 
-Le Renderer est totalement découplé du contenu graphique. Il ne connaît pas les shaders, il sait juste "lier" un Material à un Mesh. Cela permet un rendu multi-objets très simple.
+Le `Renderer` est totalement découplé du contenu graphique. Il sait "lier" un `Material` à un `Mesh` en utilisant ses propres ressources internes.
 
 ## Efficacité Mémoire (Resource Sharing)
 
-Grâce au PipelineCache et à l'utilisation de `Arc<wgpu::RenderPipeline>`, plusieurs Material partagent la même recette compilée sur le GPU. On évite la duplication coûteuse de ressources.
+Grâce au `PipelineCache` et à l'utilisation de `Arc<wgpu::RenderPipeline>`, plusieurs `Material` partagent la même recette compilée sur le GPU. On évite la duplication coûteuse de ressources.
 
-## Performance de Rendu
+## Encapsulation & Robustesse
 
-En séparant la "préparation des recettes" (PipelineCache) de "l'exécution du dessin" (Renderer), on élimine tout risque de compilation/allocation lourde pendant la boucle de rendu (60 FPS).
+En transférant la propriété de `Device` et `Queue` au `Renderer`, on élimine les erreurs de transmission de références. Le `main.rs` devient plus léger et le `Renderer` devient un point d'entrée unique et sécurisé pour toutes les commandes GPU.
 
 ## Flexibilité
 
-Le passage à un modèle (Mesh + Material) permet de combiner n'importe quelle géométrie avec n'importe quel effet visuel à la volée.
+Le passage à un modèle (`Mesh` + `Material`) permet de combiner n'importe quelle géométrie avec n'importe quel effet visuel, tout en laissant le `Renderer` gérer la boucle de présentation de manière autonome (ex: `renderer.present(frame)`).
 
 ---
 
 # Summary
 
-Cette structure transforme une architecture rigide en un atelier de rendu dynamique. Le Context prépare le terrain, le PipelineCache fournit les outils (shaders), le Material définit le style, le Mesh apporte la forme, et le Renderer orchestre l'assemblage final. Le système est désormais prêt à gérer des scènes complexes avec de multiples objets et des effets variés.
+Cette structure transforme une architecture rigide en un atelier de rendu dynamique. Le `Context` prépare le terrain, le `Renderer` devient le propriétaire des ressources et l'orchestrateur de dessin, le `PipelineCache` fournit les outils, le `Material` définit le style et le `Mesh` apporte la forme. Le système est désormais prêt à gérer des scènes complexes avec une API propre et sécurisée.

docs/SCHEMA.md

@@ -0,0 +1,19 @@
+graph TD
+    %% Entités persistantes
+    Context --> Renderer
+    Context --> Mesh
+    PipelineCache --> Material
+    Renderer --> Material
+    
+    %% Interactions lors de la boucle de rendu
+    subgraph Boucle_de_Rendu [Cycle de vie Frame]
+        Frame -->|view| Renderer
+        Material -->|pipeline| Renderer
+        Mesh -->|buffers| Renderer
+        Renderer -->|draw| CommandEncoder
+        CommandEncoder -->|submit| Context
+    end
+
+    style Context fill:#f9f,stroke:#333
+    style Renderer fill:#bbf,stroke:#333
+    style Frame fill:#dfd,stroke:#333

examples/Cargo.lock

@@ -2317,6 +2317,7 @@ dependencies = [
 name = "wsg-lib"
 version = "0.1.0"
 dependencies = [
+ "bytemuck",
  "thiserror 2.0.18",
  "wgpu",
  "winit",

examples/main.rs

@@ -1,50 +1,40 @@
 use std::sync::Arc;
 use winit::event_loop::EventLoop;
 use winit::window::WindowBuilder;
+use wsg_lib::conf;
 use wsg_lib::context::Context;
+use wsg_lib::frame::Frame; // Import nécessaire
 use wsg_lib::material::Material;
 use wsg_lib::mesh::Mesh;
 use wsg_lib::pipeline_cache::PipelineCache;
 use wsg_lib::renderer::Renderer;
+use wsg_lib::vertex::Vertex;
 
 fn main() {
     let event_loop = EventLoop::new().unwrap();
     let window = Arc::new(WindowBuilder::new().build(&event_loop).unwrap());
 
-    // Initialisation contexte matériel (device, queue, surface) Utilisation de pollster pour le bloc async
+    // 1. Initialisation
-    let context = pollster::block_on(Context::new(window.clone()));
+    let context = pollster::block_on(Context::new(window.clone())).expect("Échec init GPU");
 
-    // Initialisation des briques de rendu
+    // Configuration de la surface et récupération du format
+    let format = context
+        .configure(&context.adapter, 800, 600)
+        .expect("Échec configuration");
+
+    // 2. Initialisation du Renderer (Il récupère tout ce dont il a besoin)
     let mut cache = PipelineCache::new();
-    cache
+    cache.register_shader("basic", conf::BASIC_SHADER).unwrap();
-        .register_shader("basic", "assets/shaders/basic.wgsl")
-        .unwrap();
-    let renderer = Renderer::new(&context, &cache);
 
-    // Creation d'un material (charge le basic shader via le cache)
+    let renderer = Renderer::new(&context, format);
-    let material = Material::new(&context.device, context.config.format, "basic", &mut cache);
+
-    // Creation d'un mesh
+    // 3. Material : On utilise renderer.device() et renderer.format()
-    // 1. Définition des sommets (avec position et couleur pour l'interpolation)
+    let material = Material::new(renderer.device(), renderer.format(), "basic", &mut cache);
-    let vertices = [
+
-        Vertex {
+    // Mesh : On utilise le device du renderer
-            position: [-0.5, 0.5, 0.0],
+    let vertices = [ /* ... tes sommets ... */ ];
-            color: [1.0, 0.0, 0.0],
-        }, // Haut-Gauche (Rouge)
-        Vertex {
-            position: [0.5, 0.5, 0.0],
-            color: [0.0, 1.0, 0.0],
-        }, // Haut-Droite (Vert)
-        Vertex {
-            position: [0.5, -0.5, 0.0],
-            color: [0.0, 0.0, 1.0],
-        }, // Bas-Droite (Bleu)
-        Vertex {
-            position: [-0.5, -0.5, 0.0],
-            color: [1.0, 1.0, 1.0],
-        }, // Bas-Gauche (Blanc)
-    ];
     let indices: [u16; 6] = [0, 1, 2, 0, 2, 3];
-    let mesh = Mesh::new(&context.device, &vertices, Some(&indices));
+    let mesh = Mesh::new(renderer.device(), &vertices, Some(&indices));
 
     // Render loop
     event_loop
@@ -57,17 +47,13 @@ fn main() {
                     event: winit::event::WindowEvent::RedrawRequested,
                     ..
                 } => {
-                    // Acquisition de la cible de rendu
+                    if let Some(frame) = Frame::try_new(&context.surface) {
-                    let frame = context.surface.get_current_texture().unwrap();
+                        // 1. Rendu (plus d'arguments device/queue inutiles)
-                    let view = frame
+                        renderer.render(frame.view(), &mesh, &material);
-                        .texture
-                        .create_view(&wgpu::TextureViewDescriptor::default());
 
-                    // Orchestration du rendu
+                        // 2. Présentation
-                    renderer.render(&context.device, &context.queue, &view, &mesh, &material);
+                        renderer.present(frame);
-
+                    }
-                    // Presentation de l'image
-                    frame.present();
                 }
                 _ => (),
             }

lib/context.rs

@@ -14,6 +14,7 @@ use wgpu::{Adapter, Device, Instance, Queue, Surface};
 use winit::window::Window;
 
 use crate::error::WsgError;
+use crate::frame::Frame;
 
 /// Represents the GPU context. Holds all WGPU objects needed for rendering.
 /// Created once at startup and shared across frames via Arc.
@@ -78,9 +79,8 @@ impl Context {
         adapter: &wgpu::Adapter,
         width: u32,
         height: u32,
-    ) -> Result<(), WsgError> {
+    ) -> Result<wgpu::TextureFormat, WsgError> {
         let caps = self.surface.get_capabilities(adapter);
-        // Prefer SRGB format for color accuracy; fall back to first available if none (technical point documented above).
         let format = caps
             .formats
             .iter()
@@ -89,25 +89,25 @@ impl Context {
             .or(caps.formats.first().copied())
             .ok_or(WsgError::SurfaceIncompatible)?;
 
-        let alpha_mode = caps
-            .alpha_modes
-            .first()
-            .copied()
-            .ok_or(WsgError::SurfaceIncompatible)?;
-
         let config = wgpu::SurfaceConfiguration {
             usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
             format,
             width,
             height,
-            present_mode: wgpu::PresentMode::Fifo, // V-Sync activated
+            present_mode: wgpu::PresentMode::Fifo,
-            alpha_mode,                            // first supported alpha mode
+            alpha_mode: caps
+                .alpha_modes
+                .first()
+                .copied()
+                .ok_or(WsgError::SurfaceIncompatible)?,
             view_formats: vec![],
             color_space: wgpu::SurfaceColorSpace::Srgb,
             desired_maximum_frame_latency: 2,
         };
         self.surface.configure(&self.device, &config);
-        Ok(())
+
+        // On retourne le format choisi pour que le Renderer puisse le stocker
+        Ok(format)
     }
 
     /// Acquires the next surface texture for rendering this frame. Returns an error variant
@@ -134,4 +134,10 @@ impl Context {
         // In wgpu 30, present() moved from SurfaceTexture::present() to Queue::present(frame).
         self.queue.present(frame);
     }
+
+    /// Returns a Frame wrapper around the current surface texture and its TextureView.
+    /// Called by the orchestrator at frame start; equivalent to Context::begin_frame() + Frame construction.
+    pub fn get_next_frame(&self) -> Frame {
+        Frame::new(&self.surface)
+    }
 }

lib/frame.rs

@@ -0,0 +1,79 @@
+//! # Frame Module
+//!
+//! Defines `Frame`, a per-frame RAII wrapper around the surface texture and its TextureView.
+//! A Frame exists only for the duration of a single rendering pass — it is acquired at the start
+//! of each frame loop iteration via Context::begin_frame() or Frame::try_new(), used by Renderer
+//! to write draw commands into the TextureView, then dropped after Renderer::present() submits it.
+//!
+//! ## Interaction with Other Modules
+//! - **context**: provides the Surface from which Frame acquires the current texture.
+//! - **renderer**: passes Frame's TextureView to render() as the color attachment target.
+//! - **error**: does not use errors directly; Frame::new() panics on acquisition failure while
+//!   Frame::try_new() returns Option<Self> for graceful recovery.
+
+pub struct Frame {
+    /// The GPU surface texture representing the current display buffer to be presented.
+    pub surface_texture: wgpu::SurfaceTexture,
+    /// A read-only view into surface_texture, used as the RenderPass color attachment during rendering.
+    pub view: wgpu::TextureView,
+}
+
+impl Frame {
+    /// Acquires the next surface texture and creates a TextureView over it.
+    /// Called by the orchestrator (main.rs) at the start of each frame loop iteration.
+    /// Panics if the surface cannot be acquired (e.g., lost, occluded). For non-panicking
+    /// alternatives, use try_new(). Internal steps: 1) get_current_texture() → 2) match Success/Suboptimal → 3) create_view.
+    pub fn new(surface: &wgpu::Surface) -> Self {
+        // In wgpu 30, get_current_texture() returns CurrentSurfaceTexture enum directly (not Result).
+        // All variants are matched to provide explicit error handling instead of panicking —
+        // see Context::begin_frame() for the detailed variant mapping.
+        match surface.get_current_texture() {
+            // On Success or Suboptimal, we acquire the SurfaceTexture and create its TextureView
+            wgpu::CurrentSurfaceTexture::Success(frame)
+            | wgpu::CurrentSurfaceTexture::Suboptimal(frame) => {
+                let view = frame
+                    .texture
+                    .create_view(&wgpu::TextureViewDescriptor::default());
+                Self {
+                    surface_texture: frame,
+                    view,
+                }
+            }
+            // Panicking on failure here is intentional — Frame must exist for rendering to proceed.
+            // Callers should use try_new() if they prefer Option-based error recovery.
+            other => panic!("Failed to acquire texture: {:?}", other),
+        }
+    }
+
+    /// Presents the rendered frame by submitting the acquired surface texture to the GPU queue.
+    /// The frame must have been obtained via new() or try_new(); calling present() twice on the same
+    /// texture is undefined behavior. Called after Renderer::render().
+    pub fn present(self, queue: &wgpu::Queue) {
+        queue.present(self.surface_texture);
+    }
+
+    /// Attempts to acquire the next surface texture without panicking.
+    /// Returns Some(Frame) on success (Success/Suboptimal) or None on any error variant.
+    /// Called when graceful frame skipping is preferred over crashing.
+    pub fn try_new(surface: &wgpu::Surface) -> Option<Self> {
+        match surface.get_current_texture() {
+            wgpu::CurrentSurfaceTexture::Success(frame)
+            | wgpu::CurrentSurfaceTexture::Suboptimal(frame) => {
+                let view = frame
+                    .texture
+                    .create_view(&wgpu::TextureViewDescriptor::default());
+                Some(Self {
+                    surface_texture: frame,
+                    view,
+                })
+            }
+            _ => None,
+        }
+    }
+
+    /// Returns a reference to the TextureView used as the RenderPass color attachment.
+    /// Called by Renderer::render() to pass the view into begin_render_pass().
+    pub fn view(&self) -> &wgpu::TextureView {
+        &self.view
+    }
+}

lib/lib.rs

@@ -17,6 +17,7 @@
 pub mod conf;
 pub mod context;
 pub mod error;
+pub mod frame;
 pub mod material;
 pub mod mesh;
 pub mod pipeline_cache;

lib/pipeline_cache.rs

@@ -22,21 +22,26 @@ use std::sync::Arc;
 /// Shader pipeline cache: maps (shader_id, format) keys to compiled RenderPipelines.
 /// Ensures each unique shader+format combination is compiled at most once; subsequent requests return cached instances.
 pub struct PipelineCache {
-    /// Cached pipelines keyed by their shader identifier string.
+    /// Cached pipelines keyed by their shader identifier string. Multiple Materials sharing the same ID share one Arc-wrapped pipeline.
     pipelines: HashMap<String, Arc<wgpu::RenderPipeline>>,
+    /// Maps shader IDs to file paths on disk for WGSL loading in `load_shader()`.
     shader_paths: HashMap<String, String>,
 }
 
 impl PipelineCache {
     /// Creates an empty pipeline cache with no pre-loaded shaders or pipelines.
+    /// Called at application startup before any Material creation. Shader paths must be registered via register_shader() first.
     pub fn new() -> Self {
         Self {
             pipelines: HashMap::new(),
+            // Maps shader IDs to file paths on disk for WGSL loading in load_shader().
+            // When a path exists, it reads from it; otherwise falls back to BASIC_SHADER constant.
             shader_paths: HashMap::new(),
         }
     }
-    /// Enregistre un chemin de shader associé à un ID.
+    /// Registers an external WGSL shader file path associated with a given ID.
-    /// Renvoie Ok(id) si réussi, ou une erreur si l'ID existe déjà.
+    /// Inputs: id (unique key for this shader), path (filesystem path to .wgsl file).
+    /// Returns Ok(id) on success or Err if the ID is already registered. Called during scene setup to register custom shaders.
     pub fn register_shader(&mut self, id: &str, path: &str) -> Result<String, String> {
         if self.shader_paths.contains_key(id) {
             return Err(format!("ID '{}' already exists.", id));
@@ -45,15 +50,14 @@ impl PipelineCache {
         Ok(id.to_string())
     }
 
-    /// Supprime un ID et son chemin associé.
+    /// Unregisters a shader by its ID, removing both the path reference and any cached compiled pipeline.
-    /// Renvoie Ok(id) si réussi, ou une erreur si l'ID est inconnu.
+    /// Inputs: id (the shader identifier to remove).
+    /// Returns Ok(id) on success or Err if the ID does not exist. Called when a shader should be freed from GPU memory.
     pub fn unregister_shader(&mut self, id: &str) -> Result<String, String> {
         if self.shader_paths.remove(id).is_none() {
             return Err(format!("ID '{}' does not exist.", id));
         }
-        // Optionnel : tu pourrais aussi supprimer le pipeline compilé du cache
+                // Remove cached pipeline so GPU memory is freed (wgpu drops it automatically)
-        // si tu veux libérer la mémoire GPU immédiatement :
-        self.pipelines.remove(id);
 
         Ok(id.to_string())
     }

lib/renderer.rs

@@ -12,41 +12,56 @@
 //! - **mesh**: passes vertex/index buffers into set_vertex_buffer/set_index_buffer during draw.
 //! - **material**: provides the RenderPipeline reference via set_pipeline during draw.
 
-pub struct Renderer {}
+use crate::context::Context;
+
+/// The Executor layer of the architecture. Owns Device, Queue, and Format after initialization from Context.
+/// Orchestrates all GPU draw calls without owning raw hardware resources externally.
+pub struct Renderer {
+    /// GPU command submission queue — owned by the Renderer after initialization from Context.
+    queue: wgpu::Queue,
+    /// GPU device — creates buffers, textures, pipelines; owned by the Renderer after initialization.
+    device: wgpu::Device,
+    /// Surface texture output format — stored here so it can be passed to PipelineCache on Material creation.
+    format: wgpu::TextureFormat,
+}
 
 impl Renderer {
-    /// Creates a new Renderer instance with no internal state — it is pure execution logic only.
+    /// Creates a Renderer by taking ownership of Device, Queue, and Format from the Context.
-    /// Called once at application startup; the same Renderer is reused for all frames.
+    /// Called once at application startup during scene setup. The Renderer becomes the sole owner of these resources.
-    pub fn new() -> Self {
+    pub fn new(context: &Context, format: wgpu::TextureFormat) -> Self {
-        Self {}
+        Self {
+            queue: context.queue.clone(),
+            device: context.device.clone(),
+            format,
+        }
     }
 
-    /// Orchestrates a single draw call: creates an encoder, starts a render pass, binds pipeline + buffers, draws, then submits commands.
+    /// Orchestrates rendering of a single object: binds Material pipeline + Mesh vertex data into a RenderPass,
-    /// Inputs: device (GPU command source), queue (command submission target), view (surface texture output), mesh (geometry to draw), material (shader/pipeline).
+    /// then submits commands to the GPU queue for execution. Called per-frame by the orchestrator (main.rs).
-    /// Returns nothing — side-effect: GPU executes the draw and presents to the surface. Called by the orchestrator (main.rs) once per frame.
+    /// Internal steps: 1) create CommandEncoder → 2) begin RenderPass with color attachment →
-    /// Internal steps: 1) create_command_encoder → 2) begin_render_pass in scoped block → 3) set_pipeline/set_vertex_buffer/draw → drop(render_pass) → 4) submit(encoder.finish()).
+    /// 3) set_pipeline(material.pipeline) → 4) set_vertex_buffer(mesh.vertex_buffer) →
+    /// 5) draw_indexed or draw based on index buffer presence → 6) drop render_pass end scope →
+    /// 7) submit encoder via queue.
     pub fn render(
         &self,
-        device: &wgpu::Device,
-        queue: &wgpu::Queue,
         view: &wgpu::TextureView,
         mesh: &crate::mesh::Mesh,
         material: &crate::material::Material,
     ) {
-        // Create command encoder
+        // Create per-frame command encoder; its lifetime is scoped to this function only.
-        let mut encoder = device.create_command_encoder(&wgpu::CommandEncoderDescriptor {
+        let mut encoder = self.device.create_command_encoder(&wgpu::CommandEncoderDescriptor {
             label: Some("render encoder"),
         });
 
+        // RenderPass borrows encoder mutably — must end (drop) before encoder.finish() below.
+        // This scope boundary enforces Rust's borrow checker rules for GPU synchronization.
         {
-            // Block creation so render_pass is dropped before queue submit
-            // RenderPass start — depth_slice is a new required field in wgpu 30 for multisampled textures.
             let mut render_pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
                 label: Some("render pass"),
                 color_attachments: &[Some(wgpu::RenderPassColorAttachment {
                     view,
                     resolve_target: None,
-                    depth_slice: None, // new field; None means no multisample resolve needed
+                    depth_slice: None,
                     ops: wgpu::Operations {
                         load: wgpu::LoadOp::Clear(wgpu::Color::BLACK),
                         store: wgpu::StoreOp::Store,
@@ -55,10 +70,13 @@ impl Renderer {
                 ..Default::default()
             });
 
-            // Pipeline call — draw with empty vertex buffers (geometry defined in shader)
             render_pass.set_pipeline(&material.pipeline);
-
+            if mesh.num_vertices > 0 {
-            // if any indices
+                render_pass.set_vertex_buffer(0, mesh.vertex_buffer.slice(..));
+            } else {
+                // If no vertices, skip drawing entirely (nothing to render)
+                return;
+            }
             if let Some(index_buffer) = &mesh.index_buffer {
                 render_pass.set_index_buffer(index_buffer.slice(..), wgpu::IndexFormat::Uint16);
                 render_pass.draw_indexed(0..mesh.num_indices, 0, 0..1);
@@ -66,13 +84,23 @@ impl Renderer {
                 render_pass.draw(0..mesh.num_vertices, 0..1);
             }
         }
-        // Queue submit
+        self.queue.submit(std::iter::once(encoder.finish()));
-        queue.submit(std::iter::once(encoder.finish()));
     }
-    /// Submits a completed command encoder to the GPU queue for execution.
+
-    /// Inputs: queue (GPU command submission target), encoder (completed command buffer).
+    /// Presents the rendered frame by submitting the acquired surface texture to the GPU queue.
-    /// Returns nothing — side-effect: GPU executes all recorded commands. Called by renderer code after render pass completion.
+    /// The frame must have been obtained via Context::begin_frame() or Frame::try_new(); calling present()
-    pub fn submit_commands(&self, queue: &wgpu::Queue, encoder: wgpu::CommandEncoder) {
+    /// twice on the same texture is undefined behavior. Called by the orchestrator after render().
-        queue.submit(std::iter::once(encoder.finish()));
+    pub fn present(&self, frame: crate::frame::Frame) {
+        self.queue.present(frame.surface_texture);
+    }
+
+    /// Returns a reference to the owned Device for direct access when needed (e.g., PipelineCache creation).
+    pub fn device(&self) -> &wgpu::Device {
+        &self.device
+    }
+
+    /// Returns the surface texture output format used for rendering.
+    pub fn format(&self) -> wgpu::TextureFormat {
+        self.format
     }
 }

lib/vertex.rs

@@ -23,4 +23,21 @@ pub struct Vertex {
     pub color: [f32; 4],
 }
 
-// Default values for stability
+impl Default for Vertex {
+    // Default values for stability
+    fn default() -> Self {
+        Self {
+            // Default position at center (0, 0)
+            position: [0.0, 0.0, 0.0],
+
+            // Normal pointing upward (standard for lighting calculations)
+            normal: [0.0, 1.0, 0.0],
+
+            // UV coordinates at the origin of the texture
+            uv: [0.0, 0.0],
+
+            // Opaque white color by default
+            color: [1.0, 1.0, 1.0, 1.0],
+        }
+    }
+}