想象你买下一栋毛坯房。施工队进场后，结构工程师先测量每一面墙的转角位置，确定哪里承重、哪里开窗——这在 GPU 里叫顶点着色器；泥瓦匠接着把图纸上一条条轮廓线砌成平整的墙面——这是光栅化；最后油漆工举起滚筒，一寸一寸刷上颜色——这就是片元着色器。这套“测量—砌墙—刷漆”的流水线，正是 Unity 渲染管线的缩影。Shaders（着色器）就是发给这支施工队的施工指令：告诉 GPU 每个顶点放在哪里、每个像素刷成什么颜色。而 Shader Graph 是可视化设计图，HLSL 是背后的施工手册。本文带你从看懂毛坯房开始，一步步掌握装修一栋“数字别墅”的全部手艺。

岗位关联

学会 Shader Graph 与 HLSL，你就能驾驭游戏画面最底层的“施工队”。无论做风格化渲染、移动端性能优化，还是用 AI 辅助生成材质，这门技术都是视觉工程师的核心竞争力。

目录
  1. 可视化演示
  2. 渲染管线基础——装修流水线
  3. 节点图入门——可视化设计图
  4. HLSL语法核心——施工手册
  5. 光照与材质——涂料配方
  6. 高级特效——特殊工艺
  7. 性能优化——预算控制
  8. 调试与工具——监理验收
  9. AI辅助开发——AI装修顾问
  10. AI 应用场景
  11. Python 演示
  12. 常见误区
  13. 面试题

可视化演示

展示系统处理流水线、实时性能指标曲线及多方案对比分析，包含数据流转、吞吐延迟监控与方案评估。

本节配有交互动效（进入视口后自动加载，约 3KB）。

系统可视化 处理流程：输入→处理→模型→输出 性能监控：实时指标 P=L×T

渲染管线基础——装修流水线

想象你买下一栋毛坯房。施工队进场后，结构工程师先测量每一面墙的转角位置和高度，确定哪里开窗、哪里承重——这就是顶点着色器做的事。接着泥瓦匠进场，把图纸上的一条条线段砌成平整的墙面——这是光栅化。最后油漆工举起滚筒，一寸一寸地刷上颜色——这就是片元着色器。这套“测量、砌墙、刷漆”的流水线，正是 GPU 渲染管线（Render Pipeline）的缩影。

在 Unity 中，渲染管线是一系列固定顺序的硬件阶段，而 Shader（着色器）是唯一可以由开发者编程的部分。顶点着色器（Vertex Shader）逐个处理网格的顶点，把三维坐标变换到投影空间；光栅化器把三角形离散成一个个候选像素，称为片元（Fragment）；片元着色器（Fragment Shader）为每个片元计算颜色。理解这条流水线，是所有 Shader 工作的地基。

一个三维顶点要从模型空间出现在屏幕上，需要连续经过三次矩阵变换：

无论一面墙是普通白墙还是镶金边的电视墙，它出现在屏幕上的第一步永远是这套坐标转运。理解了流水线，后面每一节内容，都是在其中某个工位上加一道工序。

pclip=Mprojection×Mview×Mmodel×plocal\mathbf{p}_{clip} = M_{projection} \times M_{view} \times M_{model} \times \mathbf{p}_{local}
这个公式是“工地坐标转运单”：把模型本地的钉子坐标，一步步搬到屏幕坐标。
  1. 本地坐标 p_local模型文件里记录的原始顶点坐标，相当于设计师图纸上标注的尺寸。
    plocal=(x,y,z,1)\mathbf{p}_{local} = (x, y, z, 1)
  2. 模型矩阵 M_model把模型从本地空间搬到世界空间，相当于把家具从图纸位置搬到房间的实际位置。
    Mmodel∈R4×4M_{model} \in \mathbb{R}^{4 \times 4}
  3. 视图矩阵 M_view以摄像机为原点重新描述世界坐标，相当于从你的眼睛位置观察整个工地。
    Mview∈R4×4M_{view} \in \mathbb{R}^{4 \times 4}
  4. 投影矩阵 M_projection将三维视锥压成二维裁剪坐标，相当于把立体工地拍成一张照片。
    pclip∈R4\mathbf{p}_{clip} \in \mathbb{R}^{4}

节点图入门——可视化设计图

