游戏与图形 on 方糖猫Blog

《WebGL 编程指南》学习总结：渲染基础、核心数学与游戏引擎落地（新人友好版）

Sun, 26 Jan 2020 10:00:00 +0800

《WebGL 编程指南》学习总结

目标读者：会一点 JavaScript、想搞懂"3D 画面到底是怎么画出来的"的新人，或从 Cocos Creator 上层 API 往下挖原理的引擎使用者。参考书籍：Kouichi Matsuda / Rodger Lea《WebGL 编程指南》（WebGL Programming Guide）关键词：渲染管线、顶点/片元着色器、MVP 矩阵、纹理、深度测试

写在前面：这本书在讲什么？

《WebGL 编程指南》是 WebGL 入门最经典的一本书。它不依赖任何三方库（不用 Three.js），从 canvas 上一个三角形开始，一步步讲到多物体场景、光照、纹理、雾化。全书的知识结构可以概括成一张图：

mindmap
  root((WebGL 编程指南))
    基础准备
      Canvas 与 WebGL 上下文
      WebGL 是状态机
      清空颜色缓冲区
    着色器
      GLSL ES 语言
      顶点着色器
      片元着色器
      attribute / uniform / varying
    几何绘制
      缓冲区对象 Buffer
      三角形与图元装配
      索引绘制 IBO
    数学核心
      向量运算
      矩阵变换
      模型/视图/投影矩阵
    进阶效果
      颜色与纹理
      光照模型
      深度测试与混合
      雾化与三维交互

学这本书最大的收获不是"会用 WebGL API"，而是理解所有 3D 引擎（包括 Cocos Creator、Unity）底层都在做的同一件事：把一堆顶点数据，经过数学变换和逐像素计算，画到屏幕上。理解了这套流程，引擎里的材质、Shader、渲染设置对你来说就再也不是黑盒。

一、渲染基础知识：画面是怎么画出来的？

1.1 一句话理解渲染管线

渲染（Rendering）就是把"三维场景的数学描述"转换成"屏幕上一个个像素颜色"的过程。

WebGL 渲染管线是一条固定流水线，数据从 CPU 流向 GPU，每个阶段各司其职：

flowchart LR
    A[CPU: JavaScript<br/>准备顶点数据] -->|gl.bufferData| B[GPU 缓冲区<br/>顶点坐标/颜色/UV]
    B --> C[顶点着色器<br/>Vertex Shader]
    C --> D[图元装配<br/>Primitive Assembly]
    D --> E[光栅化<br/>Rasterization]
    E --> F[片元着色器<br/>Fragment Shader]
    F --> G[逐片元操作<br/>深度测试/混合]
    G --> H[帧缓冲区<br/>Framebuffer]
    H --> I[显示器画面]

    style C fill:#e1f5ff
    style F fill:#e1f5ff

逐个阶段用大白话解释：

准备数据（CPU 侧）：JavaScript 把顶点坐标、颜色、纹理坐标（UV）打包成一块"数组"（缓冲区对象 Buffer），传给 GPU。
顶点着色器：对每一个顶点执行一次你写的 GLSL 程序，核心任务是把顶点坐标变换到最终位置（乘 MVP 矩阵），输出到内置变量 gl_Position。
图元装配：GPU 按照 gl.drawArrays 指定的模式（TRIANGLES 等），把顶点三个三个地拼成三角形。
光栅化：把三角形这个"几何图形"打碎成屏幕上实际的一个个片元（可以近似理解为像素候选）。
片元着色器：对每一个片元执行一次 GLSL 程序，算出这个像素最终的颜色，输出到 gl_FragColor。纹理采样、光照计算都在这里。
逐片元操作：深度测试（谁挡谁）、模板测试、颜色混合（半透明），最后写进帧缓冲区显示出来。

关键点：顶点着色器和片元着色器是你唯一能编程的两个环节，其余都是 GPU 固定管线。WebGL 开发的本质就是"喂数据 + 写这两段 Shader"。

1.2 WebGL 是一台"状态机"

WebGL API 没有"对象"概念，它是一台巨大的状态机。你做的所有事都是：

flowchart TD
    S1[创建着色器程序<br/>gl.createProgram] --> S2[绑定到当前状态<br/>gl.useProgram]
    S2 --> S3[创建并绑定缓冲区<br/>gl.bindBuffer]
    S3 --> S4[把缓冲区接到 attribute 上<br/>gl.vertexAttribPointer]
    S4 --> S5[设置 uniform 值<br/>gl.uniformMatrix4fv]
    S5 --> S6[发出绘制命令<br/>gl.drawArrays / drawElements]
    S6 --> S7{还要画别的物体?}
    S7 -->|是| S2
    S7 -->|否| Done[本帧结束]

新人最容易犯的错就是忘记"绑定"：改了缓冲区 A 的数据，结果绘制时绑着的还是缓冲区 B。记住口诀：先绑定，再设置，后绘制。

1.3 第一个三角形的最小代码骨架

书里第 2、3 章的核心内容，浓缩起来就是这几步：

// 1. 获取 WebGL 上下文
const gl = canvas.getContext('webgl');

// 2. 编译着色器、链接成程序（顶点 + 片元着色器）
const program = createProgram(gl, VSHADER_SOURCE, FSHADER_SOURCE);
gl.useProgram(program);

// 3. 准备顶点数据并写入缓冲区
const vertices = new Float32Array([0.0, 0.5,  -0.5, -0.5,  0.5, -0.5]);
const buffer = gl.createBuffer();
gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
gl.bufferData(gl.ARRAY_BUFFER, vertices, gl.STATIC_DRAW);

// 4. 把缓冲区数据"接"到着色器的 attribute 变量上
const a_Position = gl.getAttribLocation(program, 'a_Position');
gl.vertexAttribPointer(a_Position, 2, gl.FLOAT, false, 0, 0);
gl.enableVertexAttribArray(a_Position);

// 5. 清空 + 绘制
gl.clearColor(0.0, 0.0, 0.0, 1.0);
gl.clear(gl.COLOR_BUFFER_BIT);
gl.drawArrays(gl.TRIANGLES, 0, 3);

对应的着色器（GLSL ES）：

// 顶点着色器：接收每个顶点的位置
attribute vec4 a_Position;
void main() {
  gl_Position = a_Position;   // 必须写的内置输出
}

// 片元着色器：给每个片元上色
precision mediump float;
void main() {
  gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0);  // 红色
}

1.4 三种变量：数据怎么流进着色器

变量类型	数据流向	粒度	典型用途
`attribute`	JS → 顶点着色器	每个顶点不同	顶点坐标、颜色、UV、法线
`uniform`	JS → 两个着色器	一次绘制内不变	MVP 矩阵、光照参数、时间
`varying`	顶点着色器 → 片元着色器	被光栅化插值	把顶点颜色渐变到三角形内部

varying 特别值得理解：顶点着色器给三个顶点各设了一个颜色，片元着色器拿到的却是插值后的颜色——三角形内部的颜色渐变（渐变三角形）就是这么来的。

二、核心数学知识：向量、矩阵与坐标变换

这是全书最重要、也是新人最容易劝退的部分。其实只要抓住一条主线：

flowchart LR
    A[局部坐标<br/>模型自己的坐标系] -->|模型矩阵 M| B[世界坐标<br/>摆放在场景里]
    B -->|视图矩阵 V| C[观察坐标<br/>以相机为原点]
    C -->|投影矩阵 P| D[裁剪坐标<br/>齐次坐标]
    D -->|透视除法| E[标准化设备坐标 NDC<br/>-1 到 1]
    E -->|视口变换| F[屏幕像素坐标]

