perf: update

Signed-off-by: Niu Zhihong <zhihong@nzhnb.com>

Author: MRNIU

simple_renderer/src/renderers/deferred.rs

@@ -4,25 +4,27 @@
 //!
 //! Algorithm:
 //! 1. Vertex transform (sequential — `vertex_shader` needs `&mut self`)
-//! 2. Parallel rasterization: collect ALL fragments per pixel (no backface culling)
-//! 3. Merge per-thread fragment buffers
-//! 4. Depth resolve: find closest fragment per pixel
-//! 5. Deferred shading: shade only winner fragments
-//! 6. Write to output buffer
+//! 2. Parallel rasterization with per-thread depth testing:
+//!    each thread keeps only the closest fragment per pixel (NO backface culling)
+//! 3. Parallel merge + deferred shading:
+//!    find closest fragment across threads and shade only winners (in parallel)
+//! 4. Write to output buffer
 
 use log::debug;
 use std::time::Instant;
 
 use rayon::prelude::*;
 
+use crate::color::Color;
 use crate::fragment::Fragment;
+use crate::math::{Vec2, Vec3};
 use crate::model::Model;
 use crate::rasterizer::Rasterizer;
 use crate::renderers::base;
 use crate::renderers::Renderer;
 use crate::shader::Shader;
 
-/// AoS deferred renderer: collect all fragments, then shade only the winners.
+/// AoS deferred renderer: collect closest fragments per thread, then shade only the winners.
 ///
 /// Key difference from `PerTriangleRenderer`:
 /// - NO backface culling — all fragments are collected
@@ -41,12 +43,6 @@ impl DeferredRenderer {
     }
 }
 