传统的施工交底是一摞厚厚的文字说明，而 Shader Graph 把说明变成了一张可视化设计图。每一个节点是一个功能模块，例如“纹理采样”“亮度调节”“颜色混合”；连线就是施工顺序，数据沿着连线从左往右流动，最终汇入主节点。

主节点栈（Master Stack）只有两个出口：Vertex 输出告诉 GPU 顶点怎么摆，Fragment 输出告诉 GPU 片元怎么上色。属性（Property）面板暴露给外部调整的参数——相当于在效果图上留几个旋钮，美术师不用改图纸，转动旋钮就能换墙纸颜色。

一个最简单的“陶瓷墙砖”材质：UV 节点提供坐标，连到 Texture2D 采样节点拿到底色，再乘一个颜色属性做整体调色，最后送入 Fragment 主节点。这个乘法关系写作：

可视化设计图让新手十分钟就能拖出一面会发光的墙。但当效果变复杂，节点图会变成一张蜘蛛网——下一节我们翻翻施工手册，看看设计图背后的 HLSL 到底写了什么。

Cout=Ctexture×Ctint+CemissionC_{out} = C_{texture} \times C_{tint} + C_{emission}
墙纸的花纹乘上灯光色温，再加上夜光涂料的自发光，就是最终上墙的颜色。
  1. C_texture纹理采样结果，即墙纸花纹每个位置的基础颜色。
    Ctexture=Texture2D.Sample(uv)C_{texture} = \text{Texture2D.Sample}(uv)
  2. C_tint整体色调叠加，相当于在墙纸上罩了一层彩色透明膜。
    Ctint∈[0,1]3C_{tint} \in [0,1]^3
  3. 逐通道乘法RGB 三个分量分别相乘，让花纹按色调统一染色，且不破坏相对明暗。
    (rt⋅ri,  gt⋅gi,  bt⋅bi)(r_t \cdot r_i, \; g_t \cdot g_i, \; b_t \cdot b_i)
  4. C_emission自发光项，跳过光照直接叠加，像夜光涂料一样自带亮度。
    Cemission∈[0,+∞)3C_{emission} \in [0, +\infty)^3

HLSL语法核心——施工手册

设计图再漂亮，施工队真正执行的是按部就班的文字指令。GPU 不认节点图，它只认 HLSL。HLSL（High Level Shading Language）是 DirectX 生态的着色器语言，也是 Unity Shader 的最终“施工手册”。

Shader Graph 的每一个节点，最终都会被编译成 HLSL 函数。学会读 HLSL，你的排查手段会从“逐节点点预览”升级为“直接看源码找问题”。一段片元着色器无非四件事：接收输入、声明输出语义、计算、返回。

HLSL 有三级数值精度：float 高精度、half 半精度、fixed 低精度，用错是移动端发热的常见原因。输出语义是关键——SV_Position 声明这是裁剪空间位置，SV_Target 声明这是写入渲染目标的颜色，TEXCOORD 则负责在顶点与片元之间传递纹理坐标。无论多花哨的节点，最终都化为这样一行行“口令”。法线参与光照前必须归一化，这本施工手册的命令写作：

掌握了这本施工手册，再看设计图会有一种“透视感”：你知道节点连线的背后，是某一串 float 乘法在流动。从这一节开始，你不再是只会拖节点的“图纸搬运工”，而是能改图纸的“施工员”。

n′=n∥n∥\mathbf{n}' = \frac{\mathbf{n}}{\|\mathbf{n}\|}
把一根任意长度的箭头，缩成只保留方向的单位箭头。
  1. 法线向量 n描述表面朝向的箭头，比如墙面指向房间内的一根垂直棍子。
    n=(nx,ny,nz)\mathbf{n} = (n_x, n_y, n_z)
  2. 长度 ∥n∥箭头从起点到终点的距离，即这根棍子的长度。
    ∥n∥=nx2+ny2+nz2\|\mathbf{n}\| = \sqrt{n_x^2 + n_y^2 + n_z^2}
  3. 除法归一化向量的每个分量除以长度，使总长变成 1，方向不变——这就是 HLSL 里 normalize() 的秘密。
    n′=(nx∥n∥,ny∥n∥,nz∥n∥)\mathbf{n}' = \left(\frac{n_x}{\|\mathbf{n}\|}, \frac{n_y}{\|\mathbf{n}\|}, \frac{n_z}{\|\mathbf{n}\|}\right)

光照与材质——涂料配方

