实时渲染中的工业界技术

cascaded shading

Cascaded Shadow Maps(CSM)——按距离分层 shadow map。

为什么

一张 4096² 的 shadow map 覆盖 500m 的场景
  → 每米约 8 个纹素
  → 近处(1m 的物体)只有 8 个纹素 → 阴影锯齿明显

分 4 层:
  第 0 层覆盖 0~10m  → 每米 400 纹素  ← 近处极清晰
  第 3 层覆盖 100~500m → 每米 8 纹素   ← 远处够用

实现要点

分割位置的选择(对数分割更合理):

spliti=n⋅(fn)i/N\text{split}_i = n \cdot \left(\frac{f}{n}\right)^{i/N}

纯对数会让近处过密,实践中常用对数 + 均匀的混合:

di=λ⋅n(fn)i/N+(1−λ)⋅(n+iN(f−n))d_i = \lambda \cdot n\left(\frac{f}{n}\right)^{i/N} + (1-\lambda) \cdot \left(n + \frac{i}{N}(f-n)\right)

λ≈0.5\lambda \approx 0.5,可以在"近处质量"和"远处质量"间调节。

层间过渡:

// 在层边界的混合区做跨层采样
float cascadeBlend = smoothstep(0.9, 1.0, (viewZ - splitStart) / (splitEnd - splitStart));
float s0 = sampleShadow(cascade_i);
float s1 = sampleShadow(cascade_{i+1});
shadow = mix(s0, s1, cascadeBlend);

稳定化(texel snapping):

问题: 相机移动时,shadow map 的投影矩阵跟着变 → 纹素不对齐 → 阴影边缘抖动(shimmering)

解法: 把光源的正交投影矩阵"吸附"到纹素网格上
  orthoSize = ceil(orthoSize / texelSize) * texelSize
  并把光源位置对齐到纹素边界

这一条极其重要——不做的话阴影边缘会有持续的"爬动",非常明显。

其他变体:

  • Cascaded shadow + 缓存:静态物体只更新一次
  • Virtual Shadow Maps(UE5):16K 虚拟纹理,按需分配页面

tiled shading

前向渲染的问题

前向渲染: 每个物体对每个光源都着色一遍
  → 复杂度 O(物体数 × 光源数)
  → 100 个光源 → 灾难

更糟的是:大部分像素只被少数光源照到,做了大量无用功。

Tiled / Clustered 的思路

把屏幕分成小块(tile),只给每块分配"真正影响它的光源"。

Tiled:     屏幕空间 2D 分块(如 16×16 像素),每块一个光源列表
Clustered: 3D 分块(屏幕 XY + 深度 Z),更精确
屏幕分成 16×16 的 tile
┌───┬───┬───┐
│ 3 │ 0 │ 5 │   数字 = 该 tile 的光源数
├───┼───┼───┤
│ 1 │ 8 │ 2 │
└───┴───┴───┘
每个 tile 只处理它自己的光源列表

实现(计算着色器)

// Pass 1: 光源剔除
[numthreads(16, 16, 1)]
void CullLights(uint3 groupId : SV_GroupID) {
    // 1. 由 tile 的屏幕范围 + 深度范围构造 AABB(视锥的一部分)
    float tileMinZ, tileMaxZ;      // 从深度缓冲求 min/max
    AABB tileAABB = buildAABB(groupId, tileMinZ, tileMaxZ);

    // 2. 遍历所有光源,判断是否与 AABB 相交
    for (uint i = 0; i < numLights; i++) {
        if (intersects(light[i], tileAABB))
            tileLightList[groupId].append(i);
    }
}

// Pass 2: 着色
[numthreads(16, 16, 1)]
void Shade(uint3 groupId, uint3 groupThreadId) {
    uint2 pixel = groupId.xy * 16 + groupThreadId.xy;
    // 只遍历本 tile 的光源
    for (uint i = 0; i < tileLightList[groupId].count; i++) {
        shade(pixel, tileLightList[groupId][i]);
    }
}