著名的 MVP 矩阵就是上面三个矩阵的乘积。顶点着色器里一行代码搞定：

gl_Position = u_ProjMatrix * u_ViewMatrix * u_ModelMatrix * a_Position;

2.1 向量：方向与位置

向量就是一个有方向的箭头，如 $\vec{v} = (x, y, z)$。渲染里有两个运算用最多：

点积（Dot Product）：衡量两个向量"有多同向"。

$$ \vec{a} \cdot \vec{b} = a_x b_x + a_y b_y + a_z b_z = |\vec{a}||\vec{b}|\cos\theta $$

光照计算全靠它：光线方向和表面法线的夹角越接近 $0$，$\cos\theta$ 越大，表面越亮。这就是漫反射光照的核心公式：

$$ \text{漫反射颜色} = \text{光源颜色} \times \text{表面基底色} \times \max(\vec{n} \cdot \vec{l},\ 0) $$

其中 $\vec{n}$ 是表面法线，$\vec{l}$ 是指向光源的方向，$\max(\cdot, 0)$ 保证背光面不会出现"负亮度"。

叉积（Cross Product）：求垂直于两个向量的法线，长度为平行四边形面积。

$$ \vec{a} \times \vec{b} = (a_y b_z - a_z b_y,\ a_z b_x - a_x b_z,\ a_x b_y - a_y b_x) $$

知道三角形三个顶点，用两条边叉积就能求出面的法线方向；判断三角形朝向（正面/背面剔除）也靠它。

2.2 齐次坐标：为什么坐标是 4 维的？

三维点为什么要写成 $(x, y, z, w)$？因为平移没法用 $3 \times 3$ 矩阵乘法表示，升到 4 维后，平移、旋转、缩放、投影全部统一成一次矩阵乘法。约定：点的 $w = 1$，方向的 $w = 0$（方向不受平移影响，这个约定天然正确）。

2.3 三种基本变换矩阵

平移矩阵：

$$ T = \begin{bmatrix} 1 & 0 & 0 & T_x \\ 0 & 1 & 0 & T_y \\ 0 & 0 & 1 & T_z \\ 0 & 0 & 0 & 1 \end{bmatrix} $$

绕 z 轴旋转矩阵：

$$ R_z(\theta) = \begin{bmatrix} \cos\theta & -\sin\theta & 0 & 0 \\ \sin\theta & \cos\theta & 0 & 0 \\ 0 & 0 & 1 & 0 \\ 0 & 0 & 0 & 1 \end{bmatrix} $$

缩放矩阵：

$$ S = \begin{bmatrix} S_x & 0 & 0 & 0 \\ 0 & S_y & 0 & 0 \\ 0 & 0 & S_z & 0 \\ 0 & 0 & 0 & 1 \end{bmatrix} $$

矩阵相乘的顺序非常重要：矩阵从右往左作用于顶点。$M = T \cdot R$ 表示"先旋转再平移"，和"先平移再旋转"结果完全不同。书里的 cuon-matrix.js 提供了 setTranslate / rotate / scale 等方法，实际项目中 Cocos Creator、gl-matrix 也提供同样的能力，不需要手写。

2.4 视图矩阵与投影矩阵

视图矩阵：把整个世界"挪"到相机视角下。由三个参数决定——视点（相机位置）、观察目标点、上方向，即 lookAt：

$$ V = \text{lookAt}(\text{eye},\ \text{center},\ \text{up}) $$

投影矩阵有两种：

正射投影（Orthographic）：物体远近一样大，像工程图纸，适合 2D 游戏、UI。
透视投影（Perspective）：近大远小，符合人眼，适合 3D 场景。由一个视锥体（near、far、fov、aspect）定义。

2.5 法线矩阵：一个容易被忽略的细节

对模型做了非等比缩放（比如 x 方向压扁、y 方向拉长）后，法线不能直接乘模型矩阵，要用模型矩阵的逆转置矩阵：

$$ \vec{n}’ = (M^{-1})^{T} \cdot \vec{n} $$

书里第 8 章专门讲了这个问题。等比缩放 + 旋转时法线矩阵等于模型矩阵，所以简单场景可以偷懒，但骨骼动画、非均匀缩放时漏掉这步，光照就是错的。

三、纹理、光照与隐藏面消除

3.1 纹理贴图：把图片"贴"到三角形上

流程五步：

JS 加载图片（Image 对象）。
创建并绑定纹理对象（gl.createTexture + gl.bindTexture）。
上传图片数据到 GPU（gl.texImage2D）。
把纹理单元连接到着色器的 uniform sampler2D。
顶点传 UV 坐标，片元着色器里 texture2D(u_Sampler, v_UV) 采样取色。

新人第一坑：图片在 WebGL 里是上下颠倒的，需要 gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, true) 翻转 Y 轴。原因：图片坐标系原点在左上，纹理坐标系原点在左下。

3.2 光照：环境光 + 漫反射

书里的光照模型是最经典的 Phong 简化版，新人记住两项就够：

$$ \text{最终颜色} = \underbrace{\text{环境光} \times \text{基底色}}{\text{照亮背光面，防止死黑}} + \underbrace{\text{平行光颜色} \times \text{基底色} \times \max(\vec{n}\cdot\vec{l}, 0)}{\text{漫反射}} $$

3.3 隐藏面消除：深度缓冲区

画多个三角形时，谁挡住谁？WebGL 用深度缓冲区（Z-Buffer）：每个像素除了存颜色，还存一个深度值。新片元要写入时先和已有深度比较，更近的才覆盖。

gl.enable(gl.DEPTH_TEST);                          // 开启深度测试
gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT); // 每帧连深度一起清

忘记清深度缓冲区，画面会越画越乱——这是新人第二坑。

四、典型问题排查（踩坑指南）

4.1 “我画的东西是黑屏/什么都不显示”

这是 WebGL 新人 90% 的问题。按这个流程排查，命中率极高：

flowchart TD
    Start[画面黑屏/空白] --> Q1{着色器编译链接<br/>报错了吗?}
    Q1 -->|是| A1[看 gl.getShaderInfoLog<br/>通常是 GLSL 语法错误<br/>或精度限定符缺失]
    Q1 -->|否| Q2{顶点坐标在<br/>-1 到 1 的 NDC 范围内吗?}
    Q2 -->|否| A2[检查 MVP 矩阵<br/>是否被设置/乘反了顺序]
    Q2 -->|是| Q3{三角形顶点顺序<br/>是逆时针 CCW 吗?}
    Q3 -->|否| A3[被背面剔除干掉了<br/>gl.disable CULL_FACE 验证]
    Q3 -->|是| Q4{深度测试开启且<br/>每帧清深度缓冲了吗?}
    Q4 -->|否| A4[gl.clear 加上<br/>DEPTH_BUFFER_BIT]
    Q4 -->|是| Q5{相机在物体<br/>正确的一侧吗?}
    Q5 -->|否| A5[物体在相机背后<br/>或在视锥体 near/far 之外]
    A1 --> OK[问题解决]
    A2 --> OK
    A3 --> OK
    A4 --> OK
    A5 --> OK

4.2 深度冲突（Z-Fighting）

两个面片距离极近时，深度缓冲精度不够，会出现闪烁的"花纹"（两个面片抢着显示）。

解决方案（书里第 10 章的方法）：多边形偏移

gl.enable(gl.POLYGON_OFFSET_FILL);
gl.polygonOffset(1.0, 1.0);  // 让后画的面片深度"向后推"一点

