5220 字

26 分钟

计算机图形学笔记(六)：现代图形学前沿

2025-07-25

计算机图形学

C++

/

编程

/

计算机图形学

/

OpenGL

NOTE
前五部分把离线渲染、几何、动画、物理四根主轴讲完了。这部分走现代前沿——实时渲染里真正在跑的东西（PBR 管线、硬件光线追踪、GPGPU），以及还在研究前线的东西（神经渲染、XPBD、SPH）。主题很多，但它们之间都是前五部分积木的组合：PBR = Part 4 的渲染方程 + GGX；RTX = Part 4 求交 + BVH 的硬件化；NeRF/3DGS = 把 Part 4 的体积渲染微分化。每节都会指出它靠的是前面哪一块。

目录#

实时渲染优化 — LOD / 视锥剔除 / 遮挡查询 / 实例化批处理
基于物理的渲染 (PBR) — Cook-Torrance 完整实现 / 能量守恒 / IBL
硬件光线追踪（RTX / DXR） — 加速结构 / 着色器表 / 去噪 / ReSTIR
体积渲染与参与介质 — 体渲染方程 / Ray marching / 云
GPGPU 与计算着色器 — 工作组模型 / 并行前缀和 / GPU 粒子
神经渲染 — NeRF / 3D Gaussian Splatting
现代物理仿真 — XPBD / SPH / FEM 概览

三十一、实时渲染优化#

WARNING
实时引擎的帧预算只有 16 ms（60 FPS）或 8 ms（VR/120 Hz）。靠”算得快”走不远，真正的瓶颈永远是少算、不算、批着算。三板斧：LOD（远处少算）、剔除（不可见不算）、实例化（同东西一次算完）。

31.1 层次细节（LOD）#

31.1.1 距离与屏幕空间误差#

距离 LOD 是最朴素的做法：

\text{LOD}_\text{level} = \lfloor \log_2(d / d_\text{base}) \rfloor

但真正正确的指标是屏幕空间误差——远处一个三角形投影到屏幕只占 0.1 像素时，简化它眼睛察觉不到：

\epsilon_\text{screen} = \frac{\epsilon_\text{world} \cdot f}{d \cdot p}

其中 $f$ 为焦距、 $p$ 为像素尺寸、 $d$ 为视距。 $\epsilon_\text{world}$ 由 QEM 简化（Part 3 §15.3）给出——这是 Part 3 的网格简化直接产出的量。

31.1.2 LOD 链的构造#

1
// 连续 LOD 链：每级三角数减半，误差单调上升
2
struct LODLevel {
3
    Mesh   mesh;
4
    float  distance_threshold;   // 切换阈值
5
    float  geometric_error;      // 世界空间误差
6
};
7

8
class LODChain {
9
    std::vector<LODLevel> levels_;
10
public:
11
    void build(const Mesh& hi, int num_levels) {
12
        levels_.resize(num_levels);
13
        levels_[0] = { hi, 0.f, 0.f };
14
        for (int i = 1; i < num_levels; ++i) {
15
            // Part 3 §15.3 的 QEM 简化
16
            levels_[i].mesh = qem_simplify(hi, std::pow(0.5f, i));
17
            levels_[i].geometric_error = hausdorff(hi, levels_[i].mesh);
18
            levels_[i].distance_threshold = 10.f * std::pow(2.f, i);
19
        }
20
    }
21
    const Mesh& pick(float distance) const {
22
        for (int i = levels_.size() - 1; i >= 0; --i)
23
            if (distance >= levels_[i].distance_threshold) return levels_[i].mesh;
24
        return levels_[0].mesh;
25
    }
26
};

TIP
Nanite（UE5）彻底放弃离散 LOD 链，改成 cluster hierarchy：网格切成 128 面的 cluster，运行时按屏幕像素误差在 BVH 里选一个切面。但底层的简化算法仍然是 QEM 的现代变体。

31.2 视锥剔除#

从 MVP 矩阵 $\mathbf{P}\mathbf{V}$ 抽出六个平面：

\mathbf{n}_\text{left} = \text{row}_3 + \text{row}_0, \qquad \mathbf{n}_\text{right} = \text{row}_3 - \text{row}_0, \ \dots

用 AABB 的 p-vertex / n-vertex 技巧避免 8 个顶点全测：