同样是白墙，哑光漆和亮面漆观感完全不同。光照模型就是涂料配方：底漆负责环境亮度，面漆负责主光方向亮度，亮片决定高光集中程度。

从图形学诞生起，工程师们总结出 Blinn-Phong 经验模型：漫反射由法线与光线方向的点积决定，高光由法线与半角向量的点积的高次幂模拟。这套配方至今仍是指标基准。PBR 则是更物理的配方——用金属度、粗糙度两个旋钮替代一堆经验参数，本质上仍是“底漆、面漆、亮片”三件套。

Blinn-Phong 的数学内核：

配方决定质感。把漫反射、高光、环境光三个分量配比调对，材质立刻从“塑料感”升级到“瓷器感”。在 PBR 时代这套直觉没有过时——PBR 只是把配方从“凭手感”换成了“称重下料”。

I=Ia+Id⋅max⁡(0,n⋅l)+Is⋅(n⋅h)pI = I_a + I_d \cdot \max(0, \mathbf{n} \cdot \mathbf{l}) + I_s \cdot (\mathbf{n} \cdot \mathbf{h})^{p}
房间基础亮度 + 主灯照亮程度 + 高光强度，三样涂料按比例调配。
  1. 环境光 I_a不来自任何特定方向的基础亮度，对应房间里的环境照明。
    Ia=ka⋅LambientI_a = k_a \cdot L_{ambient}
  2. 法线点积 n·l光线方向与表面朝向夹角越小，面越亮；夹角超过 90° 时 max(0,·) 保证背面不被照亮。
    n⋅l=∥n∥∥l∥cos⁡θ=cos⁡θ\mathbf{n} \cdot \mathbf{l} = \|\mathbf{n}\| \|\mathbf{l}\| \cos \theta = \cos \theta
  3. 半角向量 h光线方向和视线方向的“中间角度”，用来模拟镜面反射的角度集中性。
    h=l+v∥l+v∥\mathbf{h} = \frac{\mathbf{l} + \mathbf{v}}{\|\mathbf{l} + \mathbf{v}\|}
  4. 高光指数 pp 越大，高光越集中锐利，对应漆面越亮、亮片越小。
    (n⋅h)p=(cos⁡ϕ)p(\mathbf{n} \cdot \mathbf{h})^{p} = (\cos \phi)^{p}

高级特效——特殊工艺

精装修总有一些炫技工艺：隐形门关上一看就是一面墙，其实是门；变色涂料不同角度看颜色不同；动态装饰画画面会慢慢流动。Shader 的高级特效正是这些工艺。

法线贴图是“隐形门”——一张蓝紫色贴图并不改变几何，而是篡改逐像素的光照方向，让平面看起来有凹凸纹路。UV 动画是“动态装饰画”——让纹理坐标随时间滚动，形成流动的水面或警示带。顶点位移是“变形墙”——在顶点着色器阶段改写网格形状，实现波浪、飘动。

UV 滚动的核心是在采样前修改 UV 坐标：

法线贴图的“篡改”公式：

特效虽炫，成本不低。法线贴图多一次纹理采样，UV 动画多几条指令，顶点位移要重算切线。记住下一节的投资原则：预算有限，特效也要精打细算。

uv′=uv+s⋅t\mathbf{uv}' = \mathbf{uv} + \mathbf{s} \cdot t
把朝上的平面法线，按贴图记录的凹凸方向轻轻掰弯一点点。
  1. 原始法线 n平面原本的朝向，例如朝上的地板。
    n=(0,1,0)\mathbf{n} = (0,1,0)
  2. 扰动向量 Δn从法线贴图采样得到的扰动，模拟砖缝的起伏方向。
    Δn=2⋅tex2D(uv)−1\mathbf{\Delta n} = 2 \cdot \text{tex2D}(uv) - 1
  3. 归一化把扰动后的向量重新拉回单位长度，保证光照计算正确。
    n′=n+Δn∥n+Δn∥\mathbf{n}' = \frac{\mathbf{n}+\mathbf{\Delta n}}{\|\mathbf{n}+\mathbf{\Delta n}\|}

性能优化——预算控制

装修可以不设预算，但游戏引擎的铁律是：一帧必须在 16.7 毫秒内画完（60 fps）。超时就卡顿、发热、掉电。Shader 性能优化就是一份“精打细算的装修预算表”，三个大项必须盯紧。

