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。先执行:

bash
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 四灯、四灯加两张贴图、五层透明,以及逐像素交错分支。

js
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 时间中位数;否则明确显示不支持,不会虚构毫秒值。

最后启动开发服务器:

bash
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 中位数及视觉差异,才有依据选择删减哪项效果。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

分析灯光与材质的片元开销

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通