1
bool aabb_in_frustum(const AABB& box, const Plane frustum[6]) {
2
    for (const auto& pl : frustum) {
3
        // 选 p-vertex：沿法线方向最远的 AABB 角点
4
        Eigen::Vector3f p;
5
        p.x() = pl.n.x() >= 0 ? box.max.x() : box.min.x();
6
        p.y() = pl.n.y() >= 0 ? box.max.y() : box.min.y();
7
        p.z() = pl.n.z() >= 0 ? box.max.z() : box.min.z();
8
        if (pl.n.dot(p) + pl.d < 0) return false;   // 完全在外侧
9
    }
10
    return true;
11
}

复杂度:每对象 6 次点积，O(n)。进一步用 BVH 层次剔除可降到 O(log n)。

31.3 遮挡查询与 Hi-Z 剔除#

视锥剔除只排除”看不到的方向”。被前景挡住的物体同样浪费：

硬件遮挡查询（GL_SAMPLES_PASSED）:上一帧绘制一次代理几何体，统计通过深度测试的片元数。延迟一帧，容易卡渲染流水线。
Hi-Z（Hierarchical Z）:深度缓冲按 mipmap 降采样，每级存最大深度。测一个 AABB 遮挡只需从对应 mip 读一个 texel 对比——GPU 一次 tex lookup 搞定，现代引擎（Frostbite/UE）的主力。

31.4 实例化批处理#

同一网格 + 不同变换 的场景（树林、砖墙、雪粒子），用实例化把 N 次 draw call 压成 1 次：

1
// 每实例 attributes：model_matrix(16B×4) + color(16B)
2
glBindBuffer(GL_ARRAY_BUFFER, instance_vbo);
3
glBufferData(GL_ARRAY_BUFFER, N * sizeof(InstanceData), data, GL_DYNAMIC_DRAW);
4
for (int i = 0; i < 4; ++i) {                        // mat4 拆 4 个 vec4
5
    glEnableVertexAttribArray(3 + i);
6
    glVertexAttribPointer(3 + i, 4, GL_FLOAT, GL_FALSE,
7
                          sizeof(InstanceData), (void*)(i * sizeof(float) * 4));
8
    glVertexAttribDivisor(3 + i, 1);                 // divisor=1 → 每实例更新
9
}
10
glDrawElementsInstanced(GL_TRIANGLES, index_count, GL_UNSIGNED_INT, 0, N);

NOTE
DX12 / Vulkan 还有 Indirect Draw + Mesh Shader，把 draw call 参数也放 GPU buffer，由 compute shader 生成，CPU 端零 draw call——这是 Nanite/GPU-Driven 渲染的基础。

三十二、基于物理的渲染（PBR）#

32.1 为什么叫”基于物理”#

经验模型（Phong，见 Part 4 §18.3）能调出好看的反光，但：

不能量守恒 — 能量可以凭空变多
不互易 — 交换入射出射方向结果不一样（违反 BRDF 必要条件）
参数不可迁移 — 一盏灯调好换一盏就假

PBR 从微表面物理模型出发，保证：

能量守恒: $\int f_r \cos\theta_o \, d\omega_o \leq 1$
亥姆霍兹互易: $f_r(\omega_i, \omega_o) = f_r(\omega_o, \omega_i)$
参数来自实测:粗糙度、金属度可以扫描测量

32.2 Cook-Torrance BRDF（完整）#

Part 4 §18.4 给过轮廓。这里给完整公式 + GLSL 实现，做为 Part 6 的 canonical 参考。

32.2.1 微表面模型#

把表面看作无数法向分布的微小镜面。对方向 $\omega_i, \omega_o$ ，只有法向恰好等于半程向量 $\mathbf{h} = (\omega_i + \omega_o)/\|\omega_i + \omega_o\|$ 的微面才贡献镜面反射。

f_\text{spec} = \frac{D(\mathbf{h}) \, F(\omega_o, \mathbf{h}) \, G(\omega_i, \omega_o)}{4 (\mathbf{n} \cdot \omega_i)(\mathbf{n} \cdot \omega_o)}

三项分别刻画：

$D$ — 法向分布 $\to$ 有多少微面的法向朝向 $\mathbf{h}$
$F$ — 菲涅尔 $\to$ 这些微面反多少
$G$ — 几何项 $\to$ 微面之间自遮挡

