5.3.1 顶点着色器（Vertex Shader）#

每个顶点运行一次，职责是把顶点从模型空间送进裁剪空间。

1
#version 330 core
2
layout (location = 0) in vec3 aPos;
3
layout (location = 1) in vec3 aNormal;
4
layout (location = 2) in vec2 aTexCoord;
5

6
uniform mat4 uModel;
7
uniform mat4 uView;
8
uniform mat4 uProjection;
9
uniform mat3 uNormalMatrix;   // inverse-transpose of upper-left 3x3 of uModel
10

11
out vec3 vWorldPos;
12
out vec3 vNormal;
13
out vec2 vTexCoord;
14

15
void main() {
16
    vec4 worldPos = uModel * vec4(aPos, 1.0);
17
    vWorldPos = worldPos.xyz;
18
    vNormal   = normalize(uNormalMatrix * aNormal);
19
    vTexCoord = aTexCoord;
20
    gl_Position = uProjection * uView * worldPos;
21
}

WARNING

法向量必须用 (M⁻¹)ᵀ 的左上 3×3 去变换，不能直接乘 uModel。完整推导见 Part 1 §2.3，本部分 §6.2 只放工程实现。

5.3.2 片段着色器（Fragment Shader）#

光栅化器每覆盖一个像素就调一次。Vertex Shader 的 out 变量到这里已经是透视校正插值过的结果。

1
#version 330 core
2
in vec3 vWorldPos;
3
in vec3 vNormal;
4
in vec2 vTexCoord;
5

6
uniform sampler2D uAlbedo;
7
uniform vec3 uLightPos;
8
uniform vec3 uViewPos;
9
out vec4 FragColor;
10

11
void main() {
12
    vec3 N = normalize(vNormal);
13
    vec3 L = normalize(uLightPos - vWorldPos);
14
    vec3 V = normalize(uViewPos  - vWorldPos);
15
    vec3 H = normalize(L + V);                 // 半角向量（Blinn-Phong）
16

17
    vec3  albedo   = texture(uAlbedo, vTexCoord).rgb;
18
    float diff     = max(dot(N, L), 0.0);
19
    float spec     = pow(max(dot(N, H), 0.0), 64.0);
20
    vec3  ambient  = 0.1 * albedo;
21
    vec3  diffuse  = diff * albedo;
22
    vec3  specular = vec3(0.3) * spec;
23

24
    FragColor = vec4(ambient + diffuse + specular, 1.0);
25
}

8.1.1 问题#

给定两个整数端点 $(x_0, y_0)$ 和 $(x_1, y_1)$，在像素网格上画出一条近似直线，要求：

• 每列（或每行）只点亮一个像素，避免断线
• 只用整数加减和比较，没有除法和浮点

8.1.2 从直线方程出发#

设 $Delta x = x_1 - x_0 > 0$，$Delta y = y_1 - y_0 > 0$，斜率 $m = Delta y / Delta x in (0, 1]$。直线方程写成隐式：

• $F > 0$：点在直线下方
• $F < 0$：点在直线上方
• $F = 0$：点在直线上

8.1.3 中点判据#

假设已经点亮了 $(x_k, y_k)$，下一个像素只能在 $(x_k+1, y_k)$ 或 $(x_k+1, y_k+1)$ 二选一。取两者的中点 $M = (x_k+1, y_k+0.5)$，代入 $F$：

• $d_k < 0$：中点在直线上方 → 直线更靠下 → 选 $(x_k+1, y_k)$
• $d_k geq 0$：中点在直线下方 → 直线更靠上 → 选 $(x_k+1, y_k+1)$

8.1.4 增量化（关键一步）#

直接算 $d_k$ 还有浮点。相邻两步的判据差值是纯整数：

情况 A：$d_k < 0$，选 $(x_k+1, y_k)$

情况 B：$d_k geq 0$，选 $(x_k+1, y_k+1)$

初值：$d_0 = F(x_0+1, y_0+0.5) = Delta y - 0.5Delta x$。为了消去 $0.5$，两边同乘 2，得到全整数版本：

8.1.5 工程实现#

