1
// 伪代码——CPU 提交 DrawCall 做了什么
2
void SubmitDrawCall(Mesh* mesh, Material* material, Matrix4x4 worldMatrix) {
3
    // 1. 设置渲染状态（Shader、混合模式、深度测试模式……）
4
    Graphics::SetShader(material->shader);
5
    Graphics::SetBlendMode(material->blendMode);
6
    Graphics::SetDepthTest(material->depthTest);
7

8
    // 2. 传数据（顶点缓冲、索引缓冲、常量缓冲）
9
    Graphics::SetVertexBuffer(mesh->vertices);
10
    Graphics::SetIndexBuffer(mesh->indices);
11
    Graphics::SetConstantBuffer("WorldMatrix", worldMatrix);
12
    Graphics::SetConstantBuffer("MainTexture", material->texture);
13

14
    // 3. 真正提交——GPU 开始工作
15
    Graphics::DrawIndexed(mesh->indexCount);
16

17
    // 这个函数调用本身很快，但状态切换和数据传输有隐形成本
18
    // ——这就是为什么 DrawCall 多会慢
19
}

1
// 最精简的顶点着色器——只做 MVP 变换
2
struct VertexInput {
3
    float3 position : POSITION;   // 模型空间坐标
4
    float3 normal   : NORMAL;
5
    float2 uv       : TEXCOORD0;
6
};
7

8
struct VertexOutput {
9
    float4 position : SV_POSITION;  // 裁剪空间坐标（必须输出）
10
    float3 worldPos : TEXCOORD0;   // 传给片元着色器
11
    float3 normal   : TEXCOORD1;
12
    float2 uv       : TEXCOORD2;
13
};
14

15
VertexOutput MainVS(VertexInput input) {
16
    VertexOutput output;
17

18
    // 模型空间 → 世界空间
19
    float4 worldPos = mul(UNITY_MATRIX_M, float4(input.position, 1.0));
20
    // 世界空间 → 观察空间
21
    float4 viewPos = mul(UNITY_MATRIX_V, worldPos);
22
    // 观察空间 → 裁剪空间
23
    float4 clipPos = mul(UNITY_MATRIX_P, viewPos);
24

25
    output.position = clipPos;           // GPU 后续会自动做透视除法 + 视口变换
26
    output.worldPos = worldPos.xyz;      // 片元着色器需要世界坐标做光照
27
    output.normal = mul((float3x3)UNITY_MATRIX_M, input.normal);
28
    output.uv = input.uv;
29

30
    return output;
31
}
32

33
// 或者直接用 Unity 的合并矩阵：
34
// output.position = UnityObjectToClipPos(input.position);
35
// 内部 = mul(UNITY_MATRIX_VP, mul(UNITY_MATRIX_M, float4(input.position, 1.0)))

1
// 最精简的片元着色器——纹理采样
2
float4 MainFS(VertexOutput input) : SV_TARGET {
3
    // 1. 采样纹理
4
    float4 texColor = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, input.uv);
5

6
    // 2. 简单的漫反射光照
7
    float3 normal = normalize(input.normal);
8
    float3 lightDir = normalize(_WorldSpaceLightPos0.xyz);
9
    float NdotL = max(0, dot(normal, lightDir));
10
    float3 diffuse = texColor.rgb * _LightColor0.rgb * NdotL;
11

12
    // 3. 环境光
13
    float3 ambient = texColor.rgb * 0.1;
14

15
    return float4(diffuse + ambient, texColor.a);
16
}

1
片元到像素的最后一道关卡——按顺序执行：
2

3
1. 像素所有权测试 (Pixel Ownership Test)
4
   "这个像素是不是被另一个窗口挡住了？" → 系统级，和渲染无关
5

6
2. 裁剪测试 (Scissor Test)
7
   "这个像素在裁剪矩形内吗？" → UI 的 ScrollRect 遮罩底层实现
8

9
3. 模板测试 (Stencil Test)
10
   "模板缓冲区的这个位置是 0 还是 1？" → UI Mask 组件、镜面反射区域标记
11

12
4. 深度测试 (Depth Test)
13
   "这个片元的深度比之前画的更近吗？" → 决定前后遮挡关系
14

15
   配置：ZWrite On/Off, ZTest Less/Greater/Always/Equal
16
   不透明物体：ZWrite On, ZTest Less（近的覆盖远的）
17
   天空盒：ZWrite Off, ZTest Always（画在最远，不写深度）
18

19
5. Alpha 测试
20
   "这个片元的透明度足够高吗？" → 低于阈值直接丢弃（clip 操作）
21

22
6. 混合 (Blending)
23
   "新颜色和屏幕上已有的颜色怎么叠加？"
24

25
   常见混合模式：
26
   - Alpha Blend:  result = src * srcAlpha + dst * (1 - srcAlpha)  ← 半透明
27
   - Additive:    result = src + dst                                ← 粒子/光效
28
   - Multiply:    result = src * dst                                ← 暗角效果

1
// Model Matrix = Translate × Rotate × Scale（TRS 顺序）
2
// 作用：把模型空间坐标 → 世界空间坐标
3