32.2.2 GGX/Trowbridge-Reitz 法向分布#

D_\text{GGX}(\mathbf{h}) = \frac{\alpha^2}{\pi \left[ (\mathbf{n} \cdot \mathbf{h})^2 (\alpha^2 - 1) + 1 \right]^2}, \qquad \alpha = \text{roughness}^2

选 GGX 是因为它长尾——能画出粗糙金属的”柔高光”，Disney 2012 论文之后成为事实标准。

32.2.3 Smith 几何项#

G(\omega_i, \omega_o) = G_1(\omega_i) \, G_1(\omega_o), \qquad G_1(\omega) = \frac{\mathbf{n} \cdot \omega}{(\mathbf{n} \cdot \omega)(1 - k) + k}

直接光的 $k = (\alpha + 1)^2 / 8$ ；IBL 的 $k = \alpha^2 / 2$ （Disney 经验值）。

32.2.4 Schlick 菲涅尔近似#

F_\text{Schlick}(\omega_o, \mathbf{h}) = F_0 + (1 - F_0)(1 - \omega_o \cdot \mathbf{h})^5

$F_0$ = 基础反射率。非金属 $F_0 \approx 0.04$ （几乎无色）；金属 $F_0 = \text{albedo}$ （带色反光）—— 这就是金属度参数的来源。

32.2.5 漫反射与能量守恒#

f_r = k_d \frac{\text{albedo}}{\pi} + f_\text{spec}, \qquad k_d = (1 - F)(1 - \text{metallic})

关键点： $k_d$ 由 $F$ 决定 —— 镜面反多少，漫反射就少多少，自动能量守恒。金属 metallic = 1 时 $k_d = 0$ ，只有镜面反射。

📌 完整 GLSL 片段着色器#

1
const float PI = 3.14159265359;
2

3
// ---------- 三个核心函数 ----------
4
float D_GGX(float NdotH, float alpha) {
5
    float a2 = alpha * alpha;
6
    float x  = NdotH * NdotH * (a2 - 1.0) + 1.0;
7
    return a2 / (PI * x * x);
8
}
9

10
float G_SchlickGGX(float NdotX, float k) {
11
    return NdotX / (NdotX * (1.0 - k) + k);
12
}
13

14
float G_Smith(float NdotV, float NdotL, float alpha) {
15
    float k = (alpha + 1.0) * (alpha + 1.0) / 8.0;   // 直接光
16
    return G_SchlickGGX(NdotV, k) * G_SchlickGGX(NdotL, k);
17
}
18

19
vec3 F_Schlick(float VdotH, vec3 F0) {
20
    return F0 + (1.0 - F0) * pow(clamp(1.0 - VdotH, 0.0, 1.0), 5.0);
21
}
22

23
// ---------- 单光源 PBR ----------
24
vec3 pbr_direct(vec3 N, vec3 V, vec3 L,
25
                vec3 albedo, float roughness, float metallic,
26
                vec3 radiance)
27
{
28
    vec3  H     = normalize(V + L);
29
    float NdotV = max(dot(N, V), 0.0);
30
    float NdotL = max(dot(N, L), 0.0);
31
    float NdotH = max(dot(N, H), 0.0);
32
    float VdotH = max(dot(V, H), 0.0);
33

34
    vec3 F0 = mix(vec3(0.04), albedo, metallic);
35
    float alpha = roughness * roughness;
36

37
    float D = D_GGX(NdotH, alpha);
38
    float G = G_Smith(NdotV, NdotL, alpha);
39
    vec3  F = F_Schlick(VdotH, F0);
40

41
    vec3 specular = (D * G * F) / max(4.0 * NdotV * NdotL, 1e-4);
42

43
    vec3 kS = F;
44
    vec3 kD = (vec3(1.0) - kS) * (1.0 - metallic);   // 能量守恒
45
    vec3 diffuse = kD * albedo / PI;
46

47
    return (diffuse + specular) * radiance * NdotL;
48
}

TIP
对多光源，循环累加 pbr_direct 即可。IBL 部分不是简单的加法——需要分离漫反射和镜面两路预积分，见下一节。

32.3 基于图像的光照（IBL）#