本质原因也值得一提：透视投影的深度值不是线性的，精度集中在 near 平面附近。所以near 不要设得过小（如 0.0001），越大精度越好。

4.3 半透明物体显示错误

开启混合 gl.blendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA) 后，半透明物体仍然错乱？因为混合依赖绘制顺序：必须先画不透明物体，再按从远到近排序画半透明物体，且半透明物体之间往往要关闭深度写入（gl.depthMask(false)）只保留深度测试。

4.4 性能问题：Draw Call 太多

每个 gl.drawArrays/drawElements 都有一次 CPU→GPU 的状态切换开销。几千个小物体各画一次，帧率直接崩。思路：

合批（Batching）：把使用同一材质的小物体顶点合并到一个大缓冲区，一次画完。
纹理图集（Texture Atlas）：小图合成大图，减少纹理切换。
状态排序：按材质/着色器排序绘制顺序，减少状态切换。

五、在 Cocos Creator 中落地这些渲染知识

学 WebGL 不是为了手写引擎，而是为了看得懂 Cocos Creator 在干什么。下面对照来看。

5.1 概念对照表

WebGL 原生概念	Cocos Creator 对应物
顶点/片元着色器程序	Effect（`.effect` 文件，Cocos Effect 语法，本质还是 GLSL）
着色器 + uniform 参数集合	Material（材质）：一个 Effect 实例 + 具体参数值
attribute 顶点数据	`Mesh` / `MeshRenderer` 的顶点缓冲区
uniform 矩阵（MVP）	引擎自动填充：模型矩阵来自节点 Transform，视图/投影矩阵来自 Camera
纹理 + sampler	Material 上的 `mainTexture` 等贴图槽
深度测试/混合状态	Effect 中 Pass 的 `depthStencilState` / `blendState`
gl.drawElements	引擎渲染管线（Forward Pipeline）自动按材质合批后提交

5.2 引擎帮你做的事

flowchart TB
    subgraph 你写的部分
        N1[节点树 + Transform]
        N2[自定义 Effect / Shader]
        N3[材质参数]
    end
    subgraph 引擎自动处理
        E1[遍历场景收集可渲染对象]
        E2[计算模型矩阵<br/>节点世界变换]
        E3[相机视图/投影矩阵]
        E4[按材质排序 + 合批<br/>Draw Call 优化]
        E5[设置 uniform 常量缓冲]
        E6[调用底层图形 API]
    end
    N1 --> E1
    N2 --> E5
    N3 --> E5
    E1 --> E2 --> E3 --> E4 --> E5 --> E6
    E6 --> API[WebGL / WebGPU / Vulkan / Metal]

你 WebGL 手写时代要做的"传 MVP 矩阵、绑缓冲区、开深度测试、手动合批"，引擎全部代劳了。但底层语义完全没变：

节点的 position/rotation/scale 就是在拼第 2 节的 $T \cdot R \cdot S$ 模型矩阵；
Camera 的 fov、near、far 就是第 2.4 节的透视投影参数（所以 Cocos 里 near 设太小同样会 Z-Fighting）；
2D 游戏的 Sprite 本质是"两张三角形拼的矩形 + 纹理采样"；
SpriteFrame 图集就是第 4.4 节的纹理合批优化。

5.3 自定义 Shader：知识直接迁移

Cocos Creator 里写一个自定义 Effect，核心片段和手写 WebGL 几乎一一对应：

// Cocos Effect 的顶点着色器片段
CCProgram vs %{
  vec4 vert() {
    // CC_MAT_MV_PROJ 就是引擎帮你算好的 MVP 矩阵
    return CC_MAT_MV_PROJ * vec4(In.position, 1.0);
  }
}%

// 片元着色器片段
CCProgram fs %{
  vec4 frag() {
    // mainTexture 就是 uniform sampler2D
    return texture(mainTexture, In.uv);
  }
}%

看懂前面四章的内容后，Cocos 的 Effect 文档里那些 CC_MAT_MV_PROJ、CC_HANDLE_UNIFORM、depthStencilState 全部都能对上号。遇到"自定义描边、溶解、UV 动画"这类需求时，你写的就是片元着色器里的逐像素计算。

5.4 性能优化落地

第 4.4 节的合批思想在 Cocos 里的具体做法：

UI 用自动图集（Auto Atlas）：减少纹理切换，让 2D 合批生效；
避免跨材质穿插：合批会被不同材质打断，注意节点层级排序；
3D 场景用 GPU 实例化（Instancing）：同网格同材质的大量物体（草地、树木）一次 Draw Call 画完，相当于手动版的 gl.drawElementsInstanced；
用引擎的渲染调试工具看 Draw Call 数，和当年数 gl.drawElements 调用次数是同一件事。

六、经典特效 Demo 与实现分析

游戏里的特效看起来五花八门，拆开看几乎都是四种基本手段的组合：

mindmap
  root((特效的四板斧))
    顶点动画
      波浪/旗帜飘动
      草和树摇摆
      顶点挤出描边
    片元计算
      溶解/燃烧
      UV 扭曲(热浪/水波纹)
      菲涅尔边缘光
    粒子系统
      烟雾/火焰
      雨雪/魔法拖尾
    后处理
      泛光 Bloom
      模糊/暗角

下面挑三个最经典的特效，从原理、数学、Shader 代码到 Cocos Creator 落地完整走一遍。

6.1 烟雾：粒子系统（Billboard + Alpha 混合）

一句话原理：烟雾不是"一个模型"，而是几百个始终面向摄像机的半透明小方片（粒子），各自经历出生、上升、变大、变淡、死亡的生命周期，叠加起来就是一蓬烟。

flowchart LR
    A[发射器<br/>按速率生成粒子] --> B[初始化属性<br/>位置/速度/大小/寿命]
    B --> C[每帧更新<br/>位置 += 速度·dt<br/>透明度随寿命衰减]
    C --> D{寿命耗尽?}
    D -->|否| E[渲染: Billboard 面片<br/>采样烟雾纹理 + Alpha 混合]
    D -->|是| F[回收粒子<br/>进入对象池]
    E --> C

核心技巧一：Billboard（公告板）。粒子面片必须永远正对相机，否则侧着看就露馅。做法是从视图矩阵里取出相机的右方向和上方向向量（视图矩阵第一、二列就是它们），在顶点着色器里现场拼面片：

// 顶点着色器：粒子中心位置 + 相机坐标系下的二维偏移
uniform vec3 u_CameraRight;   // 视图矩阵第一列
uniform vec3 u_CameraUp;      // 视图矩阵第二列
attribute vec3 a_Center;      // 粒子中心（每粒子数据）
attribute vec2 a_Corner;      // 面片角点偏移 (-1~1)，每顶点数据
attribute float a_Size;

void main() {
  vec3 pos = a_Center
           + u_CameraRight * a_Corner.x * a_Size
           + u_CameraUp    * a_Corner.y * a_Size;
  gl_Position = u_ProjMatrix * u_ViewMatrix * vec4(pos, 1.0);
}

核心技巧二：透明度随生命周期衰减。用一个 0~1 的生命进度 $t_{\text{life}}$ 控制淡出，片元着色器：

vec4 tex = texture2D(u_SmokeTex, v_UV);
// 淡入淡出：两头为 0，中间最浓，一条简单的抛物线
float fade = 4.0 * v_Life * (1.0 - v_Life);
gl_FragColor = vec4(tex.rgb, tex.a * fade * u_Opacity);

渲染状态设置（对照 4.3 节的半透明坑）：