1
void bresenham_line(int x0, int y0, int x1, int y1,
2
                    std::function<void(int, int)> set_pixel) {
3
    // 保证 x 方向递增；对 |m|>1 的情况交换 x/y 扫描
4
    bool steep = std::abs(y1 - y0) > std::abs(x1 - x0);
5
    if (steep)            { std::swap(x0, y0); std::swap(x1, y1); }
6
    if (x0 > x1)          { std::swap(x0, x1); std::swap(y0, y1); }
7

8
    int dx    = x1 - x0;
9
    int dy    = std::abs(y1 - y0);
10
    int d     = 2 * dy - dx;          // 初值 d_0
11
    int ystep = (y0 < y1) ? 1 : -1;
12
    int y     = y0;
13

14
    for (int x = x0; x <= x1; ++x) {
15
        if (steep) set_pixel(y, x);    // 还原坐标轴交换
16
        else       set_pixel(x, y);
17

18
        if (d > 0) { y += ystep; d -= 2 * dx; }
19
        d += 2 * dy;
20
    }
21
}

TIP

Bresenham 的思想——用整数增量替代浮点计算——在后面的圆/椭圆画法、DDA 光栅化、各向异性过滤里都会反复出现。

8.2.1 边方程（Edge Function）#

三角形 $\triangle ABC$ 的有向边 $\overrightarrow{AB}$ 对应一条直线，其边函数

几何意义：$E_{AB}(P)$ 等于 2 × 三角形 $\triangle ABP$ 的有向面积（逆时针为正）。

点 $P$ 在三角形内的判据（三角形逆时针）：

8.2.2 包围盒遍历#

现代光栅化不再用扫描线，而是轴对齐包围盒 + 边方程测试：

1
void rasterize_triangle(const Vector3f v[3],
2
                        std::function<void(int, int, float, float, float)> shade) {
3
    // 计算整数包围盒（注意屏幕边界裁剪）
4
    int x_min = std::max(0,        (int)std::floor(std::min({v[0].x(), v[1].x(), v[2].x()})));
5
    int x_max = std::min(width -1, (int)std::ceil (std::max({v[0].x(), v[1].x(), v[2].x()})));
6
    int y_min = std::max(0,        (int)std::floor(std::min({v[0].y(), v[1].y(), v[2].y()})));
7
    int y_max = std::min(height-1, (int)std::ceil (std::max({v[0].y(), v[1].y(), v[2].y()})));
8

9
    for (int y = y_min; y <= y_max; ++y) {
10
        for (int x = x_min; x <= x_max; ++x) {
11
            // 以像素中心 (x+0.5, y+0.5) 做测试
12
            auto [a, b, g] = barycentric_2d(x + 0.5f, y + 0.5f, v);
13
            if (a >= 0 && b >= 0 && g >= 0) {
14
                shade(x, y, a, b, g);
15
            }
16
        }
17
    }
18
}

为什么用包围盒而不是扫描线？

• 扫描线需要对三角形顶点排序 + 边增量计算，分支多
• 包围盒 + 边方程对 SIMD/GPU 天然友好，可以 2×2 像素块并行
• 支持任意三角形朝向（顺时针/逆时针只需切换符号）

8.2.3 Top-Left 规则#

相邻三角形共享边时，如果两边都严格用 $geq$，会导致共享像素被画两次；用 $>$ 又会漏画。DirectX/OpenGL 约定Top-Left Fill Rule：

• 只有左边（从下到上的边）和顶边（水平、从左到右的边）上的像素算作”内部”
• 其他边上的像素算作”外部”

这样任何一个像素只会被恰好一个三角形覆盖，避免闪烁与双重着色。

8.3.1 定义#

对三角形 $\triangle ABC$ 内任意一点 $P$，存在唯一的一组非负数 $(\alpha, \beta, \gamma)$ 满足：

这就是 $P$ 的重心坐标。三个权重分别对应三个顶点的”影响力”。

8.3.2 面积比公式（完整推导）#

核心引理：$alpha, beta, gamma$ 等于 $P$ 关于对顶边所切分出的子三角形面积比。

证明：固定 $alpha + beta + gamma = 1$，将 $P = \alpha A + \beta B + \gamma C$ 代入 $overrightarrow{CP} = P - C$：

用 $\overrightarrow{CB}$ 叉乘两边：

两边取模：

同理：

8.3.3 二维情形的标准公式#

二维下用 $z=0$ 的叉积求面积：$text{Area}(triangle ABC) = frac{1}{2}left|(x_B-x_A)(y_C-y_A) - (x_C-x_A)(y_B-y_A)right|$。记三角形总面积的两倍为 $D$，则