为什么不能直接对环境贴图做蒙卡尔洛积分？因为每个片元都要采几百次，实时承受不住。IBL 的核心是预积分 + 分离近似:

32.3.1 漫反射辐照度贴图#

对环境贴图做 $\int_\Omega L_i(\omega_i) \cos\theta \, d\omega_i$ 的预卷积，结果仍是一张立方体贴图（通常 32×32 足够，因为漫反射高频信息低）。运行时采一次。

32.3.2 镜面反射：分离近似（Split-Sum Approximation）#

Epic 2013：

L_o \approx \underbrace{\int f_r(\omega_i, \omega_o) \cos\theta \, d\omega_i}_{\text{BRDF LUT (2D)}} \cdot \underbrace{\int L_i(\omega_i) \, D(\omega_i) \, d\omega_i}_{\text{Prefiltered env map}}

预过滤环境图:对不同 roughness 做 importance sampling GGX，结果存成 mipmap 链（粗糙度越高采样到越高 mip）。
BRDF LUT:只依赖 $(\mathbf{n} \cdot \omega_o, \text{roughness})$ 的二维查表。

运行时 IBL 只需 3 次贴图采样：

1
vec3 IBL(vec3 N, vec3 V, vec3 albedo, float roughness, float metallic) {
2
    vec3 F0 = mix(vec3(0.04), albedo, metallic);
3
    vec3 R  = reflect(-V, N);
4
    float NdotV = max(dot(N, V), 0.0);
5

6
    vec3 kS = F_Schlick(NdotV, F0);
7
    vec3 kD = (1.0 - kS) * (1.0 - metallic);
8

9
    vec3 irradiance = texture(u_irradianceMap, N).rgb;
10
    vec3 diffuse    = irradiance * albedo;
11

12
    // 粗糙度 → mip level
13
    float mip = roughness * (MAX_PREFILTER_MIP - 1.0);
14
    vec3 prefiltered = textureLod(u_prefilterMap, R, mip).rgb;
15
    vec2 brdf = texture(u_brdfLUT, vec2(NdotV, roughness)).rg;
16
    vec3 specular = prefiltered * (F0 * brdf.x + brdf.y);
17

18
    return kD * diffuse + specular;
19
}

NOTE
Disney Principled BSDF（2012）在 Cook-Torrance 之上加 sheen / clearcoat / subsurface，UE / Blender / Substance 都基于它的 11 参数体系。原理相同，只是多了几层 BRDF 加和。

三十三、硬件光线追踪（RTX / DXR）#

WARNING
Part 4 讲的是离线光线追踪，每秒可能跑几 fps。RTX 把加速结构构建 + 求交 + BVH 遍历全搬到 GPU 专用硬件单元（RT Core），让实时光追成为现实。API 层面 NVIDIA OptiX / Microsoft DXR / Vulkan KHR Ray Tracing 三家路线几乎同构。

33.1 管线架构#

硬件光追管线有 5 种着色器，代替传统管线的 VS/FS：

着色器	作用	触发时机	Ray Generation	发射光线（相当于主循环）	每像素一次
Intersection	自定义图元求交（三角形以外）	BVH 遍历到叶子	Any-Hit	alpha 裁剪等”要不要采纳这次命中”	每次可能命中
Closest-Hit	最近命中着色（= Part 4 的 shade）	BVH 遍历结束	Miss	未命中（= 背景 / 环境贴图）	遍历结束且无命中

33.2 两级加速结构（TLAS / BLAS）#

BLAS（Bottom-Level）:每个网格一个 BVH，存三角形。静态网格可预构建。
TLAS（Top-Level）:场景中所有实例（BLAS + 世界变换）的 BVH。动态物体每帧刷新。

分两级是因为：动态场景里只重建 TLAS 就够（O(实例数)），不用重建每个几何体的 BVH（O(三角数)）。

1
// DXR 伪代码
2
D3D12_RAYTRACING_GEOMETRY_DESC geom = {};
3
geom.Type = D3D12_RAYTRACING_GEOMETRY_TYPE_TRIANGLES;
4
geom.Triangles.VertexBuffer = ...;
5
geom.Triangles.IndexBuffer  = ...;
6