gl.enable(gl.BLEND);
gl.blendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA); // 烟雾用普通混合
// gl.blendFunc(gl.SRC_ALPHA, gl.ONE);              // 火焰改用加法混合，越叠越亮
gl.enable(gl.DEPTH_TEST);
gl.depthMask(false);   // 关键：只测深度、不写深度，粒子之间不互相遮挡

性能坑：烟雾最大的开销不是粒子数量，而是 Overdraw——大面积半透明面片层层叠叠，同一个像素被反复着色。优化方向：控制单粒子最大尺寸、用更低分辨率渲染粒子再合成（引擎做法）。

Cocos Creator 落地：ParticleSystem（3D）/ ParticleSystem2D 组件就是这套东西的完整实现——发射速率、生命周期、颜色/大小随时间曲线、Billboard 渲染模式、材质混合模式，面板上的每个参数都能在上面找到对应原理。想自定义就用 renderMode 配合自定义材质。

6.2 逼真波浪：顶点动画（正弦叠加 → Gerstner 波）

一句话原理：水面网格的几何形状本身不动，每帧在顶点着色器里用波形函数把每个顶点的 y 坐标"抬"起来，再重新算法线做光照——看到的就是流动的波浪。

入门版：正弦波叠加。单个正弦波：

$$ y = A \sin(\omega, x + \varphi, t) $$

其中 $A$ 是振幅（波多高），$\omega$ 是频率（波多密），$\varphi$ 控制波速，$t$ 是时间。多个不同方向、频率、振幅的正弦波相加，水面就"乱"得自然了：

float wave(vec2 p, vec2 dir, float freq, float amp, float speed) {
  float phase = dot(dir, p) * freq + u_Time * speed;
  return amp * sin(phase);
}

// 顶点着色器里：y = wave(p, d1,...) + wave(p, d2,...) + ...

进阶版：Gerstner 波。正弦波的波峰是圆滚滚的，真实海浪的波峰是尖锐的。Gerstner 波在抬升 y 的同时把顶点水平拉向波峰，模拟出尖峰效果：

$$ \begin{aligned} x’ &= x + Q A, D_x \cos!\big(\omega(\vec{D}\cdot\vec{p}) + \varphi t\big) \\ y’ &= A \sin!\big(\omega(\vec{D}\cdot\vec{p}) + \varphi t\big) \\ z’ &= z + Q A, D_z \cos!\big(\omega(\vec{D}\cdot\vec{p}) + \varphi t\big) \end{aligned} $$

其中 $\vec{D}$ 是波传播方向，$Q$ 是"尖锐度"参数：$Q = 0$ 退化为正弦波，$Q$ 越大波峰越尖（超过上限会自我穿插，一般取 $0 \le QA\omega \le 1$）。

关键细节：法线必须跟着重算。顶点位移后，原来的法线就不对了，光照会露馅。严谨做法是对波形函数求偏导，用解析法得到切线 $\vec{T}$ 和副切线 $\vec{B}$，法线就是 $\vec{n} = \vec{B} \times \vec{T}$。GAMES101 等课程里有完整推导，新人知道"顶点位移后要重算法线"这个坑即可。

片元着色器里的水面质感：靠菲涅尔（Fresnel）效应——视线越贴近水面（掠射角），反射越强、越像镜子；垂直看下去则越透。Schlick 近似公式：

$$ F(\theta) = F_0 + (1 - F_0),(1 - \cos\theta)^5 $$

水的 $F_0 \approx 0.02$。用 $F$ 在"水体本色"和"天空/环境反射色"之间插值，水面瞬间就有真实感。

坑提醒：顶点动画的前提是网格顶点足够密——一块只有 4 个顶点的平面怎么抬都是平的。要么建模时细分网格，要么用 tessellation。

Cocos Creator 落地：水面是自定义 Effect 的经典练手项目——cc.time（引擎内置 uniform）提供时间，顶点着色器里写 Gerstner 位移，材质面板上把振幅、频率、波速、方向暴露成可调参数。社区商城里大量水面 Shader 都是这个套路的变体。

6.3 溶解：噪声纹理 + discard

一句话原理：片元着色器里采样一张噪声图，噪声值低于阈值的像素直接丢弃（discard），阈值随时间从 0 推到 1，物体就"一点点消失"；在阈值边缘画一条发光边，就是燃烧/消散效果。

flowchart LR
    A[采样噪声纹理<br/>得到 noise 值 0~1] --> B{noise < 阈值 threshold?}
    B -->|是| C[discard<br/>该像素不画]
    B -->|否| D{noise < threshold + 边缘宽度?}
    D -->|是| E[输出边缘发光色<br/>如橙红火焰色]
    D -->|否| F[正常输出原纹理颜色]

核心代码极简：

float noise = texture2D(u_NoiseTex, v_UV).r;
if (noise < u_Threshold) discard;

// 边缘宽度内混入燃烧色，smoothstep 让过渡自然
float edge = 1.0 - smoothstep(u_Threshold, u_Threshold + u_EdgeWidth, noise);
vec3 color = mix(texture2D(u_MainTex, v_UV).rgb, u_BurnColor.rgb, edge);
gl_FragColor = vec4(color, 1.0);

discard 就是 WebGL 里的"这个片元不要了"——对照第 1.1 节的管线，它在片元着色器阶段直接终止了后续写入。噪声图的选择决定溶解风格：Perlin 噪声 = 烟雾状消散，碎裂纹理 = 破碎消失，斜向渐变 = 扫描式消失。

Cocos Creator 落地：这是新手写自定义材质的最佳起点——抄一个 builtin Effect，加 noiseTexture、threshold、edgeColor 三个材质属性，JS 里用 tween 把 threshold 从 0 推到 1，就是角色死亡消散、传送门出现等常见需求。

6.4 更多特效的快速索引

同样套路能覆盖的常见需求，新人可以先建立"这个效果属于哪一板斧"的直觉：

特效	属于	核心技术点
火焰	粒子系统	加法混合 + 颜色随生命从黄到红
旗帜/头发飘动	顶点动画	正弦波，振幅随 UV 或骨骼权重衰减
模型描边	顶点动画	沿法线挤出背面 + 正面剔除
热浪/水下扭曲	片元计算	噪声扰动 UV 后再采样
全息/护盾	片元计算	菲涅尔边缘光 + 扫描线（`fract(uv.y - time)`）
径向模糊/泛光	后处理	帧缓冲区（FBO）离屏渲染 + 二次全屏绘制

七、总结与学习路线建议

回顾全文，WebGL 学习的核心脉络是：

管线：数据从 CPU 缓冲区 → 顶点着色器 → 光栅化 → 片元着色器 → 帧缓冲，能编程的只有两个着色器。
数学：向量点积（光照）、叉积（法线）、$4\times4$ 矩阵（MVP 变换）是必须过关的三块；齐次坐标是为了统一平移。
状态机思维：先绑定、再设置、后绘制；忘了绑定或忘了清缓冲区是最高频 bug。
排查有套路：黑屏先看着色器日志，再查 NDC 范围、背面剔除、深度缓冲、相机位置。
落地到引擎：Cocos Creator 的 Effect/材质/合批，全部是这套原理的封装——学透 WebGL，引擎文档读起来就是"老朋友换新名字"。
特效有套路：再炫的效果也逃不出四板斧——顶点动画、片元计算、粒子系统、后处理，看懂烟雾、波浪、溶解三个例子就能举一反三。

建议的动手顺序（对应原书章节）：

