城市漫游项目里,两栋楼的墙面距离只有十几厘米,近处看完全正常,镜头一拉远,两面墙就开始互相穿插,出现横条纹,走一步闪一下。美术怀疑模型穿模,把间距拉到一米,问题消失,但整条街的比例也毁了。
另一个场景是展柜玻璃。玻璃后面的展品在正面看还在,换个角度就整块消失。程序检查了透明材质、混合模式、渲染队列,都没错。最后的结论是:玻璃写了深度,它把后面的展品挡在了深度测试之外,混合根本没轮到。
这两个现象都发生在光栅化和深度测试这一层。前者是深度值被量化成同一个数,谁先画谁赢,于是闪烁;后者是把「不透明物体的深度规则」错误地用在了半透明物体上。这篇把三角形怎么变成像素、深度测试插在哪一步、深度精度怎么算、半透明该怎么排序,逐段拆开,并用脚本跑出具体的覆盖图和深度值。
| 现象 | 真实原因 | 第一步查什么 |
|---|---|---|
| 远处的两面墙互相穿插闪烁 | 两个表面的深度被量化到同一个值,绘制顺序决定谁可见 | 算一下该距离处的深度精度,再看近远裁剪面比值 |
| 玻璃后面的物体整块消失 | 透明物体写了深度,后面的片元被深度测试拒绝 | 检查透明材质的深度写入是否关闭 |
| 半透明叠多层后颜色不对 | 绘制顺序不是从远到近,混合结果不可交换 | 打印透明物体的绘制顺序和相机距离 |
| 模型边缘有一圈锯齿 | 每个像素只判断中心点是否在三角形内,没有覆盖率 | 开关抗锯齿对比,确认是几何边缘问题 |
| 细长的三角形完全不显示 | 三角形在屏幕上小于一个像素,采样点没落进去 | 看该物体是否含有大量退化或极小的三角形 |
| 场景很空但帧率很低 | 大量片元被着色后才被深度测试丢弃,过度绘制严重 | 先画一遍深度,再画颜色,看帧率变化 |
| 开了透明裁剪后性能骤降 | 片元着色器里丢弃像素会关闭提前深度测试 | 检查材质是否使用了丢弃指令或透明度测试 |
| 两个模型共用一条边时出现亮线 | 共享边上的像素被两个三角形各着色一次并混合 | 检查光栅化规则是否保证每条边只归属一个三角形 |
判断像素在不在三角形里
光栅化的任务是:给定一个已经投影到屏幕上的三角形,找出所有被它盖住的像素。做法不是真的去求面积,而是对每个像素取一个采样点,通常就是像素中心,然后判断这个点在不在三角形内部。
判断方法叫边函数,也叫半平面判断。三角形三条边,每条边把平面分成两侧,一个点在三角形内部,当且仅当它在这三条边的同一侧。把每条边的方向向量和「点到边起点」的向量做叉积,得到三个有符号面积,符号一致就在里面。这个算法只用乘法和减法,没有除法,硬件实现非常便宜。
三个有符号面积还有一个额外用途:它们可以直接归一化成重心坐标。重心坐标是三个权重,加起来等于一,分别表示这个点离三个顶点有多近。点正好在某个顶点上,那个顶点的权重是一,另外两个是零;点在三角形正中央,三个权重都是三分之一。
重心坐标的价值在于插值。顶点上的颜色、纹理坐标、法线、深度,都可以用这三个权重加权求和,得到像素位置上的值。因为三角形是平的,这种线性插值在三角形内部是精确的,不需要额外近似。后面讲的透视校正、法线插值,都是在这套权重上做文章。
还有一条容易被忽略的规则:相邻两个三角形共享一条边时,这条边上的像素只能归其中一个,不能两个都算。否则两个三角形各着色一次,颜色被叠加两次,就会出现一条比周围亮的细线。硬件用一条「左上归属」规则来保证每个像素只被覆盖一次,手写软件光栅器时也必须照做,否则模型上会出现网格状亮边。
包围盒与扫描
逐个像素判断整个屏幕太浪费,所以光栅化会先算三角形的屏幕包围盒:取三个顶点横纵坐标的最小值和最大值,围出一个矩形,只在这个矩形里逐像素判断。矩形之外的像素根本不可能被覆盖,直接跳过。
包围盒的代价是可能包含大量空像素。一个又细又斜的三角形,包围盒面积可能是三角形本身的好几倍,判断了却不在里面,这些计算白做。所以现代显卡会在包围盒内部按行或者按小块进一步裁剪,减少无效判断。这也是为什么极细的三角形效率低。
显卡实际不是逐像素独立工作的,而是按二乘二的小方块成组处理。一个小方块里只要有一个像素被覆盖,另外三个也会被一起算,这叫四像素组。好处是纹理采样和导数计算可以共享,坏处是小三角形会浪费:一个只盖住一个像素的三角形,实际占用了四个像素的计算量。
屏幕上的三角形越小,这种浪费越严重。一个模型细分到每个三角形只有几个像素时,有效计算可能不到一半。这也是「面数不是越高越好」的一个具体原因:不是显卡画不动,而是很多三角形小到效率极低。
光栅化之前还会做背面剔除,把背对相机的三角形直接丢掉。判断方法是用顶点绕序算一个屏幕空间的有符号面积,符号不对就是背面。这一步能省掉大约一半的三角形,而且必须在光栅化之前,因为它连一个像素都不用生成。但绕序被负缩放翻转、或者模型导入时坐标系换了,就会把正面剔掉,模型看起来像一张空壳。
深度测试插在片元阶段
片元有了颜色之后,还要过一关深度测试。每个像素在深度缓冲里存着一个当前最近的距离,新片元带着自己的深度来比较,比它更近就通过并更新,更远就丢弃。这样不管三角形按什么顺序画,最后留下的都是最近的那个表面。
这一步的位置很关键:它在片元着色之后。也就是说,一个片元可能先被完整地着色,算完纹理和光照,才被告知「你被挡住了」。这部分计算完全白费。场景里重复覆盖越严重,浪费越大,这就是过度绘制。
显卡有一个优化叫提前深度测试:如果一个材质的片元着色器不写深度、不使用丢弃指令,硬件可以在着色之前先做深度比较,被挡住的片元直接跳过。多数不透明材质都满足这个条件,所以实际浪费没有理论值那么夸张。
但只要着色器里用了丢弃,或者写入了深度,提前测试就得关掉,因为硬件无法在着色前知道这个片元最终会不会被丢掉。透明裁剪的树叶、栅栏、粒子经常这么写,于是它们的过度绘制成本会完整地体现出来。这也是「开了透明裁剪之后变卡」的典型原因。
跑一遍覆盖与深度
下面这段用一个十乘十的小画布,画两个三角形。先画近的,深度零点三五;再画远的,深度零点六零。理论上远的那层应该被深度测试完全挡住,重叠区域保持近的值。
W = H = 10
def edge(a, b, p):
return (p[0] - a[0]) * (b[1] - a[1]) - (p[1] - a[1]) * (b[0] - a[0])
def inside(p, tri):
w0 = edge(tri[1], tri[2], p)
w1 = edge(tri[2], tri[0], p)
w2 = edge(tri[0], tri[1], p)
return (w0 >= 0 and w1 >= 0 and w2 >= 0) or (w0 <= 0 and w1 <= 0 and w2 <= 0)
A = [(1, 1), (9, 2), (3, 8)]
B = [(2, 3), (8, 8), (5, 1)]
def draw(tri, z, buf, cov):
for y in range(H):
for x in range(W):
p = (x + 0.5, y + 0.5)
if inside(p, tri):
cov[y][x] += 1
if z < buf[y][x]:
buf[y][x] = z
zbuf = [[1.0] * W for _ in range(H)]
cov = [[0] * W for _ in range(H)]
draw(B, 0.35, zbuf, cov) # 先画近的
draw(A, 0.60, zbuf, cov) # 再画远的,应该被深度测试挡住
print("coverage (0/1/2):")
for row in cov:
print(row)
print("depth buffer (empty=1.0):")
for row in zbuf:
print([round(v, 2) for v in row])
print("pixels covered:", sum(1 for row in cov for v in row if v))
print("overlap pixels:", sum(1 for row in cov for v in row if v == 2))
# 深度精度:near=0.1 far=100 的透视深度,量化到 24 bit 和 16 bit
def q(d, bits):
nd = (1 / d - 1 / near) / (1 / far - 1 / near)
return round(nd * (2 ** bits))
near, far = 0.1, 100.0
for a, b in [(0.9, 0.91), (50, 50.1), (90, 90.1)]:
print("z", a, b, "24bit diff", q(b, 24) - q(a, 24), "16bit diff", q(b, 16) - q(a, 16))
在本机 Python 3.15 上实际运行,输出如下:
coverage (0/1/2):
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
[0, 1, 1, 1, 2, 0, 0, 0, 0, 0]
[0, 1, 1, 2, 2, 2, 1, 1, 1, 0]
[0, 0, 1, 2, 2, 2, 1, 1, 0, 0]
[0, 0, 1, 1, 2, 2, 2, 0, 0, 0]
[0, 0, 1, 1, 1, 2, 1, 0, 0, 0]
[0, 0, 0, 1, 1, 0, 1, 0, 0, 0]
[0, 0, 0, 1, 0, 0, 0, 1, 0, 0]
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
depth buffer (empty=1.0):
[1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]
[1.0, 0.6, 0.6, 0.6, 0.35, 1.0, 1.0, 1.0, 1.0, 1.0]
[1.0, 0.6, 0.6, 0.35, 0.35, 0.35, 0.6, 0.6, 0.6, 1.0]
[1.0, 1.0, 0.6, 0.35, 0.35, 0.35, 0.6, 0.6, 1.0, 1.0]
[1.0, 1.0, 0.6, 0.6, 0.35, 0.35, 0.35, 1.0, 1.0, 1.0]
[1.0, 1.0, 0.6, 0.6, 0.6, 0.35, 0.35, 1.0, 1.0, 1.0]
[1.0, 1.0, 1.0, 0.6, 0.6, 1.0, 0.35, 1.0, 1.0, 1.0]
[1.0, 1.0, 1.0, 0.6, 1.0, 1.0, 1.0, 0.35, 1.0, 1.0]
[1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]
[1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]
pixels covered: 33
overlap pixels: 11
z 0.9 0.91 24bit diff 20505 16bit diff 80
z 50 50.1 24bit diff 67 16bit diff 1
z 90 90.1 24bit diff 21 16bit diff 0
覆盖图里的数字表示这个像素被几个三角形盖住,零是没有,一是只被一个盖住,二是两个都盖住。总计三十三个像素被覆盖,其中十一个重叠。这十一个就是过度绘制的来源:如果先画远的再画近的,远的那些片元虽然最终看不见,着色计算却已经花掉了。
深度图验证了深度测试的作用。重叠区域的深度全都是零点三五,也就是近的那层赢了,不管它是先画还是后画。空像素保持初始值一点零,说明没有三角形覆盖。这套机制让绘制顺序不影响不透明物体的最终外观。
下面三行是精度。九十万米到九十一厘米这一对,二十四位深度的差值是两万零五百零五,十六位只有八十,还能分开。五十米到五十点一米,二十四位差六十七,十六位只剩一,已经濒临无法区分。九十米到九十点一米,二十四位差二十一,十六位差零,直接合并成一个值。
所以远处的两面墙闪烁,不是模型真的穿插,而是它们的深度在缓冲里变成了同一个数,深度测试分不出谁前谁后,只能按绘制顺序决定,顺序一变就闪。把近裁剪面从零点一抬到零点三,或者把远裁剪面从一百收到五十,都能明显改善。
如果场景本身就必须同时容纳很近和很远的物体,还有一个工程手段:先单独画一遍深度,只写深度不写颜色,再画第二遍颜色。第一遍的片元着色可以极简,第二遍借助已有的深度做提前测试,几乎不产生被遮挡的着色。代价是几何要提交两次,适合片元特别贵、遮挡特别多的场景。
半透明不能只靠深度测试
不透明物体的规则是「留最近的」,因为它完全挡住后面,后面的颜色根本不需要知道。半透明不一样,它要把自己的颜色和后面的颜色按比例混合,两层都有贡献,所以不能简单丢弃远的。
正确做法是把半透明物体从远到近排序,先画最远的,再把近的叠上去。混合不满足交换律,顺序反了,颜色就不同。一个红色玻璃叠在蓝色背景上,与蓝色叠在红色上,结果完全不同,这不是误差,是两种不同的物理情形。混合公式本身在多图层与混合里逐通道拆过,alpha 通道的含义可以看通道与透明度。
同时要关闭半透明材质的深度写入。它仍然可以读深度,用来判断自己是否被不透明物体挡住,但不能写,否则它会把更远的半透明物体挡住,混合链就断了。玻璃后面的展品消失,正是因为玻璃写了深度。
排序本身也有代价。按物体排序只能解决物体之间,解决不了同一个物体内部的三角形互相穿插,比如一团烟雾、一片头发。这类情况要么拆成更小的片,要么用与顺序无关的混合方法,代价是更多内存或者更多渲染目标。没有一种方法是免费的。
如果一个半透明物体既想被前面的物体正确遮挡,又想和后面的半透明正确混合,光靠一条管线做不到。常见的折中是把透明物体按层分组,每层内部排序,层与层之间用固定顺序;或者干脆接受近似,在视觉上不敏感的角落放弃严格排序。这类取舍要在项目早期定,后期改成本很高。
边界与代价
光栅化的第一个边界是采样。每个像素只取中心一个点,三角形边缘要么全进要么全不进,于是产生锯齿。这个问题的本质不是算法粗糙,而是采样密度不够,下一篇讲抗锯齿时会展开。
第二个边界是小三角形和细长三角形。它们在包围盒里占的比例低,又会被四像素组放大,效率很差。模型细分过头、或者为了做圆角把一个面切成几百条细带,都会踩这个坑。合理的做法是按屏幕尺寸决定细分程度,远处的物体不需要那么多面。
第三个边界是深度精度。它由近远裁剪面的比值决定,不由深度缓冲的位数单独决定。把近裁剪面设成零点零一米,等于把绝大部分精度浪费在眼前一厘米,远处的深度全挤在一起。这个参数不是越小越好,够用就行。
最后是过度绘制的成本上限。最坏情况下,一个像素被几十层半透明覆盖,每层都要完整着色,成本随层数线性上升。移动端尤其敏感,因为片上内存和带宽都有限。控制的办法是减少全屏特效层数、合并粒子、把大面积半透明改成不透明加抖动。
还有一个隐蔽的边界:光栅化只对完全落在屏幕内的三角形高效,跨在屏幕边缘的大三角形需要被视口裁剪,否则包围盒会覆盖整个屏幕,判断次数按全屏算。一面贴脸的墙如果没被裁剪,光栅化会为屏幕外的区域做大量无效判断,这种浪费在剖析工具里往往显示为光栅化阶段耗时异常。
五条当天能自验的练习
- 把脚本里的两个三角形对调绘制顺序,重新跑一遍,确认深度图完全不变,理解不透明物体的顺序无关性。
- 把远三角形的深度改成零点三三,比近的还近,观察深度图哪些像素变了,确认深度测试是逐像素比较而不是整块替换。
- 把近裁剪面从零点一改成零点五,重跑精度那三行,记录十六位深度的差值变化,找出它在哪个距离开始变成零。
- 在自己项目里找出一个半透明材质,关掉深度写入再对比,确认后面的物体是否重新出现。
- 用同一个场景分别按从远到近和从近到远画半透明物体,截图对比颜色,确认混合顺序确实会改变结果。
小结
光栅化用边函数判断像素中心是否落在三角形内,用重心坐标插值顶点属性。深度测试在片元着色之后,靠深度缓冲保留最近的表面,让不透明物体的绘制顺序无关。深度精度由近远裁剪面比值决定,远处容易发生深度冲突。半透明要排序、关深度写入,不能沿用不透明物体的规则。
下一篇讲着色和光照:为什么同样的模型在正面看很亮、转到侧面就发灰,Lambert、Phong 和基于物理的模型各自在算什么,以及「金属感」到底是由哪个参数决定的。