4
// 模型空间：假设模型以自己的中心为原点
5
// 世界空间：统一的世界坐标系
6

7
// 例：模型空间中，角色的鼻子在 (0, 0.8, 1.0)
8
//     角色在世界中的位置是 (10, 0, 5)，朝向正东，缩放 1.5 倍
9
//     → 鼻子的世界坐标 = Model × (0, 0.8, 1.0, 1)
10
//     ≈ (11.5, 1.2, 5, 1)
11

12
Matrix4x4 ModelMatrix(Vector3 pos, Quaternion rot, Vector3 scale) {
13
    Matrix4x4 S = Matrix4x4::Scale(scale);    // 先缩放
14
    Matrix4x4 R = Matrix4x4::Rotate(rot);    // 再旋转
15
    Matrix4x4 T = Matrix4x4::Translate(pos); // 最后平移
16

17
    return T * R * S;  // 矩阵乘法从右到左：先S后R后T
18
    // 为什么这个顺序？因为缩放和旋转是绕模型中心做的，
19
    // 如果先平移再旋转——模型会绕着世界原点公转，不是自转
20
}

1
// View Matrix 用摄像机的位置和朝向构建
2
// 本质：把整个世界"搬到"摄像机为原点的坐标系
3

4
// 摄像机在世界中的位置 = eye (10, 5, -10)
5
// 摄像机看向的点       = target (0, 0, 0)
6
// 摄像机的上方向       = up (0, 1, 0)
7

8
Matrix4x4 ViewMatrix(Vector3 eye, Vector3 target, Vector3 up) {
9
    // 摄像机的前方向（看向 target）
10
    Vector3 forward = (target - eye).Normalized();
11

12
    // 摄像机的右方向
13
    Vector3 right = Cross(forward, up).Normalized();
14

15
    // 摄像机的上方向（重新计算——保证正交）
16
    Vector3 upRecalc = Cross(right, forward);
17

18
    // 观察矩阵 = 旋转（世界轴 → 摄像机轴）× 平移（世界原点 → 摄像机位置）
19
    Matrix4x4 rot = Matrix4x4(
20
        right.x,    upRecalc.x,    -forward.x,    0,
21
        right.y,    upRecalc.y,    -forward.y,    0,
22
        right.z,    upRecalc.z,    -forward.z,    0,
23
        0,          0,             0,             1
24
    );
25

26
    Matrix4x4 trans = Matrix4x4(
27
        1, 0, 0, -eye.x,
28
        0, 1, 0, -eye.y,
29
        0, 0, 1, -eye.z,
30
        0, 0, 0, 1
31
    );
32

33
    return rot * trans;  // 先平移再旋转（先移到原点，再转方向）
34

35
    // Unity: UNITY_MATRIX_V = ViewMatrix(cameraPos, cameraTarget, cameraUp)
36
}

1
// 透视投影：模拟人眼——近大远小
2
// 正交投影：没有透视——UI/小地图/工程软件
3

4
// ============ 透视投影 ============
5
Matrix4x4 PerspectiveProj(float fovY, float aspect, float near, float far) {
6
    // fovY: 垂直方向视野角度（弧度）
7
    // aspect: 宽 / 高
8
    // near/far: 近远裁剪面
9

10
    float tanHalfFov = tan(fovY / 2.0f);
11

12
    Matrix4x4 m;
13
    m[0, 0] = 1.0f / (aspect * tanHalfFov);  // x 缩放
14
    m[1, 1] = 1.0f / tanHalfFov;             // y 缩放
15
    m[2, 2] = -(far + near) / (far - near);  // z 缩放 + 取反（右手系→左手系）
16
    m[2, 3] = -1.0f;                          // 透视除法：w = -z（观察空间的 z）
17
    m[3, 2] = -(2.0f * far * near) / (far - near);  // z 偏移
18
    m[3, 3] = 0.0f;
19

20
    return m;
21
}
22

23
// 关键理解：
24
// m[2, 3] = -1  → 输出的 w 分量 = -viewZ（观察空间的深度）
25
// 透视除法时：clipPos.xyz / clipPos.w = clipPos.xyz / (-viewZ)
26
// 所以远处的物体（viewZ 的绝对值大）→ 除以一个大数 → 屏幕坐标变小 → 近大远小
27

28
// ============ 正交投影 ============
29
Matrix4x4 OrthoProj(float left, float right, float bottom, float top,
30
                     float near, float far) {
31
    Matrix4x4 m;
32
    m[0, 0] = 2.0f / (right - left);           // x 映射到 [-1, 1]
33
    m[1, 1] = 2.0f / (top - bottom);           // y 映射到 [-1, 1]
34
    m[2, 2] = -2.0f / (far - near);            // z 映射到 [-1, 1]
35
    m[0, 3] = -(right + left) / (right - left);
36
    m[1, 3] = -(top + bottom) / (top - bottom);
37
    m[2, 3] = -(far + near) / (far - near);
38
    m[3, 3] = 1.0f;
39

40
    return m;
41
}
42
// 正交投影的 w 分量恒为 1——透视除法不起作用——没有近大远小

1
MVP 变换的完整链条：
2