flowchart LR
    S1[Ch2-3<br/>画三角形<br/>理解缓冲区] --> S2[Ch4<br/>矩阵变换<br/>让图形动起来]
    S2 --> S3[Ch5<br/>颜色与纹理]
    S3 --> S4[Ch7<br/>三维世界<br/>视图+投影矩阵]
    S4 --> S5[Ch8<br/>光照]
    S5 --> S6[Ch9-10<br/>多物体/高级技巧<br/>雾化/帧缓冲/选中物体]
    S6 --> S7[读 Cocos Creator<br/>Effect 源码<br/>自定义 Shader 实战]
    S7 --> S8[经典特效实战<br/>粒子烟雾/Gerstner 波浪<br/>噪声溶解]

下一步推荐：

跟着原书把每个示例亲手敲一遍，改参数观察变化（比如把投影矩阵的 near 改大改小，直观感受 Z-Fighting）。
在 Cocos Creator 里打开一个官方材质，逐行读懂它的 Effect 文件。
有余力再看《Fundamentals of Computer Graphics》（虎书）补全光栅化、光线追踪的理论体系。

《游戏开发物理学》学习笔记：从运动学到刚体碰撞的新手实战指南

Thu, 16 Jan 2020 11:00:00 +0800

《游戏开发物理学》学习笔记：从运动学到刚体碰撞的新手实战指南

参考书籍：《Physics for Game Developers》（David M. Bourg，O’Reilly，中译名《游戏开发物理学》）目标读者：想自己做物理效果（而不是只会调引擎参数）的游戏开发者、图形学/仿真方向的新手。阅读建议：这篇文章帮你建立主干知识框架：先数学，再运动学 → 动力学 → 载具模拟 → 实时积分 → 碰撞 → 粒子，最后给出避坑清单和主流引擎对照。公式只保留实战中真正会用的。

一、这本书到底讲什么？

很多新手做游戏的物理效果，路径是这样的：

用 Unity/UE 拖一个 Rigidbody，调调质量、摩擦力，能跑就行；
遇到「球穿过墙了」「车开起来像肥皂盒」「碰撞后能量爆炸越弹越高」就抓瞎；
回头发现：不是引擎不行，是自己不懂底层的物理模型。

Bourg 这本书的价值就在于：它把物理引擎内部在干什么，用程序员能实现的粒度讲了一遍。它不追求物理学的严谨完备，而是追求「在 60 FPS 的游戏循环里，用可承受的计算量，得到看起来正确、玩起来稳定的结果」。

全书知识地图：

mindmap
  root((游戏开发物理学))
    数学基础
      向量与运算
      矩阵与坐标变换
      四元数
    运动学 Kinematics
      位移 速度 加速度
      抛体运动
    动力学 Dynamics
      牛顿定律
      力与力矩
      流体阻力
    载具模拟
      飞机
      舰船
      气垫船
      汽车
    实时模拟
      数值积分
      游戏循环
      时间步长
    碰撞
      碰撞检测
      碰撞反应 冲量
    粒子系统

一句话总纲：游戏物理 = 用力计算加速度，用数值积分把加速度变成速度和位置，用碰撞检测发现问题，用冲量修正速度。整本书就是在把这句话的每个环节讲细。

二、核心数学基础速成

物理引擎 90% 的代码是向量、矩阵和四元数运算。这一关不过，后面全看不懂。

2.1 向量：物理量的通用语言

位置、速度、力、动量，全部是向量。必须熟练的运算：

加减：力的合成（$F = F_1 + F_2$）、相对速度；
点积（结果是一个数）：

$$ \mathbf{a} \cdot \mathbf{b} = |\mathbf{a}||\mathbf{b}|\cos\theta $$

实战用途：求投影（比如速度沿碰撞法线方向的分量）、判断两个方向夹角是锐角还是钝角（点积大于 0 还是小于 0）。碰撞反应里「物体是否在相互靠近」就是靠点积判断的。

叉积（结果是一个垂直向量，仅 3D；2D 中退化为一个标量）：

$$ |\mathbf{a} \times \mathbf{b}| = |\mathbf{a}||\mathbf{b}|\sin\theta $$

实战用途：力矩 $\tau = \mathbf{r} \times \mathbf{F}$（力作用点偏离质心会产生转动）、2D 碰撞冲量里的旋转项。

归一化：$\hat{\mathbf{v}} = \mathbf{v} / |\mathbf{v}|$，只要方向不要大小（碰撞法线必须归一化，忘记这步是经典 bug）。

避坑：2D 里叉积 $\mathbf{r} \times \mathbf{F}$ 是标量 $r_x F_y - r_y F_x$，正负号代表顺时针/逆时针，和引擎的坐标系朝向约定有关，写之前先定好「逆时针为正」并全程统一。

2.2 矩阵与坐标变换

旋转、缩放、坐标系切换都靠矩阵。新手只需要先建立两个直觉：

矩阵乘法 = 变换的复合，顺序不可交换（先旋转再平移 ≠ 先平移再旋转）；
每个刚体都活在两个坐标系里：局部坐标系（物体自己的，转动惯量、几何形状在这里算最方便）和世界坐标系（所有物体一起碰撞、渲染的地方）。物理计算每天的工作就是在这两个系之间来回变换。

2.3 四元数：3D 姿态的正确打开方式

3D 中表示朝向有三种方式：

方式	优点	缺点
欧拉角（roll/pitch/yaw）	直观，3 个数	万向锁（gimbal lock），插值不平滑
旋转矩阵	直接用于向量变换	9 个数冗余，数值误差积累会「变形」
四元数	4 个数紧凑，插值平滑，无万向锁	不直观，乘法规则要背

游戏物理的标准做法：内部存储和积分用四元数，给玩家看的时候转欧拉角。四元数必须经常归一化，否则数值漂移会让物体悄悄缩放变形。

2.4 微积分：只需要两个直觉

导数 = 变化率。速度是位置的导数，加速度是速度的导数。
积分 = 累积。已知加速度，累加得到速度；累加速度得到位置。

游戏里你永远不会真的去解符号积分——而是用数值积分一步步逼近（见第六章）。理解「导数是斜率、积分是累加」就够了。

2.5 单位制与坐标系：开工前先立规矩

避坑（这是新手第一大坑）：开工前必须白纸黑字定下来——

长度单位是米还是像素？重力加速度是 9.81 m/s² 还是 981 px/s²？混用必出灵异现象。

2D 屏幕坐标 y 轴向下，而物理教科书 y 轴向上。直接照抄公式会把「下落」写成「飞天」。

角度用弧度，所有三角函数接口都是弧度，传角度进去结果毫无明显错误提示。

三、运动学（Kinematics）：只描述运动，不问原因

运动学关心「物体怎么动」，不关心「为什么动」（那是动力学的事）。

3.1 三个基本量

$$ \text{速度 } \mathbf{v} = \frac{d\mathbf{x}}{dt}, \qquad \text{加速度 } \mathbf{a} = \frac{d\mathbf{v}}{dt} $$

匀加速运动（加速度恒定）下的三个实用公式：

$$ v = v_0 + at $$

$$ x = x_0 + v_0 t + \frac{1}{2} a t^2 $$

$$ v^2 = v_0^2 + 2a(x - x_0) $$

3.2 抛体运动：游戏里最值钱的运动学

抛体（炮弹、篮球、跳跃的角色）的核心思想一句话：水平方向和竖直方向互相独立，分开算。

水平：无加速度，匀速 $x = v_0 \cos\theta \cdot t$
竖直：受重力，$y = v_0 \sin\theta \cdot t - \frac{1}{2} g t^2$

由这两个式子可以推出（落回同一高度时）：

$$ \text{射程 } R = \frac{v_0^2 \sin 2\theta}{g}, \qquad \text{最高点 } H = \frac{v_0^2 \sin^2\theta}{2g} $$