7
// BLAS：一次构建
8
dev->GetRaytracingAccelerationStructurePrebuildInfo(&blas_inputs, &blas_info);
9
cmd->BuildRaytracingAccelerationStructure(&blas_build, 0, nullptr);
10

11
// TLAS：每帧刷新
12
for (auto& inst : scene_instances) {
13
    D3D12_RAYTRACING_INSTANCE_DESC& d = tlas_instances[i];
14
    d.AccelerationStructure = inst.blas_gpu_va;
15
    memcpy(d.Transform, inst.world_matrix, sizeof(float) * 12);
16
    d.InstanceMask = 0xFF;
17
    d.InstanceContributionToHitGroupIndex = inst.material_id;
18
}

33.3 着色器表（Shader Binding Table）#

硬件光追怎么知道命中某个三角形后跑哪个 Closest-Hit？靠一张 SBT 表：material_id → 着色器索引。这就是 Part 4 §19 BVH 叶子节点的硬件一般化版本。

33.4 低采样去噪（核心难题）#

实时光追每像素只能发 1–4 条光线（否则帧率不够）。方差巨大，需要时空重建：

SVGF（Schied 2017）:空间双边滤波 + 时域复用，主流离线电影也在用
ReSTIR（Bitterli 2020）:重采样——对每像素维护一个小的候选”重要光路”蓄水池，邻居互相借光样本，等效采样数翻倍。是 Cyberpunk / Alan Wake 2 路径追踪的关键。
神经去噪（OIDN / OptiX Denoiser）吃 (noisy RT, albedo, normal) 输出干净图，细节最多。

WARNING
ReSTIR / SVGF 都假设场景时序稳定——快速相机旋转、disocclusion 会破坏时域复用，导致”鬼影 / 拖影”。工程上要配 motion vector + depth 判据回退到空间滤波。

33.5 动态全局光照（DDGI / ReSTIR GI）#

实时 GI 的主流方案：

DDGI（Dynamic Diffuse Global Illumination，Majercik 2019）:场景里布一张稀疏的 probe 网格，每 probe 存一张 8×8 的辐照度图。着色时三线性插值。UE5 Lumen 的 diffuse GI 近亲。
ReSTIR GI:把 ReSTIR 的蓄水池思路扩展到路径追踪 —— 整条路径（而不只是一次直接光采样）加入蓄水池。

三十四、体积渲染与参与介质#

NOTE
体积渲染不只是”画云”。CT/MRI 医学影像、光雾、次表面散射（皮肤/蜡/叶子）全是它的应用。核心方程把 Part 4 的渲染方程从”表面上一次事件”推广到”光沿路径的连续积分”。

34.1 体渲染方程#

光线 $\mathbf{r}(t) = \mathbf{o} + t\omega$ 在介质里的辐射度：

L(\mathbf{o}, \omega) = \int_0^d T(0, t)\, \sigma_s(\mathbf{r}(t))\, L_s(\mathbf{r}(t), \omega)\, dt + T(0, d)\, L_\text{bg}(\mathbf{r}(d), \omega)

透射率 $T(0, t) = \exp\left(-\int_0^t \sigma_t(\mathbf{r}(s))\, ds\right)$ （Beer-Lambert 定律）
消光 $\sigma_t = \sigma_a + \sigma_s$ （吸收 + 散射）
入散射 $L_s = \int_{4\pi} p(\omega', \omega) L(\mathbf{r}(t), \omega') d\omega'$
相位函数 $p$ 常用 Henyey-Greenstein: $p(\cos\theta) = \frac{1 - g^2}{4\pi (1 + g^2 - 2g\cos\theta)^{3/2}}$

34.2 Ray Marching 求解#

实时里几乎全用黎曼和离散化——均匀步长沿光线采样：