第一项是 Draw Call——CPU 向 GPU 发一次渲染命令，就像为一面墙单独叫一支施工队。第二项是指令数——同一片像素上执行的运算量，工序越复杂越贵。第三项是像素数——屏幕分辨率与 Overdraw（同一像素被反复画），刷墙面积越大越贵。

总耗时可以大致记为三者乘积：

三者相乘意味着任何一项翻倍，总耗时都会直线上升。所以优化三板斧立竿见影：合批降低 C_dc、用 half 精度减少 I_ins、控制粒子与全屏特效减少 P_pix。移动端尤其要紧盯第三项——屏幕像素虽然少，但 Mali/Adreno GPU 的算力也弱。

T=Cdc×Iins×PpixT = C_{dc} \times I_{ins} \times P_{pix}
工期 = 施工队进场次数 × 每队工序复杂度 × 要刷的墙面积。
  1. C_dc（Draw Call 次数）渲染命令的数量。合并同材质网格，就是让一支施工队多干几面墙。
    Cdc=∑materialsbatchesC_{dc} = \sum_{\text{materials}} \text{batches}
  2. I_ins（每条指令耗时）片元着色器内的运算量和纹理采样次数。
    Iins≈ALU ops+tex samplesI_{ins} \approx \text{ALU ops} + \text{tex samples}
  3. P_pix（像素处理量）分辨率越高、Overdraw 越严重，像素总量越大。
    Ppix=Rwidth×Rheight×overdrawP_{pix} = R_{width} \times R_{height} \times \text{overdraw}

调试与工具——监理验收

施工再快，也要监理验收。如果你看不到每一道工序，出了问题只能砸墙重来。Unity 的调试工具就是一套“监理总控台”，让 GPU 的每道工序都透明可查。

Frame Debugger 是渲染帧的“施工记录仪”——可以逐事件回放一帧，看 GPU 画了哪些网格、用了哪个材质、绑定了哪张纹理。Shader Graph 的每个节点都有实时预览，相当于“每一层墙纸先涂在小样上看看效果”。Profiler 显示 GPU 时间花在哪个 Pass，让优化有的放矢。

排查移动端发热时，一个常被忽视的指标是带宽。它由分辨率、位深和帧率共同决定：

把 Frame Debugger 当监理、节点预览当小样、Profiler 当财务报表，你就能在“验收”时一眼看穿问题出在几何、材质还是像素填充。下一节，AI 顾问会帮你更快地找到这些问题。

B=Rw×Rh×Dbits×FfpsB = R_w \times R_h \times D_{bits} \times F_{fps}
每秒要从显存搬运的数据量，就是墙面每一帧重新上色需要的总油漆搬运量。
  1. R_w × R_h屏幕分辨率，代表要刷的墙面总面积。
    Rw×Rh=1920×1080≈2.07×106R_w \times R_h = 1920 \times 1080 \approx 2.07 \times 10^{6}
  2. D_bits 位深每个像素用多少 bit 表示颜色，常见的 RGBA32 是 32 bit。
    Dbits=32D_{bits} = 32
  3. F_fps 帧率每秒刷新次数，60 帧意味着同一面墙每秒刷 60 遍。
    Ffps=60F_{fps} = 60
  4. 总带宽 B单位换算后是每秒 GB 级别的搬运量，内存带宽一超就掉帧。
    B=2.07×106×32×60≈3.97 Gb/sB = 2.07 \times 10^{6} \times 32 \times 60 \approx 3.97 \, \text{Gb/s}

AI辅助开发——AI装修顾问

现在你还能请一位随叫随到的资深 AI 装修顾问。你只需说“我要一面赛博朋克风格的霓虹渐变墙”，AI 几分钟就能给出节点图草稿和 HLSL 代码。这不是炫技，而是已经在发生的日常工作：AI 把 Shader 开发的“翻译成本”降到极低。

AI 辅助写 Shader 有三种常见姿势：自然语言生成 Shader Graph——描述材质效果，AI 输出可导入的节点图；HLSL 代码补全——写着写着，IDE 里的 AI 直接给出下一行；自动性能审查——把 Shader 源码给 AI，它会指出冗余采样和高成本语句。

AI 产出质量需要评估，而不是盲目信任。一个实用的指标是编译通过率：