两个直接能用在游戏里的结论：

45 度抛射射程最远（不计空气阻力时）；
已知初速度和目标距离，可以反解出抛射角——这就是「抛物线命中目标」的数学基础。

典型问题：炮弹打移动目标的提前量。 设目标当前位置 $\mathbf{p}$、速度 $\mathbf{v}_t$，炮弹速度 $s$，求解命中时间 $t$：

$$ |\mathbf{p} + \mathbf{v}_t t| = s t $$

两边平方得到一个关于 $t$ 的一元二次方程，取最小正根，瞄准点就取 $\mathbf{p} + \mathbf{v}_t t$。AI 炮塔、技能预判全是这个套路。

避坑：二次方程可能无解（目标跑得太快炮弹追不上），代码里必须处理判别式小于 0 的情况，否则 AI 会对着永远打不中的目标开火。

四、作用力与动力学（Dynamics）：运动的原因

4.1 牛顿三定律的程序员版本

惯性定律：不受力的物体保持匀速直线运动——所以你不用写代码让它「继续动」，它不减速只是因为没人让它减速；
核心公式 $\mathbf{F} = m\mathbf{a}$：所有物理引擎的心脏。先把作用在物体上的所有力加起来（合力），除以质量得到加速度，然后交给积分器；
作用力与反作用力：碰撞反应、火箭推力的理论基础。

旋转版本的对应关系（这对应表值得背下来）：

直线运动	旋转运动
质量 $m$	转动惯量 $I$
力 $\mathbf{F}$	力矩 $\tau = \mathbf{r} \times \mathbf{F}$
加速度 $\mathbf{a} = \mathbf{F}/m$	角加速度 $\alpha = \tau / I$
速度 $\mathbf{v}$	角速度 $\omega$

转动惯量的直觉：质量分布离转轴越远越难转（花样滑冰收手加速）。2D 里 $I$ 就是一个标量（如均匀圆盘 $I = \frac{1}{2}mr^2$，细杆绕中心 $I = \frac{1}{12}mL^2$）；3D 里是一个 3×3 张量矩阵，通常直接在局部坐标系下预计算并求逆，避免每帧重复。

4.2 游戏里最常见的几种力

重力：$F = mg$，恒定向下，人人有份；
弹簧力：胡克定律 $F = -kx$（$k$ 是劲度系数），悬挂、软绳、镜头跟随弹性都靠它；
摩擦力：静摩擦（小于阈值时完全抵消切向力）与动摩擦 $F = \mu N$（$\mu$ 摩擦系数，$N$ 法向压力）；
流体阻力（空气/水）：低速近似线性 $F = -k_1 v$，高速用二次项：

$$ F_d = -\frac{1}{2} \rho v^2 C_d A , \hat{\mathbf{v}} $$

$\rho$ 是流体密度，$C_d$ 阻力系数，$A$ 是迎流面积。飞机、舰船、弹道下坠感全靠它。

避坑：二次阻力在速度很大时力也爆炸式增大，直接积分容易数值不稳定（物体来回震荡甚至飞出屏幕）。实战技巧是给阻力加速度设上限，或改用半隐式积分。

五、载具物理：本书的招牌四章

Bourg 用飞机、舰船、气垫船、汽车四个例子，展示同一套框架（合力 → 加速度 → 积分）如何套出完全不同的手感。掌握套路比记住每个参数重要。

5.1 飞机：四力平衡

flowchart LR
    T[推力 Thrust<br/>发动机] -->|向前| P((飞机))
    D[阻力 Drag<br/>空气摩擦与压差] -->|向后| P
    L[升力 Lift<br/>机翼上下压差] -->|向上| P
    W[重力 Weight<br/>mg] -->|向下| P

核心公式是升力和阻力，共享同一个「动压」结构：

$$ L = \frac{1}{2} \rho v^2 S C_L, \qquad D = \frac{1}{2} \rho v^2 S C_D $$

其中 $S$ 是机翼面积，$C_L$ 升力系数。关键知识点：

$C_L$ 随迎角（机翼与气流的夹角）增大而增大，但超过临界迎角后骤减——这就是失速，飞机升力瞬间消失往下掉。模拟飞行手感，失速是必须实现的；
滚转、俯仰、偏航三个通道各自独立输入力矩，组合出飞行姿态；
升力正比于 $v^2$：速度不够就拉不起来，这是「起飞需要跑道」的物理原因。

避坑：完整的空气动力学模型极复杂，游戏里几乎没人真做 CFD。标准做法是查表/分段线性：把 $C_L$ 和 $C_D$ 做成关于迎角的查找表，手感调好就是胜利。

5.2 舰船：浮力与流体阻力的天下

浮力：阿基米德原理，浮力等于排开水的重量。简化模拟常用「浮力采样点」——在船底布若干采样点，每个点按入水深度产生向上的力，自然涌现出船的横摇和纵摇；
稳性：浮心与重心的相对位置决定船会不会翻。重心太高、浮心太低 = 头重脚轻，一晃就翻；
阻力：水的密度约为空气的 800 多倍，所以舰船阻力以粘性阻力为主，低速近似线性即可；
转弯：舵产生侧向水动力，船不是「拐过去」而是「漂着转过去」，模拟时要给船体侧向很大的阻力、纵向较小的阻力，才有「船感」。

5.3 气垫船：低摩擦的特殊手感

气垫船悬在气垫上，与地面的摩擦几乎为零，带来两个标志性的操控特性：

推力方向和运动方向可以长期不一致——船头朝东，船还在往西漂；
转向靠舵/侧推产生力矩，但转弯时船身会侧滑，直到横向水/气阻力把侧向速度消耗掉。

实现上就是在普通刚体模型里把接触摩擦调得极小，再加分方向差异很大的阻力系数（横向阻力大、纵向阻力小）。「阻力系数各向异性」是气垫船和所有水上载具手感的灵魂。

5.4 汽车：一切手感都在轮胎上

汽车的驱动力链路：发动机扭矩 → 变速箱/挡位 → 驱动轮 → 轮胎与地面的摩擦 → 牵引力。

最重要的概念是抓地力有限：轮胎能提供的摩擦力有上限（摩擦圆/摩擦椭圆），加速、刹车、转向消耗的抓地力共享同一个预算。转向打满还猛踩油门，抓地力透支——打滑、漂移就这么来的。

简化模型三件套：

驱动力 $F = \text{engineForce}$，随速度衰减（极速的来源：驱动力 = 阻力时不再加速）；
阻力 = 滚动阻力 + 空气阻力（二次项主导高速）；
转向时按当前速度把车头方向「往速度方向拉」，拉伸强度代表抓地力——强度低就是漂移手感。

避坑：很多新手给汽车直接用「速度 = 车头方向 × 油门」，车像轨道车一样瞬间转向，毫无惯性。正确做法是转向改的是车头朝向，速度方向靠轮胎力逐渐跟上，这个「跟不上」就是车感的来源。

六、实时模拟：数值积分与时间步长

前面所有公式给出的是「这一瞬间的加速度」。游戏是一帧一帧跑的，核心问题是：怎么从加速度一步步推出位置和姿态？

6.1 游戏物理主循环

flowchart TD
    A[读取输入] --> B[计算所有作用力与力矩<br/>重力/推力/阻力/弹簧...]
    B --> C[求合力 F 与合力矩 τ<br/>a = F/m, α = τ/I]
    C --> D[数值积分<br/>更新速度 v、角速度 ω]
    D --> E[再积分<br/>更新位置 x、姿态 q]
    E --> F[碰撞检测]
    F --> G{有碰撞?}
    G -->|是| H[碰撞反应<br/>施加冲量修正速度]
    G -->|否| I[渲染]
    H --> I
    I --> A