关键优化:用 depth 的 min/max 构造 3D AABB,去掉在该深度范围内没有贡献的光源。

对比

光源数量备注
前向~8每物体遍历所有光
Deferred~1000但带宽大,不透明-only,MSAA 难
Tiled Deferred数千主流
Clustered数万3D 分块,更精确
Forward+数千前向 + tile 剔除,支持 MSAA/透明

Forward+(Tiled Forward) 是另一个方向:保留前向渲染(支持 MSAA 和透明),但用 tile 剔除减少光源。UE、很多手游引擎用它。

deferred shading

思路

把"几何"和"着色"分离。

Pass 1 (Geometry Pass):
  渲染所有物体,只输出材质参数到 G-buffer:
    - albedo (RGB)
    - normal (RGB, 或压缩成 2)
    - depth
    - roughness, metallic, ...
  不做光照计算

Pass 2 (Lighting Pass):
  对每个像素,用 G-buffer 的数据计算光照
  只需遍历影响该像素的光源

为什么好

前向渲染:被遮挡的物体也会着色(浪费)。

深度复杂度(overdraw):
  场景里 10 层物体重叠 → 前向渲染着色 10 次,只有 1 次可见
  Deferred: 着色只做 1 次(G-buffer 只保留最前面的)

复杂度从O(几何×光源)O(\text{几何} \times \text{光源}) 降到O(几何+像素×光源)O(\text{几何} + \text{像素} \times \text{光源})。

G-buffer 的内存问题

典型 G-buffer(1080p, 32bit/通道):
  albedo:      RGBA8     = 4 bytes
  normal:      RGBA8     = 4 bytes  (或 RG16 存八面体编码)
  material:    RGBA8     = 4 bytes  (roughness, metallic, AO, ...)
  depth:       D32       = 4 bytes
  ─────────────────────────────────
  合计约 16 bytes/像素 × 2M 像素 = 32 MB (1080p)
         4K 下 128 MB

这是 deferred 的主要代价——带宽。

优化:

  • 法线编码:八面体编码(Octahedral)用 2 通道存 3 分量
  • 材质压缩:用较少的位(roughness 5 bit 够)
  • Thin G-buffer:只存最少信息,其余从材质 ID 查表

Deferred 的问题

问题后果
不支持透明G-buffer 只存一层 → 透明要单独用前向渲染
MSAA 困难硬件 MSAA 对 MRT 无效(DX10 后可用,但内存爆炸)→ 只能靠 FXAA/TAA
内存带宽大G-buffer 读写是主要瓶颈
材质种类受限所有物体用同一套材质参数 → 特殊材质难处理

Deferred vs Forward 的现代选择

大量光源 (>100)          → Deferred / Clustered
需要 MSAA、透明材质      → Forward+
移动端(带宽敏感)        → Forward+ 或 Tile-Based Deferred(用片上内存)

移动端的关键:Tile-Based Rendering(TBR)——把 tile 的 G-buffer 放在片上内存(on-chip memory),不写回主存。这样 deferred 的带宽问题在移动端被大幅缓解。PowerVR、Adreno、Mali 都是这个架构。

particles

粒子系统的组成

1. 粒子数据: 位置、速度、生命、颜色、大小、旋转
2. 模拟(Simulation): 更新位置、速度(CPU 或 GPU)
3. 渲染(Rendering): billboard / mesh / ribbon

GPU 粒子

现代游戏粒子数量可达百万级,必须用 GPU。

两种实现:

方式做法优点
Compute + Indirect Drawcompute shader 更新粒子,用 DrawIndirect 绘制灵活,可排序
Vertex Shader 拉取粒子数据存纹理/Buffer,VS 里按 vertexID 读取简单
// GPU 粒子更新(compute)
[numthreads(64, 1, 1)]
void Update(uint3 id : SV_DispatchThreadID) {
    Particle p = particles[id.x];
    p.velocity += gravity * dt;
    p.position += p.velocity * dt;
    p.life -= dt;
    if (p.life <= 0) p = spawnNew(id.x);      // 死亡则重生
    particles[id.x] = p;
}

