🖥️ 第23课：延迟渲染基础

学习目标：掌握延迟渲染基础的核心原理与Verilog实现。

📋 核心概念

本课深入探讨延迟渲染基础的硬件实现。理解其数学基础和算法流程是设计高效GPU模块的关键。

• 核心算法：延迟渲染基础的标准实现方法
• 数据流：输入数据如何经过变换产生输出
• 边界条件：特殊情况的处理策略

🔍 数学原理

定点数实现时需注意精度和溢出问题，Q4.12格式提供足够的动态范围。

🔧 Verilog实现：延迟渲染器

//====================================================================
// deferred_renderer.v - 延迟渲染器
// 第23课：G-Buffer生成与光照pass
//====================================================================
module deferred_renderer #(
    parameter COORD_WIDTH = 16,
    parameter COLOR_WIDTH = 24,
    parameter GBUF_WIDTH  = 80,  // G-Buffer总位宽
    parameter ADDR_WIDTH  = 20,
    parameter FRAC_BITS   = 12
)(
    input  wire                          clk, rst_n,
    // Geometry Pass输入
    input  wire                          geom_valid,
    input  wire [ADDR_WIDTH-1:0]         geom_addr,
    input  wire [COLOR_WIDTH-1:0]        geom_albedo,
    input  wire signed [COORD_WIDTH-1:0] geom_nx, geom_ny, geom_nz,
    input  wire signed [COORD_WIDTH-1:0] geom_depth,
    output reg                           geom_ready,
    // Lighting Pass输入
    input  wire                          light_valid,
    input  wire [ADDR_WIDTH-1:0]         light_addr,
    input  wire signed [COORD_WIDTH-1:0] light_dir_x, light_dir_y, light_dir_z,
    input  wire [COLOR_WIDTH-1:0]        light_color,
    output reg                           light_ready,
    // 最终输出
    output reg                           result_valid,
    output reg  [ADDR_WIDTH-1:0]         result_addr,
    output reg  [COLOR_WIDTH-1:0]        result_color
);
    // G-Buffer存储(简化版: albedo + normal + depth)
    reg [COLOR_WIDTH-1:0]   gbuf_albedo [0:255];
    reg [COORD_WIDTH-1:0]   gbuf_nx [0:255], gbuf_ny [0:255], gbuf_nz [0:255];
    reg [COORD_WIDTH-1:0]   gbuf_depth [0:255];
    // 光照计算
    reg signed [2*COORD_WIDTH-1:0] dot_nl;
    reg [7:0] diff_factor;
    reg [7:0] alb_r, alb_g, alb_b;
    reg [7:0] lit_r, lit_g, lit_b;
    localparam S_GEOM=3'd0, S_LIGHT_READ=3'd1, S_LIGHT_CALC=3'd2, S_LIGHT_OUT=3'd3;
    reg [2:0] state;
    always @(posedge clk or negedge rst_n) begin
        if (!rst_n) begin state<=S_GEOM; geom_ready<=1; light_ready<=0; result_valid<=0; end
        else begin
            result_valid <= 0;
            case (state)
                S_GEOM: begin
                    geom_ready <= 1; light_ready <= 0;
                    if (geom_valid) begin
                        geom_ready <= 0;
                        gbuf_albedo[geom_addr[7:0]] <= geom_albedo;
                        gbuf_nx[geom_addr[7:0]] <= geom_nx;
                        gbuf_ny[geom_addr[7:0]] <= geom_ny;
                        gbuf_nz[geom_addr[7:0]] <= geom_nz;
                        gbuf_depth[geom_addr[7:0]] <= geom_depth;
                    end
                    light_ready <= 1; // 两个pass并行
                end
                S_LIGHT_READ: begin
                    light_ready <= 1;
                    if (light_valid) begin
                        light_ready <= 0;
                        alb_r <= gbuf_albedo[light_addr[7:0]][23:16];
                        alb_g <= gbuf_albedo[light_addr[7:0]][15:8];
                        alb_b <= gbuf_albedo[light_addr[7:0]][7:0];
                        dot_nl = gbuf_nx[light_addr[7:0]] * light_dir_x +
                                 gbuf_ny[light_addr[7:0]] * light_dir_y +
                                 gbuf_nz[light_addr[7:0]] * light_dir_z;
                        state <= S_LIGHT_CALC;
                    end
                end
                S_LIGHT_CALC: begin
                    diff_factor = (dot_nl > 0) ? ((dot_nl[19:12]>255)?8'd255:dot_nl[19:12]) : 8'd0;
                    lit_r <= (alb_r * diff_factor) >> 8;
                    lit_g <= (alb_g * diff_factor) >> 8;
                    lit_b <= (alb_b * diff_factor) >> 8;
                    result_addr <= light_addr;
                    state <= S_LIGHT_OUT;
                end
                S_LIGHT_OUT: begin
                    result_color <= {lit_r, lit_g, lit_b};
                    result_valid <= 1; state <= S_GEOM;
                end
                default: state <= S_GEOM;
            endcase
        end
    end
endmodule

🧪 仿真验证

`timescale 1ns/1ps
module tb_deferred_renderer;
    parameter CLK_PERIOD = 10;
    reg clk, rst_n;
    // 添加具体接口信号...
    deferred_renderer dut (.*);
    initial clk = 0; always #(CLK_PERIOD/2) clk = ~clk;
    initial begin
        rst_n = 0; #(CLK_PERIOD*5); rst_n = 1; #(CLK_PERIOD*2);
        $display("=== deferred_renderer 测试开始 ===");
        // 测试逻辑...
        #(CLK_PERIOD*100);
        $display("=== deferred_renderer 测试完成 ===");
        $finish;
    end
endmodule

📐 性能分析

延迟渲染基础模块在100MHz时钟下可达到每周期处理一个数据单元的吞吐率。关键路径在乘法器和加法器链上。

🏗️ 与前课的关联

本课模块承接前课的输出数据，处理后的结果传递给下一课。整个管线模块间的接口定义保持一致。

🧩 练习题

🎯 本课小结

📚 延伸阅读与行业标准

🔧 硬件实现考量

在实际GPU芯片设计中，延迟渲染模块面临以下挑战：

• 面积优化：乘法器占用大量硅面积，需要复用和时分
• 功耗控制：高频运算产生大量动态功耗，需要时钟门控
• 时序收敛：乘法器链路是关键路径，可能需要插入流水线寄存器
• 存储带宽：顶点数据的读写带宽是瓶颈

🌐 跨平台实现对比

🧪 验证策略

对延迟渲染模块的验证应包含以下方面：

1. 功能验证：基本输入输出的正确性
2. 边界测试：零值、最大值、最小值、溢出情况
3. 随机测试：大量随机输入的回归测试
4. 对比验证：与软件参考模型的输出对比
5. 时序验证：流水线停顿、反压等场景

📈 性能基准

在现代FPGA平台上的典型性能指标：

// 性能基准（Artix-7 @ 100MHz）
// - 顶点吞吐率: 10M vertices/s (单核)
// - 延迟: 3周期 (30ns)
// - DSP占用: 12个 (Q4.12乘法)
// - 最大时钟: ~150MHz (时序约束后)
// - 功耗: ~50mW (动态功耗估算)

🔗 与其他课程的关联

📖 推荐资源

• 《Real-Time Rendering》第4版 - Tomas Akenine-Möller
• 《GPU Gems》系列 - NVIDIA
• 《Digital Design and Computer Architecture》- Harris & Harris
• OpenGL规范: khronos.org/opengl
• Verilator文档: veripool.org/verilator

🔬 延迟渲染的深入分析

从硬件设计角度，延迟渲染模块需要满足严格的时序和面积约束。以下分析关键路径和优化空间。

关键路径分析

模块的关键路径通常在乘法器链上。Q4.12格式的16×16位乘法器在FPGA上需要约5ns，级联两级乘法器约10ns，这决定了最大工作频率约为100MHz。

// 关键路径示例
// 输入 → 乘法器1(5ns) → 加法器(2ns) → 乘法器2(5ns) → 输出
// 总延迟: 12ns → 最大频率 ≈ 83MHz
//
// 优化: 插入流水线寄存器
// Stage1: 乘法器1(5ns) → 寄存器
// Stage2: 加法器(2ns) + 乘法器2(5ns) → 寄存器
// 最大频率 ≈ 143MHz

面积优化策略

• 时分复用：用1个乘法器分时完成多个乘法运算
• 资源共享：多个路径共享同一个加法器
• 精度降低：Q4.8格式可减少乘法器面积50%
• CSD编码：常数乘法用CSD(正则有符号数)编码

功耗优化策略

• 时钟门控：当模块空闲时关闭时钟
• 操作数隔离：当输入无效时将乘法器输入置零
• 电压缩放：在性能允许时降低供电电压

📊 与软件实现的对比

硬件实现在延迟和吞吐率上有显著优势，特别适合实时渲染场景。

🧩 进阶练习