8.3.4 工程实现#

1
// GAMES101 Assignment 2 风格，已整理
2
std::tuple<float, float, float>
3
barycentric_2d(float x, float y, const Eigen::Vector3f v[3]) {
4
    float x0 = v[0].x(), y0 = v[0].y();
5
    float x1 = v[1].x(), y1 = v[1].y();
6
    float x2 = v[2].x(), y2 = v[2].y();
7

8
    float denom = (y1 - y2) * (x0 - x2) + (x2 - x1) * (y0 - y2);
9
    float a = ((y1 - y2) * (x  - x2) + (x2 - x1) * (y  - y2)) / denom;
10
    float b = ((y2 - y0) * (x  - x2) + (x0 - x2) * (y  - y2)) / denom;
11
    float c = 1.0f - a - b;
12
    return {a, b, c};
13
}

8.3.5 属性插值的通用公式#

已知三角形三个顶点的属性 $f_A, f_B, f_C$（深度、颜色、法向量、UV 等），三角形内部任一点的属性值：

但这只在屏幕空间线性的属性上成立——颜色这种无所谓，深度和 UV 需要透视校正（见 §8.4）。

8.4.1 为什么屏幕空间线性插值是错的#

透视投影后，世界空间里等距的三个点，在屏幕上不等距。直接在屏幕空间线性插值 UV，结果会在倾斜面上明显”挤”在一起（远处纹理被拉长）。

8.4.2 深度倒数线性#

关键数学事实：

这是因为透视投影本质上是 $z' = az + b / z$ 形式，其中 $1/z$ 对应于投影空间中的线性量。因此：

8.4.3 任意属性的透视校正#

对任意顶点属性 $f$（UV、世界空间坐标、法向量），$f/z$ 也在屏幕空间线性：

所以正确的插值是：

8.4.4 工程实现#

1
// alpha, beta, gamma: 屏幕空间重心坐标
2
// z_a/b/c: 三个顶点在相机空间的深度（正值）
3
// f_a/b/c: 三个顶点上待插值的属性
4
template <typename T>
5
T perspective_correct(float alpha, float beta, float gamma,
6
                      float z_a, float z_b, float z_c,
7
                      const T& f_a, const T& f_b, const T& f_c) {
8
    float inv_z = alpha / z_a + beta / z_b + gamma / z_c;
9
    T     num   = alpha * f_a / z_a + beta * f_b / z_b + gamma * f_c / z_c;
10
    return num / inv_z;
11
}

WARNING

深度值本身的插值比较特殊：在光栅化里，传进深度缓冲的 $z_{NDC}$ 可以直接用重心坐标线性插值（因为投影矩阵已经让 $z_{NDC}$ 在屏幕空间线性）。但 UV / 世界坐标 / 法向量必须走透视校正公式。

8.5.1 Tile-Based 光栅化#

移动 GPU（Mali, Adreno, PowerVR, Apple GPU）和部分桌面 GPU 把屏幕切成 16×16 或 32×32 的 tile，每个 tile 独立光栅化。好处：

• Tile 内的 Framebuffer 能装进片上 SRAM，带宽消耗大幅降低
• 同一个 tile 的像素天然 SIMD
• 适合大规模并行

8.5.2 Early-Z 与 Hi-Z#

Early-Z：如果片段着色器不修改深度（没有 discard、没有 gl_FragDepth），硬件会在 FS 之前就做深度测试，被遮挡的片段直接跳过 FS，节省大量计算。

Hi-Z（Hierarchical Z）：对深度缓冲建 Mipmap，每个 tile 记录最大/最小深度。三角形进入前先查 Hi-Z，能批量剔除整块被遮挡的像素。

1
bool hiz_reject(int tile_x, int tile_y, int level,
2
                float tri_z_near) {
3
    float tile_z_max = hi_z[level][tile_y * tile_stride[level] + tile_x];
4
    return tri_z_near > tile_z_max;   // 整个 tile 都在三角形前面 → 剔除
5
}

8.5.3 2×2 像素 Quad#

片段着色器实际上以 2×2 像素为最小单位执行。这是因为硬件需要相邻像素的属性差来估算 $\partial u/\partial x, \partial u/\partial y$ 等导数，用于 Mipmap 选级和各向异性过滤。

WARNING

