doc

lib/src/core/renderer.rs

@@ -19,9 +19,8 @@
 //! - **Accès Bas-Niveau**: Advanced users can bypass Scene and call Renderer directly for custom rendering paths.
 
 use crate::core::Context;
-use crate::resources::{Mesh, Material};
 use crate::core::Frame;
-
+use crate::resources::{Material, Mesh};
 
 /// The Executor layer of the architecture. Holds shared references to Device and Queue from Context,
 /// plus the surface texture format. Executes WGPU rendering commands by binding Materials and Meshes
@@ -37,6 +36,8 @@ pub struct Renderer {
 
 impl Renderer {
     /// Creates a Renderer by cloning Device and Queue Arc references from the Context, plus capturing the surface format.
+    /// Inputs: context (borrowed reference to Context providing GPU resource handles), format (surface texture format).
+    /// Returns a new Renderer instance sharing the same underlying GPU resources as Context.
     /// Called once at application startup during scene setup. The Renderer shares these resources via Arc;
     /// Context retains ownership and can continue using them after this call.
     pub fn new(context: &Context, format: wgpu::TextureFormat) -> Self {
@@ -49,20 +50,18 @@ impl Renderer {
 
     /// Orchestrates rendering of a single object: binds Material pipeline + Mesh vertex data into a RenderPass,
     /// then submits commands to the GPU queue for execution. Called per-frame by the orchestrator (main.rs).
+    /// Inputs: view (TextureView color attachment target), mesh (geometry to render), material (shader+pipeline).
     /// Internal steps: 1) create CommandEncoder → 2) begin RenderPass with color attachment →
-    /// 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,
-        view: &wgpu::TextureView,
-        mesh: &Mesh,
-        material: &Material,
-    ) {
+    ///   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, view: &wgpu::TextureView, mesh: &Mesh, material: &Material) {
         // Create per-frame command encoder; its lifetime is scoped to this function only.
-        let mut encoder = self.device.create_command_encoder(&wgpu::CommandEncoderDescriptor {
-            label: Some("render encoder"),
-        });
+        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.
@@ -106,11 +105,13 @@ impl Renderer {
     }
 
     /// Returns a reference to the owned Device for direct access when needed (e.g., PipelineCache creation).
+    /// Called internally during scene setup; not typically used by external code.
     pub fn device(&self) -> &wgpu::Device {
         &self.device
     }
 
     /// Returns the surface texture output format used for rendering.
+    /// Called internally during Material/PipelineCache initialization to ensure pipeline compatibility.
     pub fn format(&self) -> wgpu::TextureFormat {
         self.format
     }