Web 图形与 3D / 系统课时
分析灯光与材质的片元开销
分析灯光与材质的片元开销
Draw Calls 并不高,场景却在提高分辨率、增加灯光或叠加透明层后掉帧,往往需要检查片元着色成本。本课用固定画幅的 Three.js 对照场景,分别观察光照、贴图、透明混合和 Shader 分支,并用 GPU 计时判断哪些效果值得保留。
学习目标
- 估算像素覆盖量,区分光照计算、纹理读取与透明叠层的额外工作。
- 运行六档对照场景,正确解读绘制次数和 GPU 计时结果。
- 在画质可接受的前提下选择优先删减的片元效果。
先看每个像素做了多少工作
在 960×540、pixelRatio=1 的画布上,一张铺满画面的平面覆盖约 518400 个像素;五层完全重叠的透明平面则有约 2592000 次潜在片元覆盖。若 CSS 尺寸不变而像素比升至 2,物理像素数还会增加到四倍。这只是覆盖量估算,深度测试、裁剪和硬件优化会影响实际执行的着色次数。
| 变化 | 可能增加的 GPU 工作 | 该怎样检查 |
|---|---|---|
MeshBasicMaterial 换成 MeshStandardMaterial,定向光由 1 盏增至 4 盏 |
PBR 片元光照运算;若开阴影,还有阴影图绘制与采样 | 固定画面、关闭阴影,先只变光源数量 |
增加 map、normalMap |
纹理采样、法线计算和缓存压力 | 先保持光源不变,再逐张撤销贴图 |
一层不透明变成五层 transparent 叠加 |
重复着色与颜色混合,深度剔除收益可能降低 | 看同一像素被覆盖的层数,不能只看三角形数 |
| Shader 条件依赖每像素数据 | 相邻片元可能走不同路径;编译器也可能改写分支 | 对比一致分支与分歧分支的实际 GPU 时间 |
transparent: true 不等于一定慢;只有大量重叠、较高着色复杂度等条件同时出现时,开销才可能显著。alphaTest 适合硬边裁切,却不能直接替代半透明玻璃或烟雾。