正因如此，分支内调用 texture() 是危险的——如果同 Quad 中有的像素走 if 分支、有的走 else 分支，导数就不对了。常见症状是树叶、栅栏的 Alpha Test 边缘出现 Mipmap 错误。

9.2.1 非线性的深度分布#

透视投影后，NDC 深度与相机空间深度的关系：

求导得精度分布：

这个精度与 $z_{view}^2$ 成反比——远处精度急剧下降。

9.2.2 Z-Fighting 的数学条件#

24 位深度缓冲区的最小可分辨单位：

在相机空间距离 $z$ 处，两个表面可区分的最小间距：

举例：$n = 0.1, f = 1000, z = 100$，$Delta z_{view}^{min} approx 0.030$ —— 3 cm 以内的两个面会冲突。

9.2.3 三个常用缓解方法#

方法一：收紧近远平面比值

f/n 越大、精度越差。工程经验：$f/n < 1000$ 比较安全，$f/n < 10000$ 可用，$f/n > 10000$ 极易出问题。

方法二：Polygon Offset

1
glEnable(GL_POLYGON_OFFSET_FILL);
2
glPolygonOffset(1.0f, 1.0f);   // 把当前绘制的三角形"推远"一点点

常用于阴影贴图——把遮挡物稍微推远避免自遮挡（shadow acne）。

方法三：反向 Z（Reverse-Z）

把近平面映射到 $z_{NDC} = 1$，远平面映射到 $z_{NDC} = 0$，配合浮点深度缓冲。利用 IEEE 754 浮点在接近 0 处精度更高的特性，精度分布从”远处差”变成”远处好”，大大缓解远场 Z-Fighting。

1
// 反向 Z 投影矩阵（OpenGL 约定需要 glClipControl 切换裁剪空间）
2
Eigen::Matrix4f reverse_z_projection(float fov, float aspect,
3
                                     float n, float f) {
4
    float t = std::tan(fov * 0.5f);
5
    Eigen::Matrix4f P = Eigen::Matrix4f::Zero();
6
    P(0, 0) =  1.0f / (aspect * t);
7
    P(1, 1) =  1.0f / t;
8
    P(2, 2) =  n / (f - n);                    // 近→1, 远→0
9
    P(2, 3) = (f * n) / (f - n);
10
    P(3, 2) = -1.0f;
11
    return P;
12
}
13

14
// 配合：
15
glClipControl(GL_LOWER_LEFT, GL_ZERO_TO_ONE);
16
glDepthFunc(GL_GREATER);                      // 比较方向反过来
17
glClearDepth(0.0f);                           // 清成 0（代表"最远"）

9.3.1 画家算法#

按深度从远到近绘制。致命弱点：

• 循环遮挡处理不了（三角形 A 挡 B、B 挡 C、C 挡 A）
• 穿插的长条三角形无法用单个深度值代表

今天的用法：只用在透明物体的 Sort-Then-Draw 流程里，因为 Z-Buffer 无法正确混合半透明。

9.3.2 BSP 树#

用一系列分割平面把场景递归切成前后两部分，建一棵二叉空间分割树。遍历时按相机和分割平面的位置关系决定先画哪边——能对静态几何得到绝对正确的深度顺序，不需要 Z-Buffer。

经典用途：Doom / Quake 时代的室内渲染。现代 GPU 有 Z-Buffer 后基本被淘汰，但在CSG 布尔运算、碰撞检测中仍有身影。

10.1.1 渲染方程的形式#

Kajiya 1986 提出的渲染方程描述了任何表面点的出射辐射度：

• $L_o$：从 $\mathbf{p}$ 点沿 $\omega_o$ 方向的出射辐射度
• $L_e$：自发光
• $f_r$：BRDF，描述入射→出射的反射率
• $L_i$：入射辐射度
• $costheta_i = vec{n} cdot omega_i$：入射方向与法向量夹角的余弦

10.1.2 光栅化管线的经验近似#

光栅化管线没能力求解这个积分——每个片段只能访问自己的局部信息。于是Phong 模型把积分替换为对少量光源的求和：

这是一种经验模型，精度低但速度极快。物理正确的 PBR 模型（Cook-Torrance、Disney BRDF）见 Part 6。

10.2.1 三分量结构#

10.2.2 漫反射：Lambert 定律#

物理假设：理想粗糙表面各方向反射均匀。能量守恒给出 BRDF：

