Shader编程：后处理Shader

可视化演示

展示后处理Shader渲染管线、深度缓冲重建与SSR屏幕空间反射射线步进过程。

后处理基础

一间成熟的电影后期工作室，最繁忙的房间往往不是片场，而是那间灯光昏暗的调色机房。导演在片场拍完了所有镜头——演员的走位、灯光的明暗、实景的质感——这些“毛片”被原封不动地存进胶片。但观众绝不会直接看毛片：上映前，调色师要逐帧调整色温、叠加雾气、压暗边角，让画面具备电影感。游戏渲染里的“后处理Shader”，正是这座调色机房。

在GPU渲染管线中，调色机房的位置很固定：它在所有不透明和透明物体绘制完之后，在UI叠加之前。此时场景已经变成了屏幕上一张完整的二维图像，这张图像的专业名字叫“帧缓冲”（Frame Buffer）。后处理做的事情，就是拿起这张底片，对上面的每一个像素重新“精修”。

具体怎么做呢？GPU会画一个恰好铺满整个屏幕的三角形或四边形，然后用片段着色器对每个输出像素执行一遍“滤色逻辑”：从输入纹理中读取该像素原本的颜色，经过计算生成一个新颜色，写入输出纹理。每执行这么一遍，称为一个pass（通道）。调色、泛光、暗角、景深、屏幕空间反射……所有叫得上名字的后处理效果，本质上都是一次或多次“全屏逐像素操作”。

在调色机房，一道工序就是一层滤镜，导演不满意就再加一道。后处理的多个pass也是层层叠加：每个pass的输入纹理是上一个pass的输出纹理，直到最终画面被送去“放映”——也就是显示到屏幕上。理解了这张“滤镜链条”，后面的每一步都是在往链条上挂新的工具。

纹理获取

调色师要开工，第一件事不是调色，而是“把胶片从摄影机里取出来”。对GPU来说，就是从颜色缓冲里拿到那张二维画面，交给后处理作为输入。这个可被读取的工作副本，叫作渲染纹理（Render Texture）。

在Unity中，通常有两种拿法：一是直接把相机的 targetTexture 指向一张渲染纹理，让场景渲染到纹理上；二是在URP里通过摄像机脚本接口获取 _CameraOpaqueTexture（不透明物体纹理）或 _CameraDepthTexture（深度纹理）。拿到之后，着色器用 tex2D(tex, uv) 在片段着色器里逐像素采样。

采样要用的 uv 坐标非常关键：屏幕像素的整数坐标需要换算成 0 到 1 的归一化坐标，GPU 才知道“这个像素对应纹理里的哪个点”。同时要注意分辨率匹配——屏幕多大，工作副本通常就建多大；如果性能紧张，就建半分辨率副本，处理完再放大回屏幕。最后还要操心GPU显存：临时纹理必须“借了就还”，否则就会泄漏。

把原始胶片“复制”出来，是几乎所有后续精修的前提——没有这张 Render Texture，调色师连一张能下笔的照片都没有。而且“借了要还”的原则贯穿整个后处理生涯：每申请一张临时纹理，都要在合适的时机释放，这座调色房才能持续运转。

深度重建

电影调色时，有时需要知道“哪个地方远、哪个地方近”——比如远处的山加雾，近处的人物做锐化。后处理也有这样一张“距离地图”：深度缓冲。它记录每个像素离相机有多远，但记法非常特殊，直接读出来甚至会让人误解。

原因是深度缓冲存的不是真实的“米数”，而是经过透视投影变换后的非线性值，大约呈 1/z 的关系。透视投影为了把近处精度拉高，把远处距离“压缩”进了很窄的数值区间。所以想用这些数据做雾效、景深、屏幕空间反射，必须先做一步“重建”——也就是把非线性的深度还原成线性的真实距离。

还原过程需要两个相机参数：近裁剪面 Near 和远裁剪面 Far。Unity 把这两个参数打包进 _ZBufferParams 供着色器使用，一条指令就能完成线性化。有了线性深度，再配合相机位置和视锥方向，就能恢复每个像素的世界坐标——这也是后面SSR、体积雾、景深散景等一切“距离相关魔法”的共同地基。