6.2 三种积分方法对比

方法	公式（以位置为例）	精度	速度	适用
显式欧拉	$x(t+h) = x(t) + v(t),h$	差，能量发散	最快	不推荐单独用
半隐式欧拉（Symplectic Euler）	先 $v(t+h) = v(t) + a,h$，再 $x(t+h) = x(t) + v(t+h),h$	一阶但能量稳定	快	游戏物理默认选择
RK4	四次采样加权平均	四阶，很准	4 倍开销	需要精确的离线仿真

半隐式欧拉只比显式欧拉改了一个顺序（用新速度更新位置），稳定性却有质的飞跃——这是书里最划算的「一行代码的智慧」。

6.3 时间步长：实时模拟的头号工程问题

固定时间步：物理每 1/60 秒（或 1/120 秒）推进一步，渲染帧率高时插值、低时多补几步。优点：结果可复现（回放、联机同步必须用它）；
可变时间步：直接用上一帧的耗时当 $h$。优点简单；缺点致命——帧率波动直接改变物理行为，同一台机器跑两遍结果都不一样。

避坑（ spiral of death，死亡螺旋）：帧率突然下降 → 单帧物理步数暴增 → 物理计算更慢 → 帧率进一步下降。解法：给每帧物理步数设上限（如最多 5 步），宁可游戏慢动作也不让模拟爆炸。

避坑（隧道效应 tunneling）：步长太大 + 速度太快 → 子弹一帧飞过了整面墙，两帧采样点都在墙外，碰撞检测永远发现不了。解法：小步长、射线扫掠检测（swept collision / CCD），或对高速物体单独细分步长。

七、刚体旋转：从粒子到真正的「物体」

粒子只有位置；刚体多了姿态（orientation），一切都变复杂了。

3D 姿态更新的标准流程（四元数版）：

存姿态四元数 $q$ 和角速度向量 $\omega$；
每步积分：

$$ q(t+h) = q(t) + \frac{h}{2}, \tilde{\omega} , q(t) $$

其中 $\tilde{\omega} = (0, \omega_x, \omega_y, \omega_z)$ 是纯四元数形式的角速度（注意乘法顺序，别写反）； 3. 归一化 $q$（不做的后果：物体慢慢变大/缩小）； 4. 需要转动向量时，用 $q$ 把向量从局部系旋转到世界系。

力矩链路：外力作用点相对质心的偏移 $\mathbf{r}$ 产生力矩 $\tau = \mathbf{r} \times \mathbf{F}$，角加速度 $\alpha = I^{-1}\tau$（3D 中 $I^{-1}$ 要用当前姿态把局部系的逆惯量张量变换到世界系），积分得 $\omega$。这就是为什么打在边缘的一拳会让物体边飞边转。

避坑：3D 转动惯量张量一定要在局部坐标系预计算并求逆；每帧变换到世界系用 $I^{-1}_{world} = R I^{-1}_{local} R^T$。直接在世界系里积分惯量是错误的经典写法。

八、碰撞检测：先粗后精

8.1 两阶段流水线

flowchart LR
    subgraph 粗阶段 Broad Phase
        A1[遍历所有物体对] --> A2[包围球 / AABB 快速排除]
        A2 --> A3[空间划分<br/>网格 / 四叉树 / BVH]
    end
    subgraph 窄阶段 Narrow Phase
        B1[候选物体对] --> B2[精确求交<br/>SAT / 顶点-面 / 边-边]
        B2 --> B3[输出碰撞信息<br/>接触点 / 法线 / 穿透深度]
    end
    A3 --> B1

关键思想：$n$ 个物体两两检测是 $O(n^2)$，先用粗阶段把 99% 不可能相碰的对子排除掉，窄阶段只处理剩下的少数。

8.2 常用包围体

包围体	特点	典型场景
包围球	测试只需比较圆心距与半径和，最快	子弹、粒子、粗略筛选
AABB（轴对齐包围盒）	各轴区间重叠判断，简单快速	静态场景、粗阶段
OBB（有向包围盒）	贴合物体旋转，测试较贵	车辆、细长物体
凸多边形/凸包 + SAT	分离轴定理：存在一条轴使两形体的投影不重叠 ⟺ 不相交	2D 精确检测、3D 凸体

避坑：SAT 的轴候选是「两个形体所有面的法线」（3D 还要加边叉积），漏掉一组轴就会在特定角度漏检。另外 SAT 只适用于凸体，凹体要先拆成多个凸体。

8.3 碰撞检测必须输出的三样东西

窄阶段不是只回答「碰没碰」，而是要给出碰撞反应需要的输入：接触点（冲量作用在哪里）、法线（冲量沿哪个方向）、穿透深度（位置修正多少）。缺了任何一个，后面的碰撞反应都写不出来。

九、碰撞反应：冲量法

碰撞瞬间持续时间极短、力极大，直接模拟力不现实。游戏物理的标准做法是冲量法：把碰撞看成瞬间改变速度的一次「踢」。

9.1 核心推导思路

设两物体碰撞前的相对速度沿法线分量为 $v_r \cdot \mathbf{n}$，碰撞后变为 $-e$ 倍（$e$ 是恢复系数：$e=1$ 完全弹性，$e=0$ 完全非弹性）——这就是牛顿碰撞定律。把「冲量同时改变两物体的线速度和角速度」代入，解出法向冲量大小：

$$ j = \frac{-(1+e), \mathbf{v}_{rel} \cdot \mathbf{n}} {\dfrac{1}{m_1} + \dfrac{1}{m_2} + \dfrac{(\mathbf{r}_1 \times \mathbf{n})^2}{I_1} + \dfrac{(\mathbf{r}_2 \times \mathbf{n})^2}{I_2}} $$

（这是 2D 版本，$\mathbf{r}_1$、$\mathbf{r}_2$ 是接触点相对两质心的偏移；3D 版本把平方项换成矩阵形式 $\mathbf{n} \cdot [(\mathbf{r} \times \mathbf{n}) I^{-1} \times \mathbf{r}]$。）

然后：

线速度：$\mathbf{v}_1 \mathrel{-}= \frac{j}{m_1}\mathbf{n}$，$\mathbf{v}_2 \mathrel{+}= \frac{j}{m_2}\mathbf{n}$
角速度：$\omega_1 \mathrel{-}= \frac{(\mathbf{r}_1 \times j\mathbf{n})}{I_1}$，$\omega_2 \mathrel{+}= \frac{(\mathbf{r}_2 \times j\mathbf{n})}{I_2}$

打偏的一撞让物体旋转起来，就是这两个 $\mathbf{r} \times$ 项在起作用。

9.2 摩擦冲量

法向冲量解决「弹开」，摩擦冲量解决「蹭」。算出切向相对速度后施加切向冲量 $j_t$，并钳制在库仑摩擦锥内：

$$ |j_t| \le \mu , j $$

不做这个钳制，摩擦会反过来给物体加速——又一个「能量爆炸」来源。

9.3 实战避坑清单（碰撞反应篇）

穿透与抖动：数值误差让物体每帧陷进去一点又弹出来。解法：允许一个微小穿透量（slop），只对超出部分做位置修正（Baumgarte 稳定化），修正量再打个 0.2 左右的折扣；
能量爆炸：单次冲量解多接触点会互相打架，恢复系数别用满 1，摩擦记得钳制，必要时加阻尼；
迭代求解：多个接触点/约束时，对速度约束循环迭代 4-10 次（顺序冲量法），直到收敛——Box2D 就是这么做的；
静止接触：物体叠放静止时，冲量趋近于零但不等于零，抖动主要来自这里。slop + 位置修正 + 休眠（速度长期低于阈值就把物体标记为睡眠，跳过模拟）三件套缺一不可；
衝量只改速度：碰完物体还插在里面是正常的，位置交给下一帧的位置修正或积分自然分离，别试图一帧内又改速度又硬掰位置（除非做的是专门的位置投影）。

