实时渲染技术：后处理特效

可视化演示

可视化展示Bloom泛光提取合成、SSAO环境光遮蔽采样计算与色调映射HDR转LDR曲线，交互调节参数体验后处理管线效果。

后处理管线

走进暗房的第一步，是先把底片挂在晾片架上。游戏引擎同理——当 GPU 完成场景里所有物体的光栅化，得到的那张“底片”叫帧缓冲（Framebuffer），里面装着每个像素的颜色、深度与法线信息。后处理要做的，就是在这张底片上继续加工，而不是推倒重来。

怎么对一张现成的图片做全屏加工？渲染世界里的标准思路是“画一幅覆盖整个屏幕的矩形”——即全屏四边形（Full-screen Quad）。GPU 把帧缓冲当作纹理贴到这个四边形上，然后逐像素执行一个像素着色器。每执行一次这样的全屏绘制，就是一道“暗房工序”，多个工序串联起来就形成后处理链（Post-processing Chain）。

后处理链的输入输出都是同一张尺寸的纹理。前一道工序的输出作为下一道的输入，例如景深之后接泛光，再接着做色调映射。由于每个像素的处理相互独立，GPU 的并行架构能同时处理数百万像素，这正是后处理特效不增加场景几何复杂度、却能大幅提升画面质感的原因。

就像修图师不会重新拍照，而是用一套固定工序批量处理每一张底片，后处理管线也以极低的代价复用同一帧画面质量。理解这条“暗房流水线”，后面讲的每道工序才能各就各位。

Bloom泛光

夜晚你盯着对面楼顶的霓虹灯，会发现灯管边缘晕开一圈柔光，眼睛眨一下，那圈光还会拖出细细的尾巴。这是高光周围的“光污染”，摄影师却把它当成宝贝——游戏里把这个效果做到极致，就是 Bloom 泛光：通过让高亮区域的光线“渗”到邻域像素中，营造出光有能量的感觉。

实现 Bloom 的第一步是“挑出该发光的地方”。把每个像素转成亮度，和阈值 $T$ 比较，亮度高于 $T$ 的区域保留下来，其余置黑，这叫亮度阈值提取。紧接着，把这张“高光黑白图”做高斯模糊，让高光的边缘扩散出去，像墨水滴进水里。模糊后的图像乘上一个强度系数 $k$，再与原图叠加，就得到了光晕。

高斯模糊本质是加权平均：越靠近中心像素的邻居权重越大。若直接对大尺寸纹理做全分辨率模糊，开销惊人。引擎的通用做法是降采样：先把高光图缩到 1/2、1/4 甚至 1/8 分辨率依次模糊，再逐步上采样合并——画面影响极小，但性能翻倍。这也是为什么移动端游戏能跑 Bloom 的秘密。

回到霓虹灯的例子：阈值 $T$ 决定哪些灯管有资格“发光”，高斯模糊的半径决定光晕能铺多远，$k$ 则决定这圈柔光有多浓。调好这三者的分寸，比盲目堆高模糊次数更见功力。

SSAO环境光遮蔽

留意家里墙角：就算白天光线充足，墙角也会比墙面中央暗一截。原因很简单——墙面彼此遮挡了来自环境的光线。这种“角落里更暗”的细节叫环境光遮蔽（Ambient Occlusion），它让物体之间产生真实的接触感，是画面“立起来”的关键。

环境光遮蔽的精确计算需要光线追踪，实时渲染耗不起。SSAO（屏幕空间环境光遮蔽）想了个取巧的主意：既然手头有帧缓冲里的深度缓存，直接把它当作场景几何，对每个像素在其周围取一组采样点，看看有多少采样点被附近的几何体挡住——遮挡越多，该像素越暗。

为了让采样更准，SSAO 会在表面的法向半球内采样——只有表面上方才是可能进光的方向，而不是在球体内各方向乱扫。每个像素取十几个采样点做比较，结果难免带噪，因此最后还需要一道模糊（去噪），把颗粒感抹平，得到柔和的接触阴影。在此基础上，业界还发展出 HBAO、GTAO 等改进方案，它们在采样分布上更聪明。

把墙角的粒子再想一遍：SSAO 做的事，就是画完画面后，挨个像素去“摸”一下周围的深度，手动把墙角那条缝描得更暗。它不追求绝对精确，只求在几十毫秒内让画面看起来“有物理感”。

色调映射

人眼天生是优秀的 HDR 显示器——从刺眼的太阳到深黑的阴影，都能同时看清细节。但普通屏幕不是，它只能显示 0 到 1 之间的亮度。原始渲染结果里，阳光直射处亮度可能是 50，直接映射到屏幕就会变成一片死白。

色调映射（Tone Mapping）就是这道“把宽动态范围压缩进窄范围”的工序。它通过一条曲线，把高动态范围（HDR）的线性亮度映射到低动态范围（LDR）。曝光控制决定曲线的整体平移：曝光值提高，中景变亮，高光更早被压缩。

业界常用的 ACES 曲线源自电影工业的 Academy Color Encoding System。它的数学近似式低光段接近线性、保留暗部细节，高光段逐渐压缩、不会瞬间切死，同时还能轻微提升色彩饱和度，让画面有电影感。相较简单好算的 Reinhard 曲线（$x / (x+1)$），ACES 的亮部过渡更柔和，也更贵——这也是一种“调色风格”的选择。