3
Model Space (局部坐标，如模型文件中定义的顶点)
4
    ↓ × Model Matrix
5
World Space (世界统一坐标)
6
    ↓ × View Matrix
7
View Space (摄像机为原点，Z轴指向观察方向)
8
    ↓ × Projection Matrix
9
Clip Space (裁剪空间，x,y,z ∈ [-w, w])
10
    ↓ 透视除法 (÷ w)  ← 硬件自动完成
11
NDC (Normalized Device Coordinates, x,y,z ∈ [-1, 1])
12
    ↓ 视口变换 (× 屏幕宽高 + 偏移)
13
Screen Space (屏幕像素坐标)
14

15
面试关键：
16
  1. 透视除法是不可编程的——硬件自动完成
17
  2. Shader 的输出是 Clip Space 坐标（SV_POSITION 语义）
18
  3. NDC 中，z ∈ [0, 1]（D3D/Vulkan/Metal）或 [-1, 1]（OpenGL）
19
  4. 视口变换也是固定管线——你设置 viewport，GPU 自动映射

1
// 把 3D 世界位置映射到 2D UI 位置——最常见的使用场景
2
public class WorldToScreenUI : MonoBehaviour {
3
    [SerializeField] private RectTransform healthBarUI;
4
    [SerializeField] private Transform worldTarget;  // 角色的头顶位置
5

6
    void LateUpdate() {
7
        // Unity 已经帮你做了 MVP + 视口变换——直接拿到屏幕坐标
8
        Vector3 screenPos = Camera.main.WorldToScreenPoint(worldTarget.position);
9

10
        // screenPos.z > 0 表示在摄像机前方（屏幕坐标有效）
11
        if (screenPos.z > 0) {
12
            healthBarUI.position = screenPos;
13
            healthBarUI.gameObject.SetActive(true);
14
        } else {
15
            healthBarUI.gameObject.SetActive(false);  // 在摄像机后方——隐藏
16
        }
17
    }
18
}
19

20
// Unity 内部实现（简化）：
21
// Vector3 WorldToScreenPoint(Vector3 worldPos) {
22
//     Matrix4x4 vp = projectionMatrix * worldToCameraMatrix;
23
//     Vector4 clipPos = vp * new Vector4(worldPos.x, worldPos.y, worldPos.z, 1);
24
//
25
//     // 透视除法
26
//     float invW = 1.0f / clipPos.w;
27
//     Vector3 ndc = new Vector3(clipPos.x * invW, clipPos.y * invW, clipPos.z * invW);
28
//
29
//     // 视口变换
30
//     return new Vector3(
31
//         (ndc.x + 1) * 0.5f * Screen.width,
32
//         (ndc.y + 1) * 0.5f * Screen.height,
33
//         ndc.z  // 0~1，近平面到远平面
34
//     );
35
// }

1
// 点击屏幕 → 推出一条从摄像机射出的世界空间射线
2
// 面试常问："怎么实现鼠标点击选中 3D 物体？"
3

4
Ray ScreenPointToRay(Vector2 screenPoint) {
5
    // 1. 屏幕坐标 → NDC
6
    Vector3 ndc = new Vector3(
7
        screenPoint.x / Screen.width * 2.0f - 1.0f,
8
        screenPoint.y / Screen.height * 2.0f - 1.0f,
9
        0.0f  // 近平面
10
    );
11

12
    // 2. NDC → 裁剪空间（逆视口变换 + 逆投影变换）
13
    //    近平面上的点：clipNear = inverse(ProjectionMatrix) * (ndc, -1, 1)
14
    //    远平面上的点：clipFar  = inverse(ProjectionMatrix) * (ndc,  1, 1)
15

16
    // 3. 裁剪空间 → 世界空间（逆观察变换）
17
    //    worldNear = inverse(ViewMatrix) * (clipNear / clipNear.w)
18
    //    worldFar  = inverse(ViewMatrix) * (clipFar  / clipFar.w)
19

20
    // 4. 射线 = worldNear → worldFar
21
    // return Ray(worldNear, (worldFar - worldNear).Normalized);
22

23
    // Unity 已封装：Camera.main.ScreenPointToRay(screenPoint)
24
}

1
面试口述模板：
2

3
"渲染管线分为三大阶段。
4

5
第一是应用阶段，跑在 CPU 上，负责剔除、合批、排序，最后提交 DrawCall。
6

7
第二是几何阶段，跑在 GPU 上——
8
顶点着色器做 MVP 变换，每个顶点运行一次；
9
可选地经过曲面细分和几何着色器；
10
最后硬件裁剪掉视野外的三角形，映射到屏幕坐标。
11

12
第三是光栅化阶段——
13
三角形被转化为片元，片元着色器对每个片元计算颜色；
14
然后经过深度测试、模板测试、Alpha 测试和混合；
15
最终写入帧缓冲，显示在屏幕上。
16

17
关键点：只有顶点着色器和片元着色器是可编程的（现代管线也包括可选的曲面细分和几何着色器），
18
其余阶段是固定管线。片元着色器通常是性能瓶颈，因为每个像素都要跑。"