城市漫游项目里,两栋楼的墙面距离只有十几厘米,近处看完全正常,镜头一拉远,两面墙就开始互相穿插,出现横条纹,走一步闪一下。美术怀疑模型穿模,把间距拉到一米,问题消失,但整条街的比例也毁了。

另一个场景是展柜玻璃。玻璃后面的展品在正面看还在,换个角度就整块消失。程序检查了透明材质、混合模式、渲染队列,都没错。最后的结论是:玻璃写了深度,它把后面的展品挡在了深度测试之外,混合根本没轮到。

这两个现象都发生在光栅化和深度测试这一层。前者是深度值被量化成同一个数,谁先画谁赢,于是闪烁;后者是把「不透明物体的深度规则」错误地用在了半透明物体上。这篇把三角形怎么变成像素、深度测试插在哪一步、深度精度怎么算、半透明该怎么排序,逐段拆开,并用脚本跑出具体的覆盖图和深度值。

现象真实原因第一步查什么
远处的两面墙互相穿插闪烁两个表面的深度被量化到同一个值,绘制顺序决定谁可见算一下该距离处的深度精度,再看近远裁剪面比值
玻璃后面的物体整块消失透明物体写了深度,后面的片元被深度测试拒绝检查透明材质的深度写入是否关闭
半透明叠多层后颜色不对绘制顺序不是从远到近,混合结果不可交换打印透明物体的绘制顺序和相机距离
模型边缘有一圈锯齿每个像素只判断中心点是否在三角形内,没有覆盖率开关抗锯齿对比,确认是几何边缘问题
细长的三角形完全不显示三角形在屏幕上小于一个像素,采样点没落进去看该物体是否含有大量退化或极小的三角形
场景很空但帧率很低大量片元被着色后才被深度测试丢弃,过度绘制严重先画一遍深度,再画颜色,看帧率变化
开了透明裁剪后性能骤降片元着色器里丢弃像素会关闭提前深度测试检查材质是否使用了丢弃指令或透明度测试
两个模型共用一条边时出现亮线共享边上的像素被两个三角形各着色一次并混合检查光栅化规则是否保证每条边只归属一个三角形

判断像素在不在三角形里

光栅化的任务是:给定一个已经投影到屏幕上的三角形,找出所有被它盖住的像素。做法不是真的去求面积,而是对每个像素取一个采样点,通常就是像素中心,然后判断这个点在不在三角形内部。

判断方法叫边函数,也叫半平面判断。三角形三条边,每条边把平面分成两侧,一个点在三角形内部,当且仅当它在这三条边的同一侧。把每条边的方向向量和「点到边起点」的向量做叉积,得到三个有符号面积,符号一致就在里面。这个算法只用乘法和减法,没有除法,硬件实现非常便宜。

三个有符号面积还有一个额外用途:它们可以直接归一化成重心坐标。重心坐标是三个权重,加起来等于一,分别表示这个点离三个顶点有多近。点正好在某个顶点上,那个顶点的权重是一,另外两个是零;点在三角形正中央,三个权重都是三分之一。

重心坐标的价值在于插值。顶点上的颜色、纹理坐标、法线、深度,都可以用这三个权重加权求和,得到像素位置上的值。因为三角形是平的,这种线性插值在三角形内部是精确的,不需要额外近似。后面讲的透视校正、法线插值,都是在这套权重上做文章。

还有一条容易被忽略的规则:相邻两个三角形共享一条边时,这条边上的像素只能归其中一个,不能两个都算。否则两个三角形各着色一次,颜色被叠加两次,就会出现一条比周围亮的细线。硬件用一条「左上归属」规则来保证每个像素只被覆盖一次,手写软件光栅器时也必须照做,否则模型上会出现网格状亮边。

包围盒与扫描

逐个像素判断整个屏幕太浪费,所以光栅化会先算三角形的屏幕包围盒:取三个顶点横纵坐标的最小值和最大值,围出一个矩形,只在这个矩形里逐像素判断。矩形之外的像素根本不可能被覆盖,直接跳过。

包围盒的代价是可能包含大量空像素。一个又细又斜的三角形,包围盒面积可能是三角形本身的好几倍,判断了却不在里面,这些计算白做。所以现代显卡会在包围盒内部按行或者按小块进一步裁剪,减少无效判断。这也是为什么极细的三角形效率低。

显卡实际不是逐像素独立工作的,而是按二乘二的小方块成组处理。一个小方块里只要有一个像素被覆盖,另外三个也会被一起算,这叫四像素组。好处是纹理采样和导数计算可以共享,坏处是小三角形会浪费:一个只盖住一个像素的三角形,实际占用了四个像素的计算量。

屏幕上的三角形越小,这种浪费越严重。一个模型细分到每个三角形只有几个像素时,有效计算可能不到一半。这也是「面数不是越高越好」的一个具体原因:不是显卡画不动,而是很多三角形小到效率极低。

光栅化之前还会做背面剔除,把背对相机的三角形直接丢掉。判断方法是用顶点绕序算一个屏幕空间的有符号面积,符号不对就是背面。这一步能省掉大约一半的三角形,而且必须在光栅化之前,因为它连一个像素都不用生成。但绕序被负缩放翻转、或者模型导入时坐标系换了,就会把正面剔掉,模型看起来像一张空壳。