1
Eigen::Vector3f ray_march(const Ray& ray, float t_min, float t_max,
2
                          const Volume& vol, const std::vector<Light>& lights) {
3
    Eigen::Vector3f L = Eigen::Vector3f::Zero();
4
    float T = 1.0f;                              // 透射率
5
    float dt = 0.1f;
6
    int   steps = int((t_max - t_min) / dt);
7

8
    for (int i = 0; i < steps; ++i) {
9
        float t = t_min + i * dt;
10
        Eigen::Vector3f p = ray.o + t * ray.d;
11
        float density = vol.sample(p);            // 从 3D 纹理采样
12
        if (density <= 0) continue;
13

14
        float sigma_t = vol.extinction * density;
15
        float dT = std::exp(-sigma_t * dt);       // 本步透射率衰减
16

17
        // 直接光采样（只对每盏光算一次阴影 ray march）
18
        Eigen::Vector3f Ls = Eigen::Vector3f::Zero();
19
        for (const auto& light : lights) {
20
            Eigen::Vector3f L_dir = (light.pos - p).normalized();
21
            float T_light = shadow_transmittance(p, light.pos, vol);   // 同法
22
            float cos_theta = (-ray.d).dot(L_dir);
23
            float phase = henyey_greenstein(cos_theta, vol.g);
24
            Ls += light.color * T_light * phase * vol.scattering * density;
25
        }
26

27
        L += T * (1.0f - dT) * Ls;                // 本步入散射贡献
28
        T *= dT;
29
        if (T < 0.01f) break;                     // 早期终止
30
    }
31
    return L;
32
}

34.3 云渲染的工程技巧#

离线的 ray march 每像素几百步。游戏要实时，靠这些 trick：

3D 噪声纹理 + Perlin 混合做基础云密度，天气贴图做宏观覆盖率
大步长 + 抖动:64–128 步配合蓝噪声抖动起点，消除带状条纹
双尺度:低分辨率（1/4 分辨率）体 ray march + 高分辨率 upsample
Horizon Zero Dawn 2015 GDC 演讲是云渲染的经典资料

TIP
体渲染和 NeRF 本质一样 —— 都是”沿光线累积密度加权辐射”。NeRF 的不同只是把 $(\sigma, L_s)$ 从采样纹理换成查询 MLP。

三十五、GPGPU 与计算着色器#

35.1 工作组模型#

GPU 把线程按三层组织：

Thread:最小单位，一段 shader
Work Group（本地工作组）:local_size_{x,y,z}，共享一块片上 shared memory（~48 KB），可 barrier 同步
Dispatch:num_groups_{x,y,z}，一次 glDispatchCompute

关键约束：同组内可同步，跨组不能。要跨组同步必须额外发起 dispatch。

1
#version 430
2
layout(local_size_x = 16, local_size_y = 16) in;
3
layout(rgba32f, binding = 0) uniform image2D img;
4

5
shared float tile[16][16];     // 组内共享
6

7
void main() {
8
    ivec2 gid = ivec2(gl_GlobalInvocationID.xy);   // 全局坐标
9
    ivec2 lid = ivec2(gl_LocalInvocationID.xy);    // 组内坐标
10

11
    tile[lid.y][lid.x] = imageLoad(img, gid).r;
12
    barrier();                                      // 组内同步
13

14
    // ... 用 tile 做 blur / reduce
15
}

35.2 并行前缀和（Scan）#

Prefix sum 是无数并行算法的基石——stream compaction、排序、BVH 构建全要用。Blelloch 算法 $O(n)$ 复杂度 $O(\log n)$ 深度：

1
输入  [3, 1, 7, 0, 4, 1, 6, 3]
2
Upsweep（树形归约）:
3
  步长 1: [3, 4, 7, 7, 4, 5, 6, 9]
4
  步长 2: [3, 4, 7,11, 4, 5, 6,14]
5
  步长 4: [3, 4, 7,11, 4, 5, 6,25]   # 根为总和
6
末位清零 → [3, 4, 7,11, 4, 5, 6, 0]
7
Downsweep（反向散播）:
8
  输出  [0, 3, 4,11,11,15,16,22]   # exclusive scan

WARNING
算法核心：先算总和、再反向分发。比朴素的 $O(n \log n)$ 的 Hillis-Steele 算法工作总量少一半。

35.3 GPU 粒子系统#

全 GPU 粒子 / Emit / Sort / Draw 都在 compute shader 里跑，CPU 零拷贝。核心抽象是两个 free-list:

1
// ========= Update Pass =========
2
layout(std430, binding = 0) restrict buffer Particles { Particle p[]; };
3
layout(std430, binding = 1) restrict buffer Counters  {
4
    uint alive_count; uint dead_count; uint alive_list[];
5
};
6

7
uniform float dt;
8
uniform vec3  gravity;
9