-/// Per-pixel fragment entry: stores fragment + face index for material lookup.
-struct FragmentEntry {
-    fragment: Fragment,
-    face_index: usize,
-}
-
 impl Renderer for DeferredRenderer {
     fn render(
         &self,
@@ -74,27 +70,38 @@ impl Renderer for DeferredRenderer {
         let vertex_ms = t.elapsed().as_secs_f64() * 1000.0;
 
         let t = Instant::now();
-        // 3. Parallel rasterization: collect ALL fragments (NO backface culling)
+        // 3. Parallel rasterization with per-thread depth testing
+        //
+        // Each thread keeps only the CLOSEST fragment per pixel, drastically
+        // reducing memory from O(threads × pixels × fragments_per_pixel) to
+        // O(threads × pixels).
         let num_pixels = width * height;
         let faces = model.faces();
         let rasterizer = Rasterizer::new(width, height);
         let num_threads = rayon::current_num_threads();
         let chunk_size = std::cmp::max(faces.len() / num_threads, 1);
 
-        // Per-thread fragment buffers: Vec<Vec<FragmentEntry>> per pixel
-        let chunk_results: Vec<Vec<Vec<FragmentEntry>>> = faces
+        // Dummy fragment for buffer initialization (never read — only valid
+        // entries where depth_buf < INFINITY are accessed during merge).
+        let dummy = Fragment {
+            screen_coord: [0, 0],
+            normal: Vec3::ZERO,
+            uv: Vec2::ZERO,
+            color: Color::new(0, 0, 0, 0),
+            depth: f32::INFINITY,
+        };
+
+        // Per-thread result: (depth_buf, fragment_buf, face_index_buf)
+        let chunk_results: Vec<(Vec<f32>, Vec<Fragment>, Vec<usize>)> = faces
             .par_chunks(chunk_size)
             .enumerate()
-            .map(|(_chunk_idx, face_chunk)| {
-                let mut pixel_fragments: Vec<Vec<FragmentEntry>> =
-                    (0..num_pixels).map(|_| Vec::new()).collect();
-
-                // Compute starting face index for this chunk
-                let chunk_start = face_chunk.as_ptr() as usize - faces.as_ptr() as usize;
-                let chunk_start_idx = chunk_start / std::mem::size_of_val(&faces[0]);
+            .map(|(chunk_idx, face_chunk)| {
+                let mut depth_buf = vec![f32::INFINITY; num_pixels];
+                let mut frag_buf = vec![dummy.clone(); num_pixels];
+                let mut face_buf = vec![0usize; num_pixels];
 
                 for (local_idx, face) in face_chunk.iter().enumerate() {
-                    let face_idx = chunk_start_idx + local_idx;
+                    let face_idx = chunk_idx * chunk_size + local_idx;
                     let v0 = &processed_vertices[face.indices[0]];
                     let v1 = &processed_vertices[face.indices[1]];
                     let v2 = &processed_vertices[face.indices[2]];
@@ -114,44 +121,50 @@ impl Renderer for DeferredRenderer {
                             continue;
                         }
                         let idx = x + y * width;
-                        pixel_fragments[idx].push(FragmentEntry {
-                            fragment: frag,
-                            face_index: face_idx,
-                        });
+                        // Per-thread depth test: keep only the closest fragment
+                        if frag.depth < depth_buf[idx] {
+                            depth_buf[idx] = frag.depth;
+                            frag_buf[idx] = frag;
+                            face_buf[idx] = face_idx;
+                        }
                     }
                 }
 
-                pixel_fragments
+                (depth_buf, frag_buf, face_buf)
             })
             .collect();
 
         let collect_ms = t.elapsed().as_secs_f64() * 1000.0;
 
-        // 4. Merge per-thread fragment buffers + depth resolve + deferred shading
+        // 4. Parallel merge + deferred shading
+        //
+        // For each pixel, find the closest fragment across all threads,
+        // then shade only that winner. Both merge and shade run in parallel.
         let t = Instant::now();
-        // For each pixel: collect from all threads, find min depth, shade winner
-        for i in 0..num_pixels {
-            let mut best_entry: Option<(&FragmentEntry, f32)> = None;
-
-            for thread_buf in &chunk_results {
-                for entry in &thread_buf[i] {
-                    let depth = entry.fragment.depth;
-                    match best_entry {
-                        None => best_entry = Some((entry, depth)),
-                        Some((_, best_depth)) if depth < best_depth => {
-                            best_entry = Some((entry, depth));
-                        }
-                        _ => {}
+        let final_buffer: Vec<u32> = (0..num_pixels)
+            .into_par_iter()
+            .map(|i| {
+                let mut best_depth = f32::INFINITY;
+                let mut best_chunk: Option<usize> = None;
+
+                for (chunk_idx, (depth_buf, _, _)) in chunk_results.iter().enumerate() {
+                    if depth_buf[i] < best_depth {
+                        best_depth = depth_buf[i];
+                        best_chunk = Some(chunk_idx);
                     }
                 }
-            }
 
-            if let Some((winner, _)) = best_entry {
-                let material = &faces[winner.face_index].material;
-                let color = shader.fragment_shader(&winner.fragment, material);
-                out_buffer[i] = u32::from(color);
-            }
-        }
+                if let Some(chunk_idx) = best_chunk {
+                    let winner_frag = &chunk_results[chunk_idx].1[i];
+                    let winner_face_idx = chunk_results[chunk_idx].2[i];
+                    let material = &faces[winner_face_idx].material;
+                    u32::from(shader.fragment_shader(winner_frag, material))
+                } else {
+                    0u32
+                }
+            })
+            .collect();
+        out_buffer[..num_pixels].copy_from_slice(&final_buffer);
         let shade_ms = t.elapsed().as_secs_f64() * 1000.0;
 
         let sum_ms = vertex_ms + collect_ms + shade_ms;
@@ -173,9 +186,8 @@ impl Renderer for DeferredRenderer {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::color::Color;
     use crate::light::Light;
-    use crate::math::{Mat4, Vec3};
+    use crate::math::Mat4;
 
     /// Set up a shader with identity matrices and a simple light for testing.
     fn test_shader() -> Shader {

simple_renderer/src/renderers/tile_based_deferred.rs

@@ -93,16 +93,12 @@ impl Renderer for TileBasedDeferredRenderer {
         let tile_triangles = tile_common::triangle_tile_binning(model, &grid);
         let binning_ms = t.elapsed().as_secs_f64() * 1000.0;
 
-        // 5. Global framebuffer
-        let num_pixels = width * height;
-        let mut global_color = vec![COLOR_CLEAR; num_pixels];
-        let mut global_depth = vec![DEPTH_CLEAR; num_pixels];
 
         let t = Instant::now();
         // 6. Parallel 2-pass rasterization per tile
         let total_tiles = tiles_x * tiles_y;
 
-        let tile_results: Vec<(Vec<f32>, Vec<u32>, usize, usize, usize, usize)> =
+        let tile_results: Vec<(Vec<u32>, usize, usize, usize, usize)> =
             (0..total_tiles)
                 .into_par_iter()
                 .map(|tile_id| {
@@ -136,8 +132,9 @@ impl Renderer for TileBasedDeferredRenderer {
                         height,
                     );
 
+                    // tile_depth is only used as z-buffer within
+                    // rasterize_tile_deferred — no need to return it
                     (
-                        tile_depth,
                         tile_color,
                         screen_x_start,
                         screen_y_start,
@@ -149,23 +146,18 @@ impl Renderer for TileBasedDeferredRenderer {
 
         let raster_ms = t.elapsed().as_secs_f64() * 1000.0;
 
-        // 7. Copy tile results to global framebuffer
+        // 7. Copy tile results directly to output buffer
         let t = Instant::now();
-        for (tile_depth, tile_color, sx, sy, tw, th) in &tile_results {
+        for (tile_color, sx, sy, tw, th) in &tile_results {
             for y in 0..*th {
                 let tile_row_off = y * tw;
-                let global_row_off = (sy + y) * width + sx;
-                global_color[global_row_off..global_row_off + tw]
+                let out_row_off = (sy + y) * width + sx;
+                out_buffer[out_row_off..out_row_off + tw]
                     .copy_from_slice(&tile_color[tile_row_off..tile_row_off + tw]);
-                global_depth[global_row_off..global_row_off + tw]
-                    .copy_from_slice(&tile_depth[tile_row_off..tile_row_off + tw]);
             }
         }
         let copy_ms = t.elapsed().as_secs_f64() * 1000.0;
 
-        // 8. Copy to output
-        out_buffer[..num_pixels].copy_from_slice(&global_color);
-
         let sum_ms = vertex_ms + setup_ms + binning_ms + raster_ms + copy_ms;
         if sum_ms > 0.0 {
             debug!("=== TILE-BASED DEFERRED RENDERING PERFORMANCE ===");
@@ -204,7 +196,7 @@ fn rasterize_tile_deferred(
     let tile_pixels = tile_width * tile_height;
 
     // Per-pixel state for 2-pass
-    let mut zmin = vec![DEPTH_CLEAR; tile_pixels];
+    // tile_depth is used as zmin buffer (Pass A) and output depth (Pass B)
     let mut winner: Vec<i32> = vec![-1; tile_pixels];
     let mut b0c_buf = vec![0.0f32; tile_pixels];
     let mut b1c_buf = vec![0.0f32; tile_pixels];
@@ -319,8 +311,8 @@ fn rasterize_tile_deferred(
                     let local_y = (y - screen_y_start as i32) as usize;
                     let idx = local_x + local_y * tile_width;
 
-                    if z < zmin[idx] - 1e-8 {
-                        zmin[idx] = z;
+                    if z < tile_depth[idx] - 1e-8 {
+                        tile_depth[idx] = z;
                         winner[idx] = tri_local_idx as i32;
                         b0c_buf[idx] = b0c;
                         b1c_buf[idx] = b1c;
@@ -374,11 +366,11 @@ fn rasterize_tile_deferred(
                 normal,
                 uv,
                 color,
-                depth: zmin[idx],
+                depth: tile_depth[idx],
             };
 
             let out_color = shader.fragment_shader(&frag, &faces[tri.face_index].material);
-            tile_depth[idx] = frag.depth;
+            // tile_depth[idx] already set in Pass A
             tile_color[idx] = u32::from(out_color);
         }
     }