AI 是顾问，拍板的还是你。你仍然需要懂渲染管线、懂性能预算——否则无法判断 AI 的方案是“金玉其外”还是“烧钱内墙”。把 AI 当成一个新入行的资深同事：它出活快，但你要验收。

Paccept=NcompilableNgeneratedP_{accept} = \frac{N_{compilable}}{N_{generated}}
顾问给 10 个方案，8 个能直接施工，接受率就是 80%。
  1. N_generated 生成方案数AI 根据提示词产出的 Shader 代码份数。
    Ngenerated∈NN_{generated} \in \mathbb{N}
  2. N_compilable 可编译方案数通过 Unity 编译、无语法错误的方案数。
    Ncompilable≤NgeneratedN_{compilable} \le N_{generated}
  3. 接受率 P_accept衡量 AI 产出可用程度，也反向检验你的提示词是否清晰。
    Paccept∈[0,1]P_{accept} \in [0, 1]

AI 应用场景

场景一：风格化材质的快速原型

阶段：内容生成

解决的问题：传统流程中，美术师想要一个“赛博朋克霓虹玻璃”效果，需要从零搭建十几甚至几十个节点，反复调试参数，一个材质可能要磨一整天。AI 能把“描述 → 初稿”的周期从小时级压缩到分钟级。

具体案例：某独立游戏团队的小场景需要 30 多种风格化材质。美术师用 AI 工具输入“带扫描线效果的半透明紫色全息屏”，AI 生成 Shader Graph 草稿，美术师再调整扫频速度与透明度，平均每个材质 20 分钟定稿，人力成本下降约 70%。

场景二：移动端 Shader 自动性能体检

阶段：自动优化

解决的问题：手游上线前最怕发热掉帧，传统排查依赖 Profiler 逐项人工分析，经验不足的开发者常常定位不到瓶颈。AI 可以静态扫描 HLSL 源码，自动标记高成本指令、冗余采样和精度滥用。

具体案例：一个第三人称手游的 Fur Shader 在低端机上掉帧。AI 审查后发现片元着色器里有 12 次纹理采样和大量 float 高精度运算，建议将采样降到 4 次、改用 half 精度，重写后帧率从 22 fps 提升到 55 fps。

场景三：语音/文本驱动的特效面板

阶段：代码生成

解决的问题：直播和社交 App 中，运营希望快速产出节日特效贴纸，传统方式需要图形工程师逐帧手写材质。AI 结合自然语言理解，能直接把“金色粒子烟花”这类描述转成可用的粒子材质与 Shader 配置。

具体案例：某短视频团队的 AR 滤镜后台接入 AI 生成管线，运营输入“情人节红色流光背景”，AI 输出 UV 流光 Shader 与调参面板，工程师只做最终审校，新特效上线速度从一天缩短到两小时。

Python 演示

python43 行
import numpy as npimport time def blinn_phong_pixel(normal, light_dir, view_dir, base_color, shininess=32.0):    n = normal / np.linalg.norm(normal)    l = light_dir / np.linalg.norm(light_dir)    v = view_dir / np.linalg.norm(view_dir)    h = (l + v) / np.linalg.norm(l + v)    diff = max(np.dot(n, l), 0.0)    spec = max(np.dot(n, h), 0.0) ** shininess    color = base_color * (0.15 + 0.85 * diff)    color = color + np.array([1.0, 0.9, 0.8]) * spec * 0.6    return np.clip(color, 0.0, 1.0) def render_sphere(size=128):    ys, xs = np.mgrid[0:size, 0:size]    half = (size - 1) / 2    z = np.sqrt(np.maximum(0.0, half**2 - (xs - half)**2 - (ys - half)**2))    mask = z > 0    normals = np.zeros((size, size, 3))    normals[mask] = np.stack([(xs[mask] - half) / half,                              (ys[mask] - half) / half,                              z[mask] / half], axis=-1)    normals = normals / np.linalg.norm(normals, axis=-1, keepdims=True)    light = np.array([0.6, 0.8, -0.5])    light = light / np.linalg.norm(light)    view = np.array([0.0, 0.0, 1.0])    image = np.full((size, size, 3), 0.05)    px = np.argwhere(mask)    for i, j in px:        image[i, j] = blinn_phong_pixel(normals[i, j], light, view,                                        np.array([0.2, 0.5, 0.8]))    return image, len(px) if __name__ == "__main__":    size = 128    t0 = time.perf_counter()    img, cnt = render_sphere(size)    t1 = time.perf_counter()    print("处理像素数:", cnt)    print("CPU串行耗时: %.2f ms" % ((t1 - t0) * 1000))    print("GPU并行示意: 若全部像素并行处理, 耗时仅与单个像素着色成本相当")    print("输出图像形状:", img.shape)
目的：用 numpy 模拟片元着色器的逐像素光照循环，演示 GPU 并行思想与性能公式中“像素数 × 指令数”的关系。
  1. n = normal / np.linalg.norm(normal)归一化法线，对应 HLSL 的 normalize()，只保留方向。
  2. diff = max(np.dot(n, l), 0.0)漫反射项，对应 GLSL/HLSL 中常见的 saturate(dot(n,l))。
  3. spec = max(np.dot(n, h), 0.0) ** shininess高光项，p 次幂控制高光集中度。
  4. normals[mask] = np.stack(...)只在球面覆盖的像素上构造法线，模拟 GPU 只处理被三角形覆盖的片元。
  5. for i, j in px:这是 CPU 串行循环；GPU 会并行执行每个像素，所以真实渲染远快于这个模拟。