10
void main() {
11
    uint i = gl_GlobalInvocationID.x;
12
    if (i >= p.length()) return;
13

14
    Particle pt = p[i];
15
    pt.life -= dt;
16
    if (pt.life > 0.0) {
17
        pt.vel += gravity * dt;
18
        pt.pos += pt.vel * dt;
19
        p[i] = pt;
20
        uint slot = atomicAdd(alive_count, 1u);       // 原子分配
21
        alive_list[slot] = i;
22
    } else {
23
        atomicAdd(dead_count, 1u);                    // 回收
24
    }
25
}

要点:

atomicAdd 做无锁计数分配
alive_list 只收集还活着的粒子索引，后续 draw 用 indirect draw 读这个 list 长度
发射 pass 从 dead_count 回收死粒子槽位，避免动态增长

三十六、神经渲染#

WARNING
神经渲染不是”画个图让 GAN 生成”。真正的 NeRF 和 3DGS 的数学基础仍然是体积渲染方程——它们只是把”场景表示”从传统几何+贴图换成了可微分的参数化结构。

36.1 NeRF（Mildenhall 2020）#

核心思路:用 MLP 把 3D 位置 + 视角方向映到密度 + 颜色：

F_\Theta: (\mathbf{x}, \omega) \mapsto (\sigma, \mathbf{c})

渲染时对光线做 ray marching（和 §34 一样）:

\hat{\mathbf{C}}(\mathbf{r}) = \sum_{i=1}^N T_i (1 - e^{-\sigma_i \delta_i}) \mathbf{c}_i, \qquad T_i = \exp\left(-\sum_{j<i} \sigma_j \delta_j\right)

监督信号：多视图照片。对渲染的像素 $\hat{\mathbf{C}}$ 与真实照片 $\mathbf{C}_\text{gt}$ 做 L2 loss，反向传播穿过整条 ray march 回到 MLP 权重。因为 ray march 是纯可微分加权和，梯度可传。

关键工程点#

位置编码 $\gamma(x) = [\sin 2^0 \pi x, \cos 2^0 \pi x, \dots, \sin 2^L \pi x, \cos 2^L \pi x]$ 让 MLP 能学高频细节
分层采样:粗网络预测密度 → 重要性采样细网络，避开空间中大量空白
慢:原版 NeRF 单场景训练 1–2 天。加速版 Instant-NGP（Müller 2022）用多尺度哈希网格，5 秒训练

36.2 3D Gaussian Splatting（Kerbl 2023）#

把场景表示为上百万个显式 3D 高斯,每个高斯有位置 $\boldsymbol{\mu}$ 、协方差 $\boldsymbol{\Sigma}$ 、不透明度 $\alpha$ 、球谐 RGB。

核心优势:

光栅化而非 ray march:每帧把所有高斯投影到屏幕，按深度做 $\alpha$ blend。GPU 友好。
显式 —— 可编辑、可动画、可导出。神经网络只用在训练优化中，推理零 MLP。
质量 > NeRF，速度 >> NeRF（100 FPS vs 0.1 FPS）

屏幕空间投影:3D 高斯 $G_i(\mathbf{x}; \boldsymbol{\mu}_i, \boldsymbol{\Sigma}_i)$ 投影到 2D 后仍是高斯（仿射变换保高斯性）:

\boldsymbol{\Sigma}_i^\text{2D} = \mathbf{J} \mathbf{W} \boldsymbol{\Sigma}_i \mathbf{W}^\top \mathbf{J}^\top

$\mathbf{J}$ 是投影矩阵的雅可比， $\mathbf{W}$ 是 view 矩阵。

渲染（前向合成）:把所有高斯按深度排序，前到后合成：

C(x, y) = \sum_i \mathbf{c}_i \alpha_i G_i^\text{2D}(x, y) \prod_{j < i} (1 - \alpha_j G_j^\text{2D}(x, y))

TIP
3DGS 的优化用 自适应致密化:梯度大的高斯分裂、位置近的合并、不透明度太低的删掉。这让百万高斯的数量可以动态调整，对高频细节自动变多、平坦区域自动变少。

36.3 对比#

	NeRF	Instant-NGP	3D Gaussian Splatting	表示	MLP 隐式	哈希网格 + 小 MLP	显式高斯点云