推导：出射辐射度 $L_r$ 在半球上积分应等于入射辐照度 $E$ 乘以 $rho_d$：

其中半球积分 $int_{Omega} costheta, domega = pi$。由 BRDF 定义 $f_r = L_r / E$，得 $f_r = rho_d / pi$。

10.2.3 镜面反射与反射向量#

给定入射单位向量 $\mathbf{l}$ 和法向量 $mathbf{n}$，反射向量 $\mathbf{r}$ 应该：

1. 与 $\mathbf{n}$ 夹角等于 $\mathbf{l}$ 与 $\mathbf{n}$ 的夹角
2. 与 $mathbf{l}$、$mathbf{n}$ 共面

推导：把 $\mathbf{l}$ 分解为平行 $\mathbf{n}$ 和垂直 $\mathbf{n}$ 两个分量：

反射只翻转切向分量 $mathbf{l}_perp$：

WARNING

GLSL 的 reflect(I, N) 约定 $\mathbf{I}$ 是从光源射入的方向（即 $-mathbf{l}$），返回 $mathbf{I} - 2(mathbf{N} cdot mathbf{I})mathbf{N}$。符号容易搞错，自己实现时务必验证。

10.2.4 工程实现#

1
Eigen::Vector3f phong_shade(const Eigen::Vector3f& p,       // 世界空间点
2
                            const Eigen::Vector3f& n,       // 单位法向量
3
                            const Eigen::Vector3f& eye_pos,
4
                            const Light&    light,
5
                            const Material& mat) {
6
    Eigen::Vector3f l = (light.position - p).normalized();
7
    Eigen::Vector3f v = (eye_pos        - p).normalized();
8
    Eigen::Vector3f r = 2.0f * n.dot(l) * n - l;
9

10
    // 距离衰减（平方反比定律）
11
    float r2 = (light.position - p).squaredNorm();
12
    Eigen::Vector3f I_eff = light.intensity / r2;
13

14
    Eigen::Vector3f ambient  = mat.ka.cwiseProduct(light.ambient);
15
    Eigen::Vector3f diffuse  = mat.kd.cwiseProduct(I_eff)
16
                             * std::max(0.0f, n.dot(l));
17
    Eigen::Vector3f specular = mat.ks.cwiseProduct(I_eff)
18
                             * std::pow(std::max(0.0f, r.dot(v)), mat.shininess);
19

20
    return ambient + diffuse + specular;
21
}

10.3.1 动机#

Phong 的 $\mathbf{r} \cdot \mathbf{v}$ 在掠射角（光源几乎平行于表面）附近数值不稳定，同时每个像素都要算一次 $mathbf{r}$。Blinn 1977 观察到一个等效替代：

$\mathbf{h}$ 是入射与视线方向的半角向量。用 $(\mathbf{n} \cdot \mathbf{h})^{n'}$ 替换 $(mathbf{r} cdot mathbf{v})^n$。

10.3.2 几何等价性#

微表面理论视角：只有法向量恰好等于 $\mathbf{h}$ 的微面才把光线从 $\mathbf{l}$ 反射到 $mathbf{v}$。所以 $\mathbf{n} \cdot \mathbf{h}$ 测量的是”当前宏观法向量”与”完美反射所需微表面法向量”的夹角，物理意义比 $\mathbf{r} \cdot \mathbf{v}$ 更直接。

10.3.3 指数修正#

经验公式 $n_{Blinn} approx 4 n_{Phong}$，得到视觉上近似大小的高光。

10.3.4 为什么大家都用 Blinn-Phong#

• 便宜：省掉 reflect() 的计算
• 稳定：掠射角下不会突变
• 可定向光源复用：平行光下 $\mathbf{l}$ 和 $\mathbf{v}$ 都是常数，$mathbf{h}$ 整帧可以预计算
• 贴近 PBR：微表面 GGX/Beckmann 模型里，$mathbf{n} cdot mathbf{h}$ 是天然的自变量

11.1.1 UV 坐标系#

纹理是一张 $W \times H$ 的图像。UV 坐标 $(u, v) \in [0, 1]^2$ 是归一化的纹理坐标，与具体分辨率解耦。

连续纹理坐标到像素索引的映射（采样点在像素中心）：

11.1.2 最近邻采样#

优点：保真、可见像素细节；缺点：放大时出现明显锯齿 / 阶梯感。