深度测试插在片元阶段

片元有了颜色之后,还要过一关深度测试。每个像素在深度缓冲里存着一个当前最近的距离,新片元带着自己的深度来比较,比它更近就通过并更新,更远就丢弃。这样不管三角形按什么顺序画,最后留下的都是最近的那个表面。

这一步的位置很关键:它在片元着色之后。也就是说,一个片元可能先被完整地着色,算完纹理和光照,才被告知「你被挡住了」。这部分计算完全白费。场景里重复覆盖越严重,浪费越大,这就是过度绘制。

显卡有一个优化叫提前深度测试:如果一个材质的片元着色器不写深度、不使用丢弃指令,硬件可以在着色之前先做深度比较,被挡住的片元直接跳过。多数不透明材质都满足这个条件,所以实际浪费没有理论值那么夸张。

但只要着色器里用了丢弃,或者写入了深度,提前测试就得关掉,因为硬件无法在着色前知道这个片元最终会不会被丢掉。透明裁剪的树叶、栅栏、粒子经常这么写,于是它们的过度绘制成本会完整地体现出来。这也是「开了透明裁剪之后变卡」的典型原因。

跑一遍覆盖与深度

下面这段用一个十乘十的小画布,画两个三角形。先画近的,深度零点三五;再画远的,深度零点六零。理论上远的那层应该被深度测试完全挡住,重叠区域保持近的值。

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 通道的含义可以看通道与透明度。

同时要关闭半透明材质的深度写入。它仍然可以读深度,用来判断自己是否被不透明物体挡住,但不能写,否则它会把更远的半透明物体挡住,混合链就断了。玻璃后面的展品消失,正是因为玻璃写了深度。

排序本身也有代价。按物体排序只能解决物体之间,解决不了同一个物体内部的三角形互相穿插,比如一团烟雾、一片头发。这类情况要么拆成更小的片,要么用与顺序无关的混合方法,代价是更多内存或者更多渲染目标。没有一种方法是免费的。

如果一个半透明物体既想被前面的物体正确遮挡,又想和后面的半透明正确混合,光靠一条管线做不到。常见的折中是把透明物体按层分组,每层内部排序,层与层之间用固定顺序;或者干脆接受近似,在视觉上不敏感的角落放弃严格排序。这类取舍要在项目早期定,后期改成本很高。

边界与代价

光栅化的第一个边界是采样。每个像素只取中心一个点,三角形边缘要么全进要么全不进,于是产生锯齿。这个问题的本质不是算法粗糙,而是采样密度不够,下一篇讲抗锯齿时会展开。

第二个边界是小三角形和细长三角形。它们在包围盒里占的比例低,又会被四像素组放大,效率很差。模型细分过头、或者为了做圆角把一个面切成几百条细带,都会踩这个坑。合理的做法是按屏幕尺寸决定细分程度,远处的物体不需要那么多面。

第三个边界是深度精度。它由近远裁剪面的比值决定,不由深度缓冲的位数单独决定。把近裁剪面设成零点零一米,等于把绝大部分精度浪费在眼前一厘米,远处的深度全挤在一起。这个参数不是越小越好,够用就行。

最后是过度绘制的成本上限。最坏情况下,一个像素被几十层半透明覆盖,每层都要完整着色,成本随层数线性上升。移动端尤其敏感,因为片上内存和带宽都有限。控制的办法是减少全屏特效层数、合并粒子、把大面积半透明改成不透明加抖动。

还有一个隐蔽的边界:光栅化只对完全落在屏幕内的三角形高效,跨在屏幕边缘的大三角形需要被视口裁剪,否则包围盒会覆盖整个屏幕,判断次数按全屏算。一面贴脸的墙如果没被裁剪,光栅化会为屏幕外的区域做大量无效判断,这种浪费在剖析工具里往往显示为光栅化阶段耗时异常。

五条当天能自验的练习

  1. 把脚本里的两个三角形对调绘制顺序,重新跑一遍,确认深度图完全不变,理解不透明物体的顺序无关性。
  2. 把远三角形的深度改成零点三三,比近的还近,观察深度图哪些像素变了,确认深度测试是逐像素比较而不是整块替换。
  3. 把近裁剪面从零点一改成零点五,重跑精度那三行,记录十六位深度的差值变化,找出它在哪个距离开始变成零。
  4. 在自己项目里找出一个半透明材质,关掉深度写入再对比,确认后面的物体是否重新出现。
  5. 用同一个场景分别按从远到近和从近到远画半透明物体,截图对比颜色,确认混合顺序确实会改变结果。

小结

光栅化用边函数判断像素中心是否落在三角形内,用重心坐标插值顶点属性。深度测试在片元着色之后,靠深度缓冲保留最近的表面,让不透明物体的绘制顺序无关。深度精度由近远裁剪面比值决定,远处容易发生深度冲突。半透明要排序、关深度写入,不能沿用不透明物体的规则。

下一篇讲着色和光照:为什么同样的模型在正面看很亮、转到侧面就发灰,Lambert、Phong 和基于物理的模型各自在算什么,以及「金属感」到底是由哪个参数决定的。