训练	~24 h	~5 s	~30 min	推理	0.1 FPS	~10 FPS	~100 FPS
可编辑	难	难	容易	底层	体渲染方程	体渲染方程	屏幕空间 alpha blend

三十七、现代物理仿真#

37.1 XPBD（eXtended PBD）#

Part 5 §29.2 的 PBD 好用但刚度非物理——同样的 $k$ 换迭代次数就软硬不同。XPBD (Macklin 2016) 把拉格朗日乘子作为显式状态：

\Delta \mathbf{x}_i = -\frac{C + \tilde{\alpha} \lambda}{\sum_j w_j \|\nabla_j C\|^2 + \tilde{\alpha}} \, w_i \nabla_i C, \qquad \tilde{\alpha} = \frac{\alpha}{\Delta t^2}

其中 $\alpha = 1/k$ 是柔度（compliance），直接对应物理弹性。 $\tilde{\alpha} = 0$ 退化为 PBD。刚度从此和迭代次数解耦，UE5 Chaos Cloth / Houdini Vellum 都基于它。

37.2 SPH（Smoothed Particle Hydrodynamics）#

把流体离散为粒子，用核函数加权平均邻居估计场变量：

A(\mathbf{x}) \approx \sum_j \frac{m_j}{\rho_j} A_j \, W(\|\mathbf{x} - \mathbf{x}_j\|, h)

$W$ 常用 Poly6 / Spiky 核。离散 Navier-Stokes（Part 5 §30.2）:

\mathbf{a}_i = -\frac{1}{\rho_i} \nabla p_i + \nu \nabla^2 \mathbf{v}_i + \mathbf{g}

每项梯度/拉普拉斯用 $W$ 的导数解析表达，纯局部计算，GPU 友好。

工程流程:

空间哈希 bucketize 粒子（Part 5 §27 的邻居查找）
每粒子求邻居 → 估计密度 $\rho_i$
由状态方程 $p_i = k(\rho_i - \rho_0)$ 算压强 → 压强梯度力
加粘性、表面张力、重力
积分（辛欧拉 / Verlet，见 Part 5 §28）

PBF（Position Based Fluids，Macklin 2013）把 SPH 的”压强力”改写成 PBD 风格的密度约束投影,稳定性和大步长都更好，是 Houdini / Flip Fluids 的主流。

37.3 FEM（有限元）概览#

弹簧质点把物体离散为质点+弹簧，FEM 离散为四面体单元,每个单元上定义位移插值。应力-应变关系（线弹性）:

\boldsymbol{\sigma} = \lambda \, \text{tr}(\boldsymbol{\varepsilon}) \mathbf{I} + 2\mu \boldsymbol{\varepsilon}

$\lambda, \mu$ 是拉梅常数（可由杨氏模量 $E$ 、泊松比 $\nu$ 推出）。Co-rotational FEM 把旋转部分先通过 polar decomposition 提取出来，避免大变形下线性弹性的”体积爆炸”。

Corotated / Stable Neo-Hookean / ARAP 是业界主力的超弹性模型,Ten Minute Physics / PhysX / Chaos 都在用。

尾声：把六部分拼起来#

Part	工具	在 Part 6 里被谁复用
Part 2 光栅化	透视除法 / 深度测试	§31 剔除 / §36 3DGS 投影
Part 4 光线追踪	渲染方程 / BVH / 蒙卡洛	§32 PBR / §33 RTX / §34 体渲染 / §36 NeRF
Part 6 前沿	上面的全部组合	—

NOTE
六部分笔记的主线其实很简单：前五部分造积木，Part 6 搭城堡。真正难的不是任何单个算法，而是知道在什么场景下选哪个积木。下次看到一个新论文（比如”基于 Gaussian Splatting 的实时 relighting”），第一反应应该是：这是把 §36 的 3DGS 和 §32 的 PBR 拼起来了。积木法一分解，就不神秘了。

延伸阅读清单#

主题	推荐
光线追踪	《PBRT》第 4 版 / Ray Tracing Gems I & II（免费 PDF）
神经渲染	NeRF / Instant-NGP / 3D Gaussian Splatting 三篇原论文
GPU 架构	《GPU Gems》1-3 卷（免费） / 《Real-Time Collision Detection》