这份“距离地图”一旦被翻译成人能读懂的距离，调色师就能精准地给远处的山加雾、给近处的人物打高光。可以说，深度重建是后处理里最“隐形”却最承重的一步——没有它，很多特效都只能凭空瞎猜距离。

屏幕空间反射

导演想要地面上有一片湿漉漉的水洼倒影，但又不愿意再雇一组人重新搭一套倒影场景——平面反射和光线追踪都太贵。调色师想出个省钱的“障眼法”：屏幕空间反射（Screen Space Reflection，简称SSR）。反正观众只能看到屏幕上已有的像素，那就直接在屏幕里找“倒影应该出现的位置”。

对每个像素，已知视线方向 V 和表面法线 N，先用反射公式算出反射方向 R；然后沿着 R 在屏幕空间里一步步前进——这一步叫“光线步进”。每走一步，都采样该位置的深度，与“光线前进到这里时对应的深度”比较：如果光线深度越过了场景深度，说明撞上了某个物体，就采那个物体表面的颜色作为反射结果。

不过屏幕空间有个硬边界：反射方向指到屏幕外、或者反射目标本来就被其他物体遮挡时，SSR就会失效。这时必须让反射效果平滑淡出，并回退到环境贴图作为兜底。这也是为什么SSR的反射往往“近处惊艳、远处消失”。

SSR是调色师的“穷人反射神器”：不重新渲染场景，只用屏幕里现成的像素拼出逼真的水洼倒影。它成本低、效果好，是如今很多游戏“雨后湿地板”“水面反光”质感的来源——也提醒我们：所有屏幕空间技术，都必须接受“屏幕之外一无所知”这个前提。

渲染特征扩展

调色机房有标准流程：调色、降噪、加字幕。但导演偶尔需要在流程中间临时插一道“定制滤镜”。在Unity URP中，这道定制工序就是 Renderer Feature（渲染特征扩展）——一种可以插进渲染管线、指定时机执行自定义逻辑的机制。

编写时要认识两个核心类：ScriptableRendererFeature 负责把“工序卡”注册进管线，ScriptableRenderPass 负责具体执行。在 pass 的 Execute 方法里，用 CommandBuffer 发号施令：先 GetTemporaryRT 申请一张中间纹理，再用 cmd.Blit(src, dest, material, passIndex) 把上一张纹理当作输入、执行一遍后处理材质并写入新纹理，最后 ReleaseTemporaryRT 释放显存。

一个最经典的入门例子是“转灰度”：片段着色器采样帧缓冲的颜色，套用下面的亮度公式，把彩色像素变成灰阶。这既是调色手段，也是做描边、模糊、SSR材质通道的“地基”。掌握了这个最小闭环，把公式换成泛光阈值、暗角距离、深度雾，就得到了任意后处理效果。

有了这张“可插拔工序卡”，后处理就不再是引擎内置的固定选项，而是完全由你编排的流水线。导演想在哪一步插什么滤镜，都可以自由定制——这也是 URP 相比传统内置渲染管线的最大魅力：渲染的编排权真正交到了开发者手上。

优化与调试

调色房里的每道工序都要花钱：胶片、拷贝、人工。后处理也一样——每个全屏pass都要把整块屏幕的像素读一遍、写一遍，带宽开销惊人。如果导演一口气加了七八层滤镜，放映机可能直接从 60 帧掉到 20 帧。这时候，预算工程师（性能优化）就得拿起计算器。

先用带宽公式粗算成本：屏幕像素数 × 每像素字节数 × pass数量 × 帧率。以1080p为例：约207万像素，RGBA每像素4字节，3个pass，60帧/秒——每秒要读写接近15GB的显存数据。这就是为什么“效果越多越好”在实时渲染里是危险的。