常见误区

误区我看到很多教程说学了 Shader Graph 就不需要学 HLSL，反过来也有说必须手写代码才算真本事。我是不是只要学其中一个就行了？

正解Shader Graph 和 HLSL 不是互斥的两套技术，而是同一件事的两种表达。你在编辑器里拖的每一个节点、连的每一条线，最终都会编译成 HLSL 代码。节点图适合快速原型和美术协作，HLSL 适合精细控制和性能调优。先用节点图建立直觉，再用 HLSL 读编译产物理解底层，两条腿走路才是正解。

为何常见：许多入门教程为了降低门槛刻意回避代码，深度教程又推崇手写 Shader，造成“二者对立”的印象。实际上编辑器里就有 View Generated Shader 按钮，随时能看到等价代码。

误区我把 `abs(dot(n,l))` 写进光照计算，球体看起来挺亮的，效果挺好的，这样应该对吧？

正解abs 会把背面（夹角大于 90°）翻成“正对着光”，导致本该全黑的背面出现假光。用 max(0, dot(n,l)) 才符合物理直觉：法线背向光源时根本照不到。球体上不明显是因为球面本来就有大量渐变，换个立方体测试，你会看到背光面亮得诡异。

为何常见：球体是最常用的测试物体，而球面几乎每个朝向都有，人眼对渐变的错误不敏感。

误区材质效果好看就行，性能优化等掉帧了再说吧？反正高配电脑跑得动。

正解Shader 性能在移动端是生死线。一个过度膨胀的片元着色器在 PC 上或许 200 帧，在手机 GPU 上可能直接 20 帧并发热降频。指令数、纹理采样、Overdraw 的账单是每帧实时结算的，而不是最后统一付款。养成“写完即自查”的习惯：采样次数、ALUs、变体数三件套。

为何常见：PC 开发机性能过剩，编辑器里跑的不受真机发热与带宽限制，开发者自然感觉不到压力。

误区给地面贴了法线贴图，砖缝看起来凸起来了，那这个地形的轮廓也应该跟着凹凸不平吧？

正解法线贴图只是修改了像素点上的光照方向——即“让光认为表面朝向变了”，几何网格的顶点位置完全没变。从侧面看，地面依然是一马平川。真正的几何凹凸需要顶点位移、曲面细分或视差映射，分别对应把墙真的敲出起伏。

为何常见：视觉系统强烈依赖光照明暗推断形状，法线贴图恰好精准地骗过这条视觉通路，人脑自动脑补出凸起。

误区给材质加一个关键字开关很方便，再为头发、皮肤、布各加一个选项，变体多就多吧，反正编辑器里跑得动。

正解每个开关都让着色器产生变体，多个开关自由组合形成指数级增长。以 5 个 bool 开关为例，最多 32 个变体；10 个就是 1024 个。变体增加打包体积、加载时间和首次运行编译卡顿。应尽量用多分支合并进同一段代码，或在 Shader Variant Stripping 中裁剪未使用组合。

为何常见：编辑器里感知不到编译产物大小，开发者只看到了“灵活好用”的正面，看不到热更新包和首帧卡顿的账单。

面试题

Q1. 渲染管线中，哪个阶段负责把三角形网格转换为屏幕上的像素片元？