搭建可切换的对照场景
使用支持当前 Vite 版本的 Node.js,创建原生 JavaScript 工程并安装 Three.js;示例针对 WebGLRenderer,不依赖 WebGPU。先执行:
npm create vite@latest fragment-cost -- --template vanilla
cd fragment-cost
npm install
npm install three预期结果:工程包含 src/main.js,且 three 已写入依赖。将 src/main.js 全部替换为以下代码。六档模式依次是基础材质、PBR 单灯、PBR 四灯、四灯加两张贴图、五层透明,以及逐像素交错分支。
import * as THREE from 'three';
const renderer = new THREE.WebGLRenderer({ antialias: false });
renderer.setPixelRatio(1); // 锁定物理像素,避免高 DPI 干扰对照
renderer.setSize(960, 540);
document.body.style.margin = '0';
document.body.appendChild(renderer.domElement);
const scene = new THREE.Scene();
scene.background = new THREE.Color(0x142b39);
const camera = new THREE.OrthographicCamera(-1, 1, 1, -1, 0.1, 10);
camera.position.z = 3;
const geometry = new THREE.PlaneGeometry(2, 2);
const basic = new THREE.MeshBasicMaterial({ color: 0x56acb7 });
const pbr = new THREE.MeshStandardMaterial({
color: 0x56acb7, roughness: 0.6, metalness: 0
});
const texels = new Uint8Array(32 * 32 * 4);
const normals = new Uint8Array(32 * 32 * 4);
for (let y = 0; y < 32; y++) {
for (let x = 0; x < 32; x++) {
const offset = (y * 32 + x) * 4;
const value = (Math.floor(x / 4) + Math.floor(y / 4)) % 2 ? 220 : 90;
texels.set([value, 160, 190, 255], offset);
normals.set([128, 128, 255, 255], offset);
}
}
const map = new THREE.DataTexture(texels, 32, 32);
map.colorSpace = THREE.SRGBColorSpace;
map.needsUpdate = true;
const normalMap = new THREE.DataTexture(normals, 32, 32);
normalMap.needsUpdate = true;
const mapped = new THREE.MeshStandardMaterial({
color: 0xffffff, roughness: 0.6, map, normalMap
});
const branch = new THREE.ShaderMaterial({
vertexShader: `
varying vec2 vUv;
void main() {
vUv = uv;
gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
}
`,
fragmentShader: `
varying vec2 vUv;
void main() {
bool alternate = mod(floor(gl_FragCoord.x) + floor(gl_FragCoord.y), 2.0) < 1.0;
vec3 color;
if (alternate) color = vec3(vUv.x, 0.6, 0.75);
else color = vec3(0.8, vUv.y, 0.3);
gl_FragColor = vec4(color, 1.0);
}
`
});
const main = new THREE.Mesh(geometry, basic);
scene.add(main);
const lights = Array.from({ length: 4 }, (_, i) => {
const light = new THREE.DirectionalLight(0xffffff, 1);
light.position.set(i - 1.5, 1, 2);
scene.add(light);
return light;
});
const alpha = new THREE.MeshBasicMaterial({
color: 0xf4a15d, transparent: true, opacity: 0.24, depthWrite: false
});
const layers = Array.from({ length: 5 }, (_, i) => {
const mesh = new THREE.Mesh(geometry, alpha);
mesh.position.z = i * 0.08;
scene.add(mesh);
return mesh;
});
const modes = [
['Basic', basic, 0, 0],
['PBR / 1 灯', pbr, 1, 0],
['PBR / 4 灯', pbr, 4, 0],
['PBR / 4 灯 + 2 贴图', mapped, 4, 0],
['透明 / 5 层', basic, 0, 5],
['逐像素 Shader 分支', branch, 0, 0]
];
let current = 0;
let samples = [];
let warmup = 4;
function selectMode(index) {
current = index;
const [, material, lightCount, layerCount] = modes[index];
main.material = material;
main.visible = layerCount === 0;
// 多灯模式调低单灯强度,尽量减少亮度差异
lights.forEach((light, i) => {
light.visible = i < lightCount;
light.intensity = lightCount ? 2 / lightCount : 0;
});
layers.forEach((mesh, i) => { mesh.visible = i < layerCount; });
samples = [];
warmup = 4;
}
selectMode(0);
window.addEventListener('keydown', (event) => {
const index = Number(event.key) - 1;
if (Number.isInteger(index) && index >= 0 && index < modes.length) {
selectMode(index);
}
});
const gl = renderer.getContext();
const ext = gl.getExtension('EXT_disjoint_timer_query_webgl2');
const status = document.createElement('div');
status.style.cssText = 'padding:12px;font:16px sans-serif;color:#203746';
document.body.appendChild(status);
let pending = null;
function frame() {
// 异步读取 GPU 查询结果,不在主线程强制等待 GPU
if (ext && pending && gl.getQueryParameter(pending.query, gl.QUERY_RESULT_AVAILABLE)) {
const disjoint = gl.getParameter(ext.GPU_DISJOINT_EXT);
if (!disjoint && pending.mode === current) {
const ms = gl.getQueryParameter(pending.query, gl.QUERY_RESULT) / 1e6;
if (warmup > 0) warmup--;
else {
samples.push(ms);
if (samples.length > 40) samples.shift();
}
}
gl.deleteQuery(pending.query);
pending = null;
}
if (ext && !pending) {
const query = gl.createQuery();
gl.beginQuery(ext.TIME_ELAPSED_EXT, query);
renderer.render(scene, camera);
gl.endQuery(ext.TIME_ELAPSED_EXT);
pending = { query, mode: current };
} else {
renderer.render(scene, camera);
}
const sorted = [...samples].sort((a, b) => a - b);
const gpu = sorted.length >= 10
? `${sorted[Math.floor(sorted.length / 2)].toFixed(2)} ms`
: ext ? '采样中' : '计时扩展不可用';
status.textContent = `按 1–6 切换 | ${modes[current][0]} | Draw Calls: ${renderer.info.render.calls} | GPU: ${gpu} | 样本: ${samples.length}/40`;
requestAnimationFrame(frame);
}
frame();预期结果(启动后):画布显示对应材质,按 1~6 切换;前四档和第六档通常各有 1 次绘制,第五档有 5 次绘制。如果浏览器支持计时扩展,预热后显示 GPU 时间中位数;否则明确显示不支持,不会虚构毫秒值。
最后启动开发服务器:
npm run dev预期结果:终端显示 Local 本地访问地址。打开它即可操作;实际端口 <PORT> 由 Vite 决定,可能与默认值不同。
用相邻档位判断瓶颈
每次切换后等待纹理上传、Shader 编译及预热结束,再记录连续至少 40 个有效 GPU 查询的中位数。示例计时覆盖整次 renderer.render(),并非只计算片元着色;首次编译、CPU 帧间隔和计时扩展不支持的情况都不能当作稳定 GPU 开销。
- 比较
2与3:材质、几何和画幅相同,主要变化是参与着色的定向光数量。 - 比较
3与4:四盏灯保持不变,观察颜色贴图和法线贴图的额外成本。示例法线贴图是平坦法线,用于演示没有明显视觉收益的额外采样。 - 比较
1与5:两种画面并不等价,只用于展示五层透明覆盖会增加绘制与混合量,不能直接据此评价最终视觉性价比。 - 模式
6展示随像素变化的条件分支;它与 Basic 的着色工作量不同,不能单凭两者耗时推断分支代价。要验证分支,另做数学运算相同、仅改变条件一致性的 Shader A/B 测试。
例如同一设备测得四灯 GPU 用时 2.3 ms、单灯 1.4 ms,差值就是 0.9 ms;这是计算示例,不是程序保证产生的数值。若在高分辨率下差值显著扩大,应优先怀疑片元覆盖和计算量,而不是单看 renderer.info.render.calls。
保留能看出差异的效果
优化按受影响屏幕面积与视觉收益排序:占满屏幕的水面、雾层、全屏粒子应先查透明重叠;远景小物体若看不出法线细节,可移除 normalMap;不依赖实时受光的图标、标线可考虑 MeshBasicMaterial;灯光则优先删除贡献重复的光源,不能把关闭阴影的成本变化误判成仅减少一盏灯。
对叶片或栅栏等硬边镂空材质,可以测试 alphaTest: 0.5,但要检查锯齿和阴影边缘;对半透明烟雾不要照搬。若从 pixelRatio=2 降到 1 才明显恢复流畅,应同时调查高覆盖率材质和透明叠层。最终保留同视角截图、GPU 中位数及视觉差异,才有依据选择删减哪项效果。