TBR: Use SoA vertex layout to improve cache locality

Signed-off-by: ZhouFANG <indevn@outlook.com>

Author: indevn

src/include/rasterizer.hpp

@@ -3,6 +3,7 @@
 
 #include "config.h"
 #include "shader.hpp"
+#include "vertex_soa.hpp"
 
 namespace simple_renderer {
 
@@ -27,6 +28,11 @@ class Rasterizer {
                    int x0, int y0, int x1, int y1,
                    std::vector<Fragment>& out);
 
+  // SoA 版本：按顶点索引从 SoA 读取三角形三顶点
+  void RasterizeTo(const VertexSoA& soa, size_t i0, size_t i1, size_t i2,
+                   int x0, int y0, int x1, int y1,
+                   std::vector<Fragment>& out);
+
  private:
   size_t width_, height_;
 

src/include/renderer.h

@@ -38,18 +38,12 @@ enum class RenderingMode {
   DEFERRED      // 延迟渲染模式 - 经典GPU管线教学模拟
 };
 
-// Face 只包含顶点索引，不包含实际的顶点数据;
-// Vertex 包含3D坐标，但没有屏幕坐标
-// Fragment 包含屏幕坐标，但它是光栅化的结果，不是输入
-struct TriangleInfo {
-  Vertex v0, v1, v2;
-  const Material *material;
-  size_t face_index;
-  TriangleInfo(const Vertex& vertex0, const Vertex& vertex1, const Vertex& vertex2,
-             const Material* mat, size_t face_idx = 0)
-    : v0(vertex0), v1(vertex1), v2(vertex2), material(mat), face_index(face_idx) {}
-    
-  TriangleInfo() = default;
+
+// SoA 版 tile 列表中的三角形引用（仅存索引与材质指针）
+struct TriangleRef {
+  size_t i0, i1, i2;
+  const Material* material = nullptr;
+  size_t face_index = 0;
 };
 
 class SimpleRenderer {
@@ -158,10 +152,9 @@ class SimpleRenderer {
     double deferred_shading_ms;
     double total_ms;
   };
-  
   TileRenderStats ExecuteTileBasedPipeline(const Model &model,
-                                          const std::vector<Vertex> &processedVertices,
-                                          uint32_t *buffer);
+                                              const VertexSoA &soa,
+                                              uint32_t *buffer);
 
   /**
    * 延迟渲染管线
@@ -177,19 +170,24 @@ class SimpleRenderer {
 
 private:
 
+
+  // SoA 版本的 Triangle-Tile binning（两遍计数 + reserve）
   void TriangleTileBinning(
-    const Model &model, 
-    const std::vector<Vertex> &screenVertices,
-    std::vector<std::vector<TriangleInfo>> &tile_triangles,
+    const Model &model,
+    const VertexSoA &soa,
+    std::vector<std::vector<TriangleRef>> &tile_triangles,
     size_t tiles_x, size_t tiles_y, size_t tile_size);
 
+
+  // SoA 版本的 tile 光栅化
   void RasterizeTile(
     size_t tile_id,
-    const std::vector<TriangleInfo> &triangles,
+    const std::vector<TriangleRef> &triangles,
     size_t tiles_x, size_t tiles_y, size_t tile_size,
     float* tile_depth_buffer, uint32_t* tile_color_buffer,
     std::unique_ptr<float[]> &global_depth_buffer,
     std::unique_ptr<uint32_t[]> &global_color_buffer,
+    const VertexSoA &soa,
     bool use_early_z = false,
     std::vector<Fragment>* scratch_fragments = nullptr);
 

src/include/vertex_soa.hpp

@@ -0,0 +1,33 @@
+// Minimal SoA layout for TBR pipeline (Phase 1)
+#ifndef SIMPLERENDER_SRC_INCLUDE_VERTEX_SOA_HPP_
+#define SIMPLERENDER_SRC_INCLUDE_VERTEX_SOA_HPP_
+
+#include <vector>
+
+#include "math.hpp"
+#include "color.h"
+
+namespace simple_renderer {
+
+struct VertexSoA {
+  // 屏幕空间坐标（视口变换后）
+  std::vector<Vector4f> pos_screen;  // screen space position (x,y,z,w)
+  // 裁剪空间坐标（用于视锥体剔除）：clip = MVP * pos
+  std::vector<Vector4f> pos_clip;
+  std::vector<Vector3f> normal;
+  std::vector<Vector2f> uv;
+  std::vector<Color>    color;
+
+  inline size_t size() const { return pos_screen.size(); }
+  inline void resize(size_t n) {
+    pos_screen.resize(n);
+    pos_clip.resize(n);
+    normal.resize(n);
+    uv.resize(n);
+    color.resize(n);
+  }
+};
+
+}  // namespace simple_renderer
+
+#endif  // SIMPLERENDER_SRC_INCLUDE_VERTEX_SOA_HPP_

src/rasterizer.cpp

@@ -158,6 +158,67 @@ void Rasterizer::RasterizeTo(const Vertex& v0, const Vertex& v1, const Vertex& v
   }
 }
 
+void Rasterizer::RasterizeTo(const VertexSoA& soa, size_t i0, size_t i1, size_t i2,
+                             int x0, int y0, int x1, int y1,
+                             std::vector<Fragment>& out) {
+  // 读取三顶点的屏幕空间位置
+  const Vector4f& p0 = soa.pos_screen[i0];
+  const Vector4f& p1 = soa.pos_screen[i1];
+  const Vector4f& p2 = soa.pos_screen[i2];
+
+  Vector2f a = Vector2f(p0.x, p0.y);
+  Vector2f b = Vector2f(p1.x, p1.y);
+  Vector2f c = Vector2f(p2.x, p2.y);
+
+  Vector2f bboxMin = Vector2f{std::min({a.x, b.x, c.x}), std::min({a.y, b.y, c.y})};
+  Vector2f bboxMax = Vector2f{std::max({a.x, b.x, c.x}), std::max({a.y, b.y, c.y})};
+
+  // Clamp 到屏幕尺寸
+  float minx = std::max(0.0f, bboxMin.x);
+  float miny = std::max(0.0f, bboxMin.y);
+  float maxx = std::min(float(width_ - 1), bboxMax.x);
+  float maxy = std::min(float(height_ - 1), bboxMax.y);
+
+  // 与外部提供的裁剪区域相交（半开区间） -> 闭区间扫描
+  int sx = std::max(x0, int(std::floor(minx)));
+  int sy = std::max(y0, int(std::floor(miny)));
+  int ex = std::min(x1 - 1, int(std::floor(maxx)));
+  int ey = std::min(y1 - 1, int(std::floor(maxy)));
+  if (sx > ex || sy > ey) return;
+
+  // 透视矫正插值依赖 w
+  float w0_inv = p0.w;
+  float w1_inv = p1.w;
+  float w2_inv = p2.w;
+
+  for (int x = sx; x <= ex; ++x) {
+    for (int y = sy; y <= ey; ++y) {
+      auto [is_inside, bary] = GetBarycentricCoord(
+          Vector3f(p0.x, p0.y, p0.z), Vector3f(p1.x, p1.y, p1.z), Vector3f(p2.x, p2.y, p2.z),
+          Vector3f(static_cast<float>(x), static_cast<float>(y), 0));
+      if (!is_inside) continue;
+
+      float w_inv_interp = Interpolate(w0_inv, w1_inv, w2_inv, bary);
+      Vector3f cb(
+          bary.x * w0_inv / w_inv_interp,
+          bary.y * w1_inv / w_inv_interp,
+          bary.z * w2_inv / w_inv_interp);
+
+      float z = Interpolate(p0.z, p1.z, p2.z, cb);
+
+      Fragment frag;
+      frag.screen_coord = {x, y};
+      frag.normal = Interpolate(soa.normal[i0], soa.normal[i1], soa.normal[i2], cb);
+      frag.uv     = Interpolate(soa.uv[i0],     soa.uv[i1],     soa.uv[i2],     cb);
+      frag.color  = InterpolateColor(soa.color[i0], soa.color[i1], soa.color[i2], cb);
+      frag.depth  = z;
+      // material 指针由调用方填写
+
+      out.push_back(frag);
+    }
+  }
+}
+
 std::pair<bool, Vector3f> Rasterizer::GetBarycentricCoord(const Vector3f& p0,
                                                           const Vector3f& p1,
                                                           const Vector3f& p2,