十、粒子系统：刚体的「降维打击」

粒子 = 没有旋转、没有形状（通常渲染成点或公告板）、数量极大的迷你刚体。

模拟上只做：合力（重力、风、阻力）→ 半隐式欧拉积分 → 简单碰撞（对地面反弹或直接死亡）；
表现上靠生成器（发射速率、初速度锥角、寿命随机分布）和衰减（颜色、大小、透明度随寿命变化）；
典型用途：火花、烟雾、爆炸、尾迹、简单的流体/喷泉近似。

避坑：粒子系统的瓶颈几乎从不在物理，而在渲染和内存。对象池复用粒子、避免每帧 new/delete，CPU 模拟 + GPU 渲染分工明确，是入门就该养成的习惯。

十一、2D 刚体模拟器：把全书串起来的最小实战

书中后半部分的 2D 刚体模拟示例，是最适合新手的毕业项目。最小可用版本只需要这些模块：

flowchart TD
    subgraph 数据结构
        D1[RigidBody2D<br/>位置/角度/线速度/角速度<br/>质量/转动惯量]
        D2[Contact<br/>接触点/法线/穿透深度]
    end
    subgraph 每帧流程
        S1[施加重力等外力] --> S2[半隐式欧拉积分]
        S2 --> S3[粗阶段: AABB 排除]
        S3 --> S4[窄阶段: SAT 求接触]
        S4 --> S5[冲量求解 迭代若干次]
        S5 --> S6[位置修正 slop + Baumgarte]
        S6 --> S7[休眠检测]
    end
    D1 --> S1
    S4 --> D2
    D2 --> S5

动手顺序建议：

先做单刚体自由落体 + 地面反弹（恢复系数可调），验证积分正确；
加旋转：给一个方块偏心施加力，看是否边飞边转；
加碰撞：圆 vs 圆（最简单）→ 凸多边形 SAT；
加摩擦冲量和迭代求解；
加位置修正和休眠，一堆方块能稳稳叠起来——恭喜，你写出了一个迷你 Box2D。

十二、典型问题 FAQ

Q1：物体速度越来越快最后飞出世界（数值发散）？ 检查三件事：是否用了显式欧拉（换半隐式）；步长是否过大（弹簧系统等刚度大的力要求更小的步）；阻力/弹簧是否缺上限或阻尼。

Q2：子弹穿墙？ 隧道效应。高速物体用扫掠检测（上一帧位置到这一帧位置打一条射线/扫掠体），或对其使用更小的子步长（CCD）。

Q3：箱子叠在一起不停抖动、慢慢沉进地里？ 缺 slop 容差和位置修正折扣；恢复系数设成了接近 1（静止接触应该用 0 或极小）；缺少休眠机制。

Q4：联机/回放时物理结果不一致？ 使用了可变时间步或浮点运算顺序不一致。固定时间步 + 固定迭代次数 + 固定遍历顺序是确定性模拟的前提；跨平台完全一致还要锁定浮点模式或用定点数（如《王者荣耀》等帧同步游戏的做法）。

Q5：斜坡上的箱子自己往下滑 / 不会滑？ 检查摩擦实现：切向冲量有没有做库仑钳制 $\mu j$；法线是否归一化；静摩擦与动摩擦有没有分开处理。

Q6：四元数积分后物体悄悄变形/缩放？ 忘记每步归一化四元数。这是四元数模拟里出现率最高的 bug。

Q7：2D 里物体往天上「掉」？ 屏幕 y 轴向下而公式按 y 轴向上写的，重力符号反了。

十三、避坑总清单（速查表）

坑	症状	解法
单位混用（米/像素）	一切数值都「差不多但不对」	开工前定死单位制，重力常数跟着改
y 轴朝向	运动方向全部镜像	定好坐标约定，重力符号随之确定
显式欧拉	能量越来越多，逐渐爆炸	半隐式欧拉起步
可变时间步	帧率一掉物理就变，不可复现	固定时间步 + 步数上限
隧道效应	高速物体穿墙	扫掠检测 / CCD / 子步长
法线没归一化	碰撞反应大小诡异	所有法线使用前 normalize
四元数不归一化	物体缓慢缩放变形	每步积分后归一化
摩擦不钳制	摩擦反而加速物体	库仑摩擦锥约束
穿透硬修正	抖动、弹跳不止	slop + Baumgarte 折扣修正
无休眠	性能浪费 + 静止抖动	速度阈值休眠
死亡螺旋	卡顿后彻底卡死	每帧物理步数设上限

十四、主流游戏框架与物理引擎

上面的原理，主流引擎都已内置实现；学原理的意义在于调得动、查得准、必要时能绕过。

引擎/框架	物理方案	备注
Unity	PhysX（3D）、Box2D（2D）	Rigidbody / Rigidbody2D，FixedUpdate 即固定时间步
Unreal Engine	Chaos（新版）、PhysX（旧版）	Chaos 支持破坏、布料等大型模拟
Godot	自研 Godot Physics，可换 Jolt	开源，2D/3D 分离
Box2D	2D 物理库（C++）	本书思想的工业化实现，愤怒的小鸟、无数 2D 游戏在用
Bullet	3D 物理库	开源老牌，影视与游戏双用
Jolt	3D 物理库	《地平线》系列使用，近年性能口碑极好
PhysX	3D 物理库（NVIDIA）	Unity/UE 底层，支持 GPU 加速
Cocos Creator	内置 2D（Box2D/builtin）、3D 可选 PhysX/cannon.js	国内小游戏主流
LayaAir	集成 Bullet（编译为 wasm）	国内 3D H5 主流
Rapier	Rust 编写，可编译 wasm	Web/独立游戏新势力，确定性模拟支持好
MuJoCo / PyBullet	科研仿真	机器人、强化学习训练场景

选型直觉：2D 游戏默认 Box2D 系；3D 商用项目跟着引擎走（Unity 用 PhysX、UE 用 Chaos）；网页端想要确定性（帧同步）看 Rapier；做机器人/RL 仿真看 MuJoCo。

十五、学习路径建议

第一周：把向量运算（点积、叉积、归一化）练到不用查，手写一个 2D 抛体模拟（重力 + 半隐式欧拉 + 地面反弹）；
第二周：给抛体加空气阻力和风，做「炮弹打移动目标」的提前量解算；
第三周：实现 2D 刚体（加旋转和转动惯量），偏心受力看旋转；
第四周：SAT 碰撞检测 + 冲量法碰撞反应 + 摩擦，让方块能撞、能停、能叠；
之后：挑一个载具（汽车最容易出成就感）做手感调优；有 3D 需求再啃四元数和惯量张量；
贯穿始终：每实现一个特性，先想「这一步在哪个引擎里对应什么参数」，原理和工具互相印证。

结语

《游戏开发物理学》最大的价值不是那些公式，而是一个思维框架：任何炫酷的物理效果，拆到最后都是「合力 → 积分 → 碰撞 → 冲量」这条流水线的变体。飞机和汽车的差别只在于往「合力」里塞了什么力；刚体和粒子的差别只在于有没有旋转那一半。

先把这条流水线在小项目里跑通，再去用引擎——你会发现所有参数突然都认识了。