单选题 · easy

  • A.顶点着色器
  • B.光栅化阶段← 正确答案
  • C.片元着色器
  • D.几何着色器

答案：B。光栅化把顶点着色器输出的三角形离散成像素片元，是“由线成面”的关键一步。顶点着色器只处理顶点，片元着色器决定像素颜色，几何着色器则是可选阶段。

Q2. Shader Graph 的主节点栈中，Fragment 部分最终决定了什么？

单选题 · easy

  • A.顶点位置
  • B.片元颜色← 正确答案
  • C.网格拓扑
  • D.渲染顺序

答案：B。Fragment 段决定片元颜色，像素最终显示成什么就靠它。顶点位置由 Vertex 段决定，网格拓扑来自模型文件，渲染顺序由渲染队列控制。

Q3. HLSL 中，SV_Target 语义表示什么？

单选题 · easy

  • A.输入顶点位置
  • B.输出最终颜色← 正确答案
  • C.设定纹理坐标
  • D.描述法线方向

答案：B。SV_Target 是系统值语义，表示函数输出写入渲染目标，通常就是屏幕颜色。SV_Position 用于位置，TEXCOORD 用于纹理坐标，NORMAL 用于法线方向。

Q4. 以下哪个操作是“先归一化再使用”的典型场景？

单选题 · mid

  • A.采样纹理颜色
  • B.参与光照计算← 正确答案
  • C.制作 UV 动画
  • D.调整透明度

答案：B。法线参与点积前必须归一化，长度不是 1 会导致光照偏暗或偏亮。纹理采样、UV 动画、透明度调整都不要求向量长度为 1。

Q5. Blinn-Phong 中高光指数 p 越大，高光表现如何？

单选题 · mid

  • A.越分散越暗淡
  • B.越集中越明亮← 正确答案
  • C.颜色越偏黄色
  • D.光线越偏冷色

答案：B。p 控制高光锐度，p 越大中间值衰减越快，高光越集中明亮；p 小则高光散成一大片，像哑光漆；p 大像亮面漆。

Q6. Unity 中 Frame Debugger 的主要作用是什么？

单选题 · hard

  • A.查看 C# 变量
  • B.回放渲染事件← 正确答案
  • C.调试物理碰撞
  • D.编辑动画曲线

答案：B。Frame Debugger 逐事件回放一帧的渲染过程，每条 Draw Call、每个 Pass 都能展开查看。看 C# 变量用 VS Debugger，物理用 Physics Debug，动画用 Animation 窗口。

Q7. 下列哪种做法不能减少 Draw Call？

单选题 · hard

  • A.使用静态合批
  • B.使用纹理图集
  • C.增加材质数量← 正确答案
  • D.启用实例化绘制

答案：C。增加材质数量会引入更多 Shader Pass 和状态切换，直接增加 Draw Call。静态合批、纹理图集（多张贴图合成一张以共用材质）、GPU Instancing 都减少 Draw Call。

Q8. HLSL 中常见的数据类型包括哪些？

多选题 · mid

  • A.float 浮点型← 正确答案
  • B.half 半精度型← 正确答案
  • C.string 字符串型
  • D.fixed 低精度型← 正确答案

答案：ABD。HLSL 常用 float、half、fixed 三级精度数值类型，对应不同精度与性能开销。string 是 CPU 侧语言类型，GPU 着色器中没有字符串，C 选项错误。

Q9. 下列哪些是优化 Shader 性能的常见手段？

多选题 · mid

  • A.减少纹理采样次数← 正确答案
  • B.避免片元复杂循环← 正确答案
  • C.全用 float 高精度
  • D.用 half 降低精度← 正确答案

答案：ABD。减少纹理采样、避免复杂循环、用半精度都能降低指令成本和带宽。全用 float 高精度反而浪费性能，移动端高精度 ALU 吞吐明显更低，C 选项错误。

Q10. 关于 Unity Shader 变体管理，下列说法错误的是？

多选题 · extreme

  • A.多关键字组合导致爆炸
  • B.裁剪可删除无用组合
  • C.变体越多包体越小← 正确答案
  • D.可用关键字切换变体

答案：C。多关键字自由组合确实会导致变体爆炸，裁剪（Stripping）能删除未使用组合，运行时可通过 EnableKeyword 切换变体，A/B/D 正确。变体越多打包体积越大，C 说法错误。