Remove unused functions and scatch containers

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

Author: indevn

src/include/rasterizer.hpp

@@ -33,41 +33,6 @@ class Rasterizer {
   std::vector<Fragment> Rasterize(const Vertex& v0, const Vertex& v1,
                                   const Vertex& v2);
 
-  /**
-   * @brief 非分配版本：将片段直接写入调用方提供的容器
-   * 
-   * 可选的裁剪区域为半开区间 [x0, x1) × [y0, y1)
-   * 用于 TBR：将光栅化限制在 tile 边界内，便于复用外部 scratch 容器
-   * 
-   * @param v0 三角形第一个顶点
-   * @param v1 三角形第二个顶点
-   * @param v2 三角形第三个顶点
-   * @param x0 裁剪区域左边界（包含）
-   * @param y0 裁剪区域上边界（包含）
-   * @param x1 裁剪区域右边界（不包含）
-   * @param y1 裁剪区域下边界（不包含）
-   * @param out 输出片段容器
-   */
-  void RasterizeTo(const Vertex& v0, const Vertex& v1, const Vertex& v2,
-                   int x0, int y0, int x1, int y1,
-                   std::vector<Fragment>& out);
-
-  /**
-   * @brief SoA 版本：按顶点索引从 SoA 读取三角形三顶点
-   * @param soa 结构体数组格式的顶点数据
-   * @param i0 三角形第一个顶点索引
-   * @param i1 三角形第二个顶点索引
-   * @param i2 三角形第三个顶点索引
-   * @param x0 裁剪区域左边界（包含）
-   * @param y0 裁剪区域上边界（包含）
-   * @param x1 裁剪区域右边界（不包含）
-   * @param y1 裁剪区域下边界（不包含）
-   * @param out 输出片段容器
-   */
-  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/renderers/tile_based_renderer.hpp

@@ -103,7 +103,6 @@ class TileBasedRenderer final : public RendererBase {
    * @param soa 经过变换后的 SoA 顶点数据
    * @param shader 着色器
    * @param use_early_z 是否启用 Early‑Z
-   * @param scratch_fragments 可复用片段临时容器
    */
   void RasterizeTile(size_t tile_id,
                      const std::vector<TileTriangleRef> &triangles,
@@ -113,7 +112,6 @@ class TileBasedRenderer final : public RendererBase {
                      std::unique_ptr<uint32_t[]> &global_color_buffer,
                      const Shader& shader,
                      bool use_early_z,
-                     std::vector<Fragment>* scratch_fragments,
                      TileMaskStats* out_stats);
 
  private:

src/rasterizer.cpp

@@ -81,159 +81,6 @@ std::vector<Fragment> Rasterizer::Rasterize(const Vertex& v0, const Vertex& v1,
   return fragments;
 }
 
-void Rasterizer::RasterizeTo(const Vertex& v0, const Vertex& v1, const Vertex& v2,
-                             int x0, int y0, int x1, int y1,
-                             std::vector<Fragment>& out) {
-  // 获取三角形的最小 box（屏幕空间）
-  const Vector4f p0 = v0.GetPosition();
-  const Vector4f p1 = v1.GetPosition();
-  const Vector4f p2 = v2.GetPosition();
-
-  Vector2f a(p0.x, p0.y);
-  Vector2f b(p1.x, p1.y);
-  Vector2f c(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, 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;
-
-  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;
-
-      // 透视矫正插值
-      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;
-
-      Fragment frag; // material 指针由调用方填写
-      frag.screen_coord = {x, y};
-      frag.normal = Interpolate(v0.GetNormal(), v1.GetNormal(), v2.GetNormal(), corrected_bary);
-      frag.uv     = Interpolate(v0.GetTexCoords(), v1.GetTexCoords(), v2.GetTexCoords(), corrected_bary);
-      frag.color  = InterpolateColor(v0.GetColor(), v1.GetColor(), v2.GetColor(), corrected_bary);
-      frag.depth  = z;
-
-      out.push_back(frag);
-    }
-  }
-}
-
-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];
-
-  // 为BarycentricCoord预构造Vec3f，避免循环内重复构造
-  const Vector3f sp0(p0.x, p0.y, p0.z);
-  const Vector3f sp1(p1.x, p1.y, p1.z);
-  const Vector3f sp2(p2.x, p2.y, p2.z);
-
-  // 计算屏幕空间AABB包围盒
-  const float minx_f = std::max(0.0f, std::min({p0.x, p1.x, p2.x}));
-  const float miny_f = std::max(0.0f, std::min({p0.y, p1.y, p2.y}));
-  const float maxx_f = std::min(float(width_  - 1), std::max({p0.x, p1.x, p2.x}));
-  const float maxy_f = std::min(float(height_ - 1), std::max({p0.y, p1.y, p2.y}));
-
-  // 与外部提供的裁剪区域相交（半开区间） -> 闭区间扫描
-  int sx = std::max(x0, static_cast<int>(std::floor(minx_f)));
-  int sy = std::max(y0, static_cast<int>(std::floor(miny_f)));
-  int ex = std::min(x1 - 1, static_cast<int>(std::floor(maxx_f)));
-  int ey = std::min(y1 - 1, static_cast<int>(std::floor(maxy_f)));
-  if (sx > ex || sy > ey) return;
-
-  // 预计算边函数系数：E(x,y) = A*x + B*y + C
-  // 使用相对坐标的边函数定义，避免大常数项导致的数值不稳定
-  // 如使用绝对形式Ax+By+C会由于常数C的量级过大，造成浮点抵消，有效位丢失不稳定
-  auto cross2 = [](float ax, float ay, float bx, float by) {
-    return ax * by - ay * bx;
-  };
-  // 边向量
-  const float e01x = p1.x - p0.x, e01y = p1.y - p0.y; // (p0->p1)
-  const float e12x = p2.x - p1.x, e12y = p2.y - p1.y; // (p1->p2)
-  const float e20x = p0.x - p2.x, e20y = p0.y - p2.y; // (p2->p0)
-
-  // 有向面积（两倍），用相对面积定义：area2 = cross(p1 - p0, p2 - p0)
-  float area2 = cross2(e01x, e01y, p2.x - p0.x, p2.y - p0.y);
-  if (std::abs(area2) < 1e-6f) return; // 退化三角形
-  const float inv_area2 = 1.0f / area2;
-  const bool positive = (area2 > 0.0f);
-
-  // 行优先遍历：有利于 cache 与向量化
-  #pragma omp simd
-  for (int y = sy; y <= ey; ++y) {
-    const float yf = static_cast<float>(y);
-
-    // 注意：此处存在对 out.push_back 的写入，属于有副作用操作，不适合使用
-    // omp simd 进行强制向量化，否则可能导致不符合预期的行为（如周期性伪影）。
-    // 先保持标量内层，后续如切换为“直写像素回调”再考虑安全的 SIMD 化。
-    for (int x = sx; x <= ex; ++x) {
-      const float xf = static_cast<float>(x);
-
-      // 相对坐标边函数：
-      // E01(p) = cross(p1 - p0, p - p0)
-      // E12(p) = cross(p2 - p1, p - p1)
-      // E20(p) = cross(p0 - p2, p - p2)
-      const float E01 = cross2(e01x, e01y, xf - p0.x, yf - p0.y);
-      const float E12 = cross2(e12x, e12y, xf - p1.x, yf - p1.y);
-      const float E20 = cross2(e20x, e20y, xf - p2.x, yf - p2.y);
-
-      // 半空间测试（根据朝向选择符号）
-      const bool inside = positive ? (E01 >= 0.0f && E12 >= 0.0f && E20 >= 0.0f)
-                                   : (E01 <= 0.0f && E12 <= 0.0f && E20 <= 0.0f);
-      if (!inside) continue;
-
-      // 重心权重映射：
-      // b0 对应 v0，取与对边 (v1,v2) 的子面积 → E12
-      // b1 对应 v1 → E20
-      // b2 对应 v2 → E01
-      const float b0 = E12 * inv_area2;
-      const float b1 = E20 * inv_area2;
-      const float b2 = E01 * inv_area2;
-      const Vector3f bary(b0, b1, b2);
-
-      // 透视矫正插值
-      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;
-      const float z = perspective_result.interpolated_z;
-
-      Fragment frag; // Note: material 指针由调用方填写
-      frag.screen_coord = {x, y};
-      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;
-
-      out.push_back(frag);
-    }
-  }
-}
-
 std::pair<bool, Vector3f> Rasterizer::GetBarycentricCoord(const Vector3f& p0,
                                                           const Vector3f& p1,
                                                           const Vector3f& p2,

src/renderers/tile_based_renderer.cpp

@@ -100,18 +100,14 @@ bool TileBasedRenderer::Render(const Model &model, const Shader &shader_in,
     std::unique_ptr<uint32_t[]> tile_color_buffer =
         std::make_unique<uint32_t[]>(grid_ctx.tile_size * grid_ctx.tile_size);
 
-    // 为每个 tile 分配可复用片段临时容器，容量按单 tile 上限预估
-    std::vector<Fragment> scratch_fragments;
-    scratch_fragments.reserve(grid_ctx.tile_size * grid_ctx.tile_size);
-
 #pragma omp for schedule(static)
     for (size_t tile_id = 0; tile_id < total_tiles; ++tile_id) {
       // 按照 tile 进行光栅化（SoA）
       // 直接写入单份全局 framebuffer；不同 tile 不重叠，无需加锁
       RasterizeTile(tile_id, tile_triangles[tile_id], grid_ctx,
                     tile_depth_buffer.get(), tile_color_buffer.get(),
                     depthBuffer, colorBuffer, *shader, early_z_,
-                    &scratch_fragments, &tile_stats[tile_id]);
+                    &tile_stats[tile_id]);
     }
   }
   auto raster_end = std::chrono::high_resolution_clock::now();
@@ -129,7 +125,7 @@ bool TileBasedRenderer::Render(const Model &model, const Shader &shader_in,
     sum_shaded  += s.shaded;
   }
   auto rate = [](uint64_t num, uint64_t den) -> double {
-    if (den == 0) return 0.0; return double(num) / double(den) * 100.0;
+    return (den == 0)?0.0:double(num) / double(den) * 100.0;
   };
   SPDLOG_DEBUG(
       "TBR Mask Stats: tested={}, covered={} ({:.1f}%), zpass={} ({:.1f}%), shaded={} ({:.1f}%)",
@@ -220,7 +216,6 @@ void TileBasedRenderer::RasterizeTile(
     uint32_t *tile_color_buffer, std::unique_ptr<float[]> &global_depth_buffer,
     std::unique_ptr<uint32_t[]> &global_color_buffer,
     const Shader &shader, bool use_early_z,
-    std::vector<Fragment> *scratch_fragments,
     TileMaskStats* out_stats) {
   // 计算 tile 屏幕范围
   size_t tile_x = tile_id % grid.tiles_x;