常见的省钱手段包括：降采样——在半分辨率纹理上做特效，再放大回屏幕，适合暗角、泛光等对细节不敏感的效果；合并pass——把多个效果的数学公式写进同一个着色器，减少全屏读写次数；还有就是用Frame Debugger看清每一遍pass的输入输出，配合RenderDoc、GPU Profiler定位究竟是哪个pass在“烧钱”。

真正的调色大师不会把所有滤镜无脑堆上去，而是每加一道都问：“这一遍值得吗？”后处理优化的本质，就是在画面质量与带宽预算之间做工程取舍——而这恰恰是资深图形工程师与普通美术脚本的分水岭。

AI 应用场景

Python 演示

import numpy as np  def make_scene(w=320, h=200):    yy, xx = np.mgrid[0:h, 0:w]    sky = 0.35 + 0.4 * (yy / h)                # 天空自上而下变亮    ground = np.where(yy > h * 0.6, 0.5, 0.0)  # 地面区域    mountain = np.where(np.abs(yy - h * 0.45 - 40 * np.sin(xx / 14.0)) < 12, 0.75, 0.0)    r = np.clip(sky + ground * 0.6, 0, 1)    g = np.clip(0.6 + 0.3 * (yy / h) + mountain, 0, 1)    b = np.clip(sky * 0.7 + mountain * 0.4, 0, 1)    return np.stack([r, g, b], axis=-1).astype(np.float32)  def make_depth(w=320, h=200):    yy, _ = np.mgrid[0:h, 0:w]    depth = np.where(yy < h * 0.6, 1.0, 0.15)  # 天空远, 地面近    return depth.astype(np.float32)  def apply_passes(scene, depth, strength=0.6):    tint = scene * np.array([1.0, 0.92, 0.85])  # 暖色调色, 模拟一张滤镜    yy, xx = np.mgrid[0:scene.shape[0], 0:scene.shape[1]]    cx, cy = scene.shape[1] / 2.0, scene.shape[0] / 2.0    far = np.sqrt((xx - cx) ** 2 + (yy - cy) ** 2)    above = 1.0 - strength * (far / far.max())  # 暗角: 离中心越远越暗    fog = 0.35 + 0.65 * depth                   # 深度雾: 越远越白    out = tint * above[..., None] * fog[..., None]    return np.clip(out, 0, 1)  def save_ppm(path, img):    h, w, _ = img.shape    raw = (img * 255).astype(np.uint8).tobytes()    with open(path, "wb") as f:        f.write(("P6\n%d %d\n255\n" % (w, h)).encode("ascii"))        f.write(raw)  def main():    w, h = 320, 200    scene = make_scene(w, h)    depth = make_depth(w, h)    out = apply_passes(scene, depth, strength=0.6)    before = np.concatenate([scene, out], axis=1)  # 左右对比: 原图 vs 后处理    save_ppm("post_process_demo.ppm", before)    print("saved post_process_demo.ppm (left: frame buffer, right: post-processed)")  if __name__ == "__main__":    main()

1. scene = np.stack([r, g, b], axis=-1)把三个颜色通道拼成一张“帧缓冲”图片，就像GPU把3D场景渲染到颜色纹理。
2. depth = np.where(yy < h * 0.6, 1.0, 0.15)生成一张模拟深度图：天空远(1.0)、地面近(0.15)，对应GPU里的深度缓冲。
3. tint = scene * np.array([1.0, 0.92, 0.85])全屏逐像素乘法调色，是后处理最基础的一类操作。
4. far = np.sqrt((xx - cx) ** 2 + (yy - cy) ** 2)逐像素计算到屏幕中心的距离，暗角效果的“uv坐标”来源。
5. fog = 0.35 + 0.65 * depth把深度映射成雾浓度，对应正文里“深度重建后做雾效”的思路。
6. out = tint * above[..., None] * fog[..., None]三个效果相乘叠加，相当于把多个pass合并进一次计算。
7. before = np.concatenate([scene, out], axis=1)左右并排输出对比，类似Frame Debugger里的“前后对照”视图。

常见误区

面试题