修图师在相纸上最怕高光溢出、暗部死黑。ACES 曲线像一位经验丰富的暗房老师傅，用一条平滑的曲线“该收的收，该放的放”，保证画面从阴影到高光都有信息，即便在便宜的屏幕上也能还原电影感。

体积后处理配置

暗房修图往往按照片分场景：拍夜景特调，拍人像特调。游戏世界比一张照片大得多，同一个游戏里有白天室外、洞穴、地牢，后处理参数不能从头到尾一成不变——这就需要“后处理体积”。

后处理体积（Volume）是一个有边界的空间区域，引擎里通常以 Box Volume 或 Sphere Volume 表示。你把一套后处理参数（泛光强度、曝光、饱和度）挂在这个体积上。当相机进入这个区域，引擎就自动套用这套参数；走出去，参数自然消失。

当相机同时处于多个体积的交叠区域时，参数不能简单取某个值——引擎会在参与重叠的体积之间做基于权重的混合，每套参数按相机到体积边界的距离或优先级求出权重，并要求所有权重之和为 1。比如角色从洞口走进洞内，曝光值从 1.0 平滑过渡到 0.3，中间每一帧都是两个体积的加权结果，这才不会出现亮度跳变。对于想要“强制覆盖”全局的参数，则通过更高的优先级来压过其他体积。

修图时，你希望从“夜店风”到“日系风”的转变是渐变的，而不是啪地被闪瞎。Volume 混合就是这样一种渐变，它让同一个世界里的不同角落，共享同一套后处理引擎，却拥有各自的表情。

性能开销控制

暗房修图师的烦恼是：再好看的精修，一次只能处理一张，而游戏每秒钟要出 30 到 60 张。渲染管线同理，每帧只有 16.6 毫秒（60fps）的预算，后处理每多一道工序，GPU 就要把全屏像素再算一遍。

后处理的开销几乎和处理的像素数成正比。全分辨率做一次高斯模糊，意味着每个像素要访问几十个邻居；如果连续做五六道工序，开销立刻失控。因此引擎工程师想方设法让 GPU“少算”。

最常用的是半分辨率计算：把屏幕缩小到一半甚至四分之一做 Bloom 模糊、SSAO 采样，这些效果对低频信息敏感，降分辨率后肉眼几乎分辨不出差异，但像素数直接降到原来的 1/4 或 1/16。其次，用引擎自带的性能分析器（如 Unreal 的 GPU Visualizer）逐 Pass 看耗时，一眼找出最贵的那个效果。移动端更是精打细算：关闭全局 SSAO、限制 Bloom 的模糊级数、按相机距离动态降低特效分辨率，都是常见手段。

精明的暗房师傅不会把每张照片都放大到原尺寸精修——除非顾客加钱。后处理性能管理也是一样的生意：把最贵的工序放在人们注意不到分辨率的地方，把预算留给真正提升视觉印象的效果。

AI 应用场景

Python 演示

import numpy as np def extract_bright(img, threshold=0.75):    # 提取亮度超过阈值的像素, 其余置0    lum = np.max(img, axis=2)    mask = (lum > threshold).astype(np.float32)    return img * mask[:, :, None] def box_blur(img, radius=2):    # 可分离盒式模糊, 用两次一维卷积近似高斯模糊    h, w = img.shape[:2]    tmp = img.copy()    out = img.copy()    k = 2 * radius + 1    kernel = np.ones(k, dtype=np.float32) / k    for c in range(img.shape[2]):        for x in range(w):            tmp[:, x, c] = np.convolve(img[:, x, c], kernel, mode="same")        for y in range(h):            out[y, :, c] = np.convolve(tmp[y, :, c], kernel, mode="same")    return out def bloom_compose(img, threshold=0.7, radius=3, strength=0.8):    # 完整 Bloom 流程: 提取高光 -> 模糊 -> 回加原图    bright = extract_bright(img, threshold)    halo = box_blur(bright, radius)    halo = box_blur(halo, radius)    return np.clip(img + strength * halo, 0.0, 1.0) if __name__ == "__main__":    # 构造 256x256 暗场景, 中央有一个高亮方块    h = w = 256    img = np.zeros((h, w, 3), dtype=np.float32)    img[110:146, 110:146] = 1.0    img[92:98, 118:138] = 0.8    out = bloom_compose(img)    bright_in = int((img.max(axis=2) > 0.0).sum())    bright_out = int((out.max(axis=2) > 0.3).sum())    print("input max:", round(img.max(), 3))    print("output max:", round(out.max(), 3))    print("halo growth ratio:", round(bright_out / bright_in, 2))

1. lum = np.max(img, axis=2)把 RGB 三通道取最大值作为亮度，快速得到“哪里亮”。
2. mask = (lum > threshold).astype(np.float32)亮度超过阈值的像素记为 1，其余为 0，完成高光筛选。
3. kernel = np.ones(k, dtype=np.float32) / k构造盒式模糊权重，每个邻居等权平均，近似高斯效果。
4. tmp[:, x, c] = np.convolve(img[:, x, c], kernel, mode="same")沿列方向做一维卷积，实现可分离模糊的第一步。
5. out[y, :, c] = np.convolve(tmp[y, :, c], kernel, mode="same")沿行方向再做一维卷积，两步合起来等价于二维模糊。
6. np.clip(img + strength * halo, 0.0, 1.0)光晕乘强度后叠回原图，并把结果裁剪到合法亮度范围。

常见误区

面试题