style: update

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

Author: MRNIU

simple_renderer/src/material.rs

@@ -5,25 +5,14 @@ use crate::error::{RendererError, Result};
 use crate::math::Vec3;
 
 /// An image texture with pixel data stored in a flat `Vec<u8>`.
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Default)]
 pub struct Texture {
     pub data: Vec<u8>,
     pub width: u32,
     pub height: u32,
     pub channels: u32,
 }
 
-impl Default for Texture {
-    fn default() -> Self {
-        Self {
-            data: Vec::new(),
-            width: 0,
-            height: 0,
-            channels: 0,
-        }
-    }
-}
-
 impl Texture {
     /// Load a texture from an image file (PNG, JPEG, BMP, TGA).
     pub fn load_from_file<P: AsRef<Path>>(path: P) -> Result<Texture> {

simple_renderer/src/renderers/tile_based.rs

@@ -25,6 +25,16 @@ use crate::renderers::tile_common::{
 use crate::renderers::Renderer;
 use crate::shader::Shader;
 
+/// Result of rasterizing a single tile.
+struct TileResult {
+    depth: Vec<f32>,
+    color: Vec<u32>,
+    screen_x: usize,
+    screen_y: usize,
+    width: usize,
+    height: usize,
+}
+
 /// SoA tile-based renderer with edge function rasterization and optional Early-Z.
 ///
 /// Mirrors C++ `TileBasedRenderer`: vertex transform → tile binning →
@@ -79,8 +89,8 @@ impl Renderer for TileBasedRenderer {
         let t = Instant::now();
         // 3. Setup tile grid
         let tile_size = self.tile_size;
-        let tiles_x = (width + tile_size - 1) / tile_size;
-        let tiles_y = (height + tile_size - 1) / tile_size;
+        let tiles_x = width.div_ceil(tile_size);
+        let tiles_y = height.div_ceil(tile_size);
 
         let grid = TileGridContext {
             soa,
@@ -107,7 +117,7 @@ impl Renderer for TileBasedRenderer {
         let total_tiles = tiles_x * tiles_y;
         let early_z = self.early_z;
 
-        let tile_results: Vec<(Vec<f32>, Vec<u32>, usize, usize, usize, usize)> = (0..total_tiles)
+        let tile_results: Vec<TileResult> = (0..total_tiles)
             .into_par_iter()
             .map(|tile_id| {
                 let tile_x = tile_id % tiles_x;
@@ -139,29 +149,29 @@ impl Renderer for TileBasedRenderer {
                     height,
                 );
 
-                (
-                    tile_depth,
-                    tile_color,
-                    screen_x_start,
-                    screen_y_start,
-                    tile_width,
-                    tile_height,
-                )
+                TileResult {
+                    depth: tile_depth,
+                    color: tile_color,
+                    screen_x: screen_x_start,
+                    screen_y: screen_y_start,
+                    width: tile_width,
+                    height: tile_height,
+                }
             })
             .collect();
 
         let raster_ms = t.elapsed().as_secs_f64() * 1000.0;
 
         // 7. Copy tile results to global framebuffer
         let t = Instant::now();
-        for (tile_depth, 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]
-                    .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]);
+        for tile in &tile_results {
+            for y in 0..tile.height {
+                let tile_row_off = y * tile.width;
+                let global_row_off = (tile.screen_y + y) * width + tile.screen_x;
+                global_color[global_row_off..global_row_off + tile.width]
+                    .copy_from_slice(&tile.color[tile_row_off..tile_row_off + tile.width]);
+                global_depth[global_row_off..global_row_off + tile.width]
+                    .copy_from_slice(&tile.depth[tile_row_off..tile_row_off + tile.width]);
             }
         }
         let copy_ms = t.elapsed().as_secs_f64() * 1000.0;

simple_renderer/src/renderers/tile_based_deferred.rs

@@ -79,8 +79,8 @@ impl Renderer for TileBasedDeferredRenderer {
         let t = Instant::now();
         // 3. Setup tile grid
         let tile_size = self.tile_size;
-        let tiles_x = (width + tile_size - 1) / tile_size;
-        let tiles_y = (height + tile_size - 1) / tile_size;
+        let tiles_x = width.div_ceil(tile_size);
+        let tiles_y = height.div_ceil(tile_size);
 
         let grid = TileGridContext {
             soa,

simple_renderer/src/shader.rs

@@ -443,9 +443,9 @@ impl Shader {
             values.fill(1.0);
             return SpecularLut { values };
         }
-        for i in 0..SPECULAR_LUT_RESOLUTION {
+        for (i, value) in values.iter_mut().enumerate().take(SPECULAR_LUT_RESOLUTION) {
             let cos_theta = i as f32 / (SPECULAR_LUT_RESOLUTION - 1) as f32;
-            values[i] = if cos_theta <= 0.0 {
+            *value = if cos_theta <= 0.0 {
                 0.0
             } else {
                 cos_theta.powf(shininess)