关键问题:排序。半透明粒子必须按深度排序才能正确混合。

  • 完全排序太贵 → 常用近似排序(按 tile 排序、或按生成顺序)
  • 或者用加性混合(不透明排序无关)——火花、光效用得多

渲染方式

类型适用特点
Billboard烟雾、火花永远面向相机的四边形
Mesh 粒子碎片、树叶真实几何
Ribbon / Trail拖尾、刀光沿轨迹生成条带
Beam激光两点的圆柱

Billboard 的实现:

// 在 VS 里用相机的 right/up 构造四边形
float3 right = viewMatrix[0].xyz;
float3 up    = viewMatrix[1].xyz;
float3 worldPos = center + right * (vertex.x * size) + up * (vertex.y * size);

Soft Particle(软粒子):

问题: 粒子 quad 与场景几何相交时,会有硬边(很假)

解法: 比较粒子的深度和场景深度,按差值淡出
  fade = saturate((sceneDepth - particleDepth) / softness)

这是粒子效果看起来"专业"的关键细节。

粒子与光照

  • Unlit:简单,自发光(火花)
  • Lit:用一个近似的法线(billboard 法线 = 朝相机,或用一个"球形法线")
  • 光照粒子:把粒子当作光源(大量时太贵,通常只取几个主粒子)

性能

瓶颈通常是 overdraw(半透明重叠)
  → 烟雾粒子叠加 10 层 → 10 倍的像素填充

优化:
  1. 减少粒子大小(overdraw 与面积成正比)
  2. 降低分辨率渲染粒子(半分辨率 + 上采样)
  3. 用更少的、更大的粒子
  4. 距离 LOD

半分辨率粒子渲染是常用的优化:粒子通常模糊,半分辨率看不出来,但能省 4 倍填充率。

其他工业界重要技术

GPU Driven Rendering

把剔除(culling)放到 GPU:

1. 所有物体的包围盒存在 GPU
2. Compute shader 做视锥剔除 + 遮挡剔除
3. 生成可见物体的 draw call 列表
4. DrawIndirect / ExecuteIndirect 一次性绘制

价值:draw call 数从几千降到几个。UE5 的 Nanite 就建立在这个基础上。

配合:

  • 虚拟纹理(Virtual Texture):纹理按需加载
  • virtual geometry(Nanite):几何按 LOD 自动选择,甚至亚三角形级

Occlusion Culling

方法做法
硬件遮挡查询(HOQ)用 GPU 查询包围盒是否可见(有延迟)
Hierarchical Z(Hi-Z)用深度金字塔快速剔除
软件光栅化遮挡体用大遮挡体(墙)剔除
预计算 PVS离线算好每个区域可见什么(老式室内关卡)

LOD(Level of Detail)

按距离选择不同精度的模型
  → 远处用低模
  → 配合 morphing 避免突变(LOD  popping)

HLOD:把远处的一片物体合并成一个低模。

时间性优化

很多昂贵的东西可以分摊到多帧:

技术分摊什么
异步计算用空闲的 GPU 单元
分帧更新阴影、GI、粒子模拟
时域累积采样数

常见坑

  • CSM 没做 texel snapping:阴影边缘持续抖动
  • G-buffer 的法线压缩损失:八面体编码要注意精度,低精度会导致高光异常
  • deferred 的透明:必须另开前向 pass,且要小心深度测试
  • 粒子的排序:半透明粒子排序错误会导致闪烁
  • overdraw:大规模粒子是最容易拖垮填充率的
  • compute shader 的线程利用率:粒子数不是 64 的倍数时会有浪费的线程
  • Indirect Draw 的调试困难:出问题时很难定位(看不到 draw call)
  • 移动端带宽:G-buffer 在移动端是致命的,一定要用 TBR 架构或 forward+