Optimize perspective correction, add helper func, simplify code

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

Author: indevn

src/include/rasterizer.hpp

@@ -3,7 +3,7 @@
 
 #include "config.h"
 #include "shader.hpp"
-#include "vertex_soa.hpp"
+#include "vertex.hpp"
 
 namespace simple_renderer {
 
@@ -36,13 +36,25 @@ class Rasterizer {
  private:
   size_t width_, height_;
 
+  // 透视矫正结果
+  struct PerspectiveCorrectionResult {
+    Vector3f corrected_barycentric;
+    float interpolated_z;
+  };
+
+  // 透视矫正helper函数
+  PerspectiveCorrectionResult PerformPerspectiveCorrection(
+      float w0, float w1, float w2,
+      float z0, float z1, float z2,
+      const Vector3f& original_barycentric) const;
+
   template <typename T>
   T Interpolate(const T& v0, const T& v1, const T& v2,
-                const Vector3f& barycentric_coord);
+                const Vector3f& barycentric_coord) const;
 
   Color InterpolateColor(const Color& color0, const Color& color1,
                          const Color& color2,
-                         const Vector3f& barycentric_coord);
+                         const Vector3f& barycentric_coord) const;
 
   std::pair<bool, Vector3f> GetBarycentricCoord(const Vector3f& p0,
                                                 const Vector3f& p1,

src/include/renderer.h

@@ -20,6 +20,7 @@
 #include <cstdint>
 #include <functional>
 #include <span>
+#include <string>
 
 #include "buffer.hpp"
 #include "light.h"
@@ -38,6 +39,10 @@ enum class RenderingMode {
   DEFERRED      // 延迟渲染模式 - 经典GPU管线教学模拟
 };
 
+// RenderingMode辅助函数声明
+std::string RenderingModeToString(RenderingMode mode);
+std::string RenderingModeToDetailedString(RenderingMode mode);
+
 
 // SoA 版 tile 列表中的三角形引用（仅存索引与材质指针）
 struct TriangleRef {
@@ -94,11 +99,15 @@ class SimpleRenderer {
   const size_t width_;
   LogSystem log_system_;
   RenderingMode current_mode_;  // 当前渲染模式
-  bool early_z_enabled_;        // Early-Z优化开关
+  bool is_early_z_enabled_;        // Early-Z优化开关
 
   std::shared_ptr<Shader> shader_;
   std::shared_ptr<Rasterizer> rasterizer_;
 
+  // Rendering constants
+  static constexpr float kMinWValue = 1e-6f;      // W分量检查阈值（避免除零）
+  static constexpr size_t kDefaultTileSize = 64;  // 默认Tile大小（64x64像素）
+
   /**
    * 执行绘制管线
    * @param model 模型
@@ -125,13 +134,6 @@ class SimpleRenderer {
                                         const std::vector<Vertex> &processedVertices,
                                         uint32_t *buffer);
 
-  /**
-   * Tile-based光栅化渲染
-   * @param model 模型
-   * @param processedVertices 已处理的顶点
-   * @param buffer 输出缓冲区
-   * @return 渲染统计信息
-   */
   struct TileRenderStats {
     double setup_ms;
     double binning_ms;
@@ -167,10 +169,8 @@ class SimpleRenderer {
                                              const std::vector<Vertex> &processedVertices,
                                              uint32_t *buffer);
 
-  
 private:
 
-
   // SoA 版本的 Triangle-Tile binning（两遍计数 + reserve）
   void TriangleTileBinning(
     const Model &model,
@@ -191,7 +191,6 @@ class SimpleRenderer {
     bool use_early_z = false,
     std::vector<Fragment>* scratch_fragments = nullptr);
 
-  
   /**
    * 透视除法 - 将裁剪空间坐标转换为归一化设备坐标(NDC)
    * @param vertex 裁剪空间坐标的顶点
@@ -206,6 +205,21 @@ class SimpleRenderer {
    */
   Vertex ViewportTransformation(const Vertex &vertex);
 
+  /**
+   * 打印传统渲染性能统计信息
+   */
+  void PrintTraditionalStats(double vertex_ms, const RenderStats& stats) const;
+  
+  /**
+   * 打印基于Tile渲染性能统计信息
+   */
+  void PrintTileBasedStats(double vertex_ms, const TileRenderStats& stats) const;
+  
+  /**
+   * 打印延迟渲染性能统计信息
+   */
+  void PrintDeferredStats(double vertex_ms, const DeferredRenderStats& stats) const;
+  
 };
 }  // namespace simple_renderer
 

src/include/vertex.hpp

@@ -1,6 +1,9 @@
 #ifndef SIMPLERENDER_SRC_INCLUDE_VERTEX_HPP_
 #define SIMPLERENDER_SRC_INCLUDE_VERTEX_HPP_
 
+#include <vector>
+#include <optional>
+
 #include <math.hpp>
 
 #include "color.h"
@@ -31,18 +34,13 @@ class Vertex {
   // 析构函数
   ~Vertex() = default;
 
-  // Constructor with parameters 带参数的构造函数
-  explicit Vertex(const Vector4f& pos, const Vector3f& norm,
-                  const Vector2f& tex, const Color& color_)
-      : position_(pos), normal_(norm), texCoords_(tex), color_(color_),
-        clip_position_(pos), has_clip_position_(false) {}
-        
-  // 扩展构造函数：包含裁剪空间坐标
+  // Constructor with parameters: optional clip space coordinate
+  // 带参数的构造函数：可选的裁剪空间坐标
   explicit Vertex(const Vector4f& pos, const Vector3f& norm,
                   const Vector2f& tex, const Color& color_,
-                  const Vector4f& clip_pos)
+                  std::optional<Vector4f> clip_pos = std::nullopt)
       : position_(pos), normal_(norm), texCoords_(tex), color_(color_),
-        clip_position_(clip_pos), has_clip_position_(true) {}
+        clip_position_(clip_pos) {}
 
   // Transform the vertex with a matrix     使用矩阵变换顶点
   void transform(const Matrix4f& matrix) { position_ = matrix * position_; }
@@ -55,8 +53,8 @@ class Vertex {
   [[nodiscard]] inline Color GetColor() const { return color_; }
 
   // 扩展坐标访问
-  [[nodiscard]] inline Vector4f GetClipPosition() const { return clip_position_; }
-  [[nodiscard]] inline bool HasClipPosition() const { return has_clip_position_; }
+  [[nodiscard]] inline std::optional<Vector4f> GetClipPosition() const { return clip_position_; }
+  [[nodiscard]] inline bool HasClipPosition() const { return clip_position_.has_value(); }
 
  private:
   Vector4f position_;   // 3D position, 3D顶点坐标
@@ -65,8 +63,7 @@ class Vertex {
   Color color_;
 
   // 扩展坐标用于裁剪优化
-  Vector4f clip_position_; // 裁剪空间坐标 (用于视锥体裁剪)
-  bool has_clip_position_; // 是否包含裁剪坐标
+  std::optional<Vector4f> clip_position_; // 裁剪空间坐标 (用于视锥体裁剪)
 };
 
 inline Vertex operator*(const Matrix4f& matrix, const Vertex& vertex) {
@@ -75,6 +72,26 @@ inline Vertex operator*(const Matrix4f& matrix, const Vertex& vertex) {
                 vertex.GetColor());
 }
 
+// Minimal SoA layout for TBR pipeline
+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

src/include/vertex_soa.hpp

@@ -50,24 +50,13 @@ std::vector<Fragment> Rasterizer::Rasterize(const Vertex& v0, const Vertex& v1,
         }
 
         // 透视矫正插值
-        // 1. 获取三个顶点的1/w值
-        float w0_inv = v0.GetPosition().w;
-        float w1_inv = v1.GetPosition().w;  
-        float w2_inv = v2.GetPosition().w;
+        auto perspective_result = PerformPerspectiveCorrection(
+            v0.GetPosition().w, v1.GetPosition().w, v2.GetPosition().w,
+            v0.GetPosition().z, v1.GetPosition().z, v2.GetPosition().z,
+            barycentric_coord);
 
-        // 2. 插值1/w
-        float w_inv_interpolated = Interpolate(w0_inv, w1_inv, w2_inv, barycentric_coord);
-        
-        // 3. 计算透视矫正的重心坐标
-        Vector3f corrected_bary(
-          barycentric_coord.x * w0_inv / w_inv_interpolated,
-          barycentric_coord.y * w1_inv / w_inv_interpolated,
-          barycentric_coord.z * w2_inv / w_inv_interpolated
-        );
-        
-        // 4. 使用矫正的重心坐标进行插值
-        auto z = Interpolate(v0.GetPosition().z, v1.GetPosition().z,
-                             v2.GetPosition().z, corrected_bary);
+        const Vector3f& corrected_bary = perspective_result.corrected_barycentric;
+        float z = perspective_result.interpolated_z;
 
 
         Fragment fragment;
@@ -114,39 +103,34 @@ void Rasterizer::RasterizeTo(const VertexSoA& soa, size_t i0, size_t i1, size_t
   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)));
+  int sx = std::max(x0, static_cast<int>(std::floor(minx)));
+  int sy = std::max(y0, static_cast<int>(std::floor(miny)));
+  int ex = std::min(x1 - 1, static_cast<int>(std::floor(maxx)));
+  int ey = std::min(y1 - 1, static_cast<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);
+      // 透视矫正插值
+      auto perspective_result = PerformPerspectiveCorrection(
+          p0.w, p1.w, p2.w,
+          p0.z, p1.z, p2.z,
+          bary);
+      
+      const Vector3f& corrected_bary = perspective_result.corrected_barycentric;
+      float z = perspective_result.interpolated_z;
 
-      float z = Interpolate(p0.z, p1.z, p2.z, cb);
-
-      Fragment frag;
+      Fragment frag; // Note: material 指针由调用方填写
       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.normal = Interpolate(soa.normal[i0], soa.normal[i1], soa.normal[i2], corrected_bary);
+      frag.uv     = Interpolate(soa.uv[i0],     soa.uv[i1],     soa.uv[i2],     corrected_bary);
+      frag.color  = InterpolateColor(soa.color[i0], soa.color[i1], soa.color[i2], corrected_bary);
       frag.depth  = z;
-      // material 指针由调用方填写
 
       out.push_back(frag);
     }
@@ -182,14 +166,14 @@ std::pair<bool, Vector3f> Rasterizer::GetBarycentricCoord(const Vector3f& p0,
 
 template <typename T>
 T Rasterizer::Interpolate(const T& v0, const T& v1, const T& v2,
-                          const Vector3f& barycentric_coord) {
+                          const Vector3f& barycentric_coord) const {
   return v0 * barycentric_coord.x + v1 * barycentric_coord.y +
          v2 * barycentric_coord.z;
 }
 
 Color Rasterizer::InterpolateColor(const Color& color0, const Color& color1,
                                    const Color& color2,
-                                   const Vector3f& barycentric_coord) {
+                                   const Vector3f& barycentric_coord) const {
   auto color_r = FloatToUint8_t(
       static_cast<float>(color0[Color::kColorIndexRed]) * barycentric_coord.x +
       static_cast<float>(color1[Color::kColorIndexRed]) * barycentric_coord.y +
@@ -208,6 +192,31 @@ Color Rasterizer::InterpolateColor(const Color& color0, const Color& color1,
   return Color(color_r, color_g, color_b);
 }
 
+// 透视矫正helper函数：在透视投影下，1/w 在屏幕空间中是线性的// 因此需要先对 1/w 进行插值，再用结果矫正其他属性
+Rasterizer::PerspectiveCorrectionResult Rasterizer::PerformPerspectiveCorrection(
+    float w0, float w1, float w2,
+    float z0, float z1, float z2,
+    const Vector3f& original_barycentric) const {
+    
+  // 1. 插值 1/w （注意：这里传入的w0,w1,w2是原始的w值，需要先求倒数）
+  float w0_inv = 1.0f / w0;
+  float w1_inv = 1.0f / w1;
+  float w2_inv = 1.0f / w2;
+  float w_inv_interpolated = Interpolate(w0_inv, w1_inv, w2_inv, original_barycentric);
+  
+  // 2. 计算透视矫正的重心坐标
+  Vector3f corrected_barycentric(
+      original_barycentric.x * w0_inv / w_inv_interpolated,
+      original_barycentric.y * w1_inv / w_inv_interpolated,
+      original_barycentric.z * w2_inv / w_inv_interpolated
+  );
+  
+  // 3. 使用矫正的重心坐标插值深度值
+  float interpolated_z = Interpolate(z0, z1, z2, corrected_barycentric);
+  
+  return {corrected_barycentric, interpolated_z};
+}
+
 // Calculate the normal vector based on the vertices
 // 根据顶点计算法向量
 Vector3f Rasterizer::CalculateNormal(const Vector3f& v0, const Vector3f& v1,