three.js 中使用 WebGPU:给画面加一层光

前两篇都在处理物体:一堆星点、一堆粒子。这篇不一样,它处理的是画完之后的那张图。

官方示例里是个红黄相间的机械结构,线框质感的圆环一圈套一圈,背景全黑。亮的地方往外散出一层光晕,像隔着毛玻璃看灯。

three.js 官方 Bloom 示例:发光圆环外的光晕

这层光晕就是 bloom,中文一般叫泛光。

它值得单独学,因为它是你第一次离开"摆物体"的思路,开始对整张画面动手。

后处理是什么

正常的渲染流程是:场景里的东西经过相机直接画到屏幕上。

后处理在这条路上插了一步:先画到一张看不见的图上,再对这张图做点加工,最后才贴到屏幕。

为什么值得多这一步?因为对于有些效果,对"图"下手比对"物体"下手容易得多。

比如你想让整个画面偏黄一点。按物体的思路,得把场景里每个材质的颜色都改一遍,漏一个就穿帮。按图的思路,是把所有像素乘一个偏黄的系数,一行搞定。

再比如你想让边缘糊一点、想加一层噪点、想把亮的地方提出来单独处理。这些在"图"这一层都是一句话的事,在"物体"那一层就很别扭。

这跟修图是一个道理。拍完照后可以在相机里调参数,也可以在修图软件里套滤镜。后者能做的事多得多,因为它面对的是成品。

泛光的原理

理解了后处理,泛光本身就不难了。它做的事跟人眼在强光下的感觉有关:晚上看路灯,灯泡周围总有一圈光,那不是灯发出来的,是眼睛和镜头糊出来的。

计算机仿照了这个过程,分三步:

先把画面里够亮的部分挑出来,其余压成黑色。得到一张只有亮部的图。

再把这张图糊开。糊得越厉害,光晕越大。

最后把糊过的图叠回原图。亮的地方变得更亮、往外溢,光晕就成了。

结束。所谓 bloom,就是这个流程。不同实现之间的差别,只在"多亮才算亮",还有"糊得多开"。

老写法和新写法

在 WebGL 时代,后处理靠一条 pass 链。

EffectComposer 管总,往里一个个加 pass:先 RenderPass 渲场景,再加 UnrealBloomPass 做泛光,最后加 OutputPass 收尾。每加一个 pass,就要在两张全屏纹理之间倒一次手。

这套东西用了很多年,能干活,但写起来啰嗦,而且 pass 一多,来回拷贝的开销就上来了。

WebGPU 这条路上,three.js 换了个思路:不要 pass 数组,改成一条节点链。

你写的是一个表达式,最后挂到一个输出上。想要两个效果,就在表达式里加号、乘号连起来。听起来抽象,看代码就懂了。

先跑一个小的

存成 bloom.html,双击打开:

<!DOCTYPE html>
<html>
  <head>
    <meta charset="utf-8" />
    <style>
      body {
        margin: 0;
        overflow: hidden;
        background: #000;
      }
      canvas {
        display: block;
      }
    </style>
  </head>
  <body>
    <script type="importmap">
      {
        "imports": {
          "three": "https://cdn.jsdelivr.net/npm/three@0.187.0/build/three.webgpu.js",
          "three/webgpu": "https://cdn.jsdelivr.net/npm/three@0.187.0/build/three.webgpu.js",
          "three/tsl": "https://cdn.jsdelivr.net/npm/three@0.187.0/build/three.tsl.js",
          "three/addons/": "https://cdn.jsdelivr.net/npm/three@0.187.0/examples/jsm/"
        }
      }
    </script>

    <script type="module">
      import * as THREE from "three/webgpu";
      import { pass } from "three/tsl";
      import { bloom } from "three/addons/tsl/display/BloomNode.js";

      const scene = new THREE.Scene();
      const camera = new THREE.PerspectiveCamera(
        45,
        innerWidth / innerHeight,
        0.1,
        100,
      );
      camera.position.set(0, 0, 6);

      const light = new THREE.PointLight(0xffffff, 60);
      light.position.set(2, 2, 4);
      scene.add(light);

      const ball = new THREE.Mesh(
        new THREE.SphereGeometry(1, 64, 32),
        new THREE.MeshStandardMaterial({
          color: 0xff5522,
          emissive: 0xff3311,
          emissiveIntensity: 3,
        }),
      );
      scene.add(ball);

      const renderer = new THREE.WebGPURenderer({ antialias: true });
      renderer.setSize(innerWidth, innerHeight);
      document.body.appendChild(renderer.domElement);

      const pipeline = new THREE.RenderPipeline(renderer);
      const scenePass = pass(scene, camera);
      const sceneColor = scenePass.getTextureNode("output");
      const bloomPass = bloom(sceneColor);
      pipeline.outputNode = sceneColor.add(bloomPass);

      renderer.setAnimationLoop(() => {
        ball.rotation.y += 0.005;
        pipeline.render();
      });

      addEventListener("resize", () => {
        camera.aspect = innerWidth / innerHeight;
        camera.updateProjectionMatrix();
        renderer.setSize(innerWidth, innerHeight);
      });
    </script>
  </body>
</html>

一颗橙红色的球悬在黑色背景里,周围一圈明显的光晕,还在慢慢转。

想验证光晕真是泛光加出来的,把最后一行改成 pipeline.outputNode = sceneColor; 试试。光晕立刻消失,球变成一个硬邦邦的圆盘。

四行代码,一条链

const pipeline = new THREE.RenderPipeline(renderer);
const scenePass = pass(scene, camera);
const sceneColor = scenePass.getTextureNode("output");
const bloomPass = bloom(sceneColor);
pipeline.outputNode = sceneColor.add(bloomPass);

第一行建一条管线。文档里的说法是:这个类负责管理应用的渲染管线和后处理链,通常只建一个实例,而且只能配 WebGPURenderer 用。

第二行渲染场景,但结果不往屏幕上送,而是留在一张纹理里。

第三行把那张纹理的颜色取出来。

第四行把颜色喂给泛光,然后把"原图加泛光"挂到输出上。

五行的代码,四步逻辑,比 pass 链清楚得多。尤其是最后那个add方法就是字面意思:两张图相加。

pass 和那个字符串

pass(scene, camera) 做的事就是"渲染一遍,别急着显示"。它返回一个节点,身上挂着几张纹理。

getTextureNode('output') 取的是颜色那张。output 这个名字是约定好的。

同一个 pass 还能取深度、取法线,取决于渲染时写了哪些附件。做景深、做描边的时候,取的就是另外那几张。

那六个配置项在省什么

const config = {
  storeMultisampledColorBuffer: false,
  storeMultisampledDepthBuffer: false,
  storeMultisampledStencilBuffer: false,
  resolveColorBuffer: true,
  resolveDepthBuffer: false,
  resolveStencilBuffer: false,
};

看着吓人,其实在说一件事。

开了抗锯齿(MSAA)之后,每个附件都会有两份:一份是多采样的原始数据,一份是解析后的结果。默认两份都留,显存和带宽一起吃紧。

这段配置的意思是:只留颜色解析后的那一份,深度和模板都不要。代码注释写得很直白,这个配置只在用 MSAA 时有意义,而且是可选的。

antialias: true 打开的就是 4 倍 MSAA,所以这段配置在示例里确实起作用。

你的场景要是不需要抗锯齿,这六行可以直接删,一个字都不用改。

三个旋钮

bloomPass.threshold.value = value; // 多亮才算亮部
bloomPass.strength.value = value; // 泛光多强
bloomPass.radius.value = value; // 扩散多远

threshold 是最容易被忽略的一个。示例的初始值写的是 0,等于全画面都参与泛光。拖到 0 整个画面会糊成一片,什么都看不清。

实际项目里一般从 0.6 往上试,让只有真正亮的地方发光。

strength 是强度,radius 是扩散范围。三个一起调,手感很快就出来了。

色调映射得自己接

renderer.toneMapping = THREE.ReinhardToneMapping;
renderer.toneMappingExposure = Math.pow(value, 4.0);

这句话的意思是:画面最后要经过一道"从高动态范围压到屏幕能显示的范围"的处理。

不接的话,亮的地方会一片死白,泛光也会过曝。

示例用的是 Reinhard,滑块范围 0.1 到 2,取四次方之后传给曝光。四次方让滑块中间那段变化更细腻,两头更陡,手感比线性好。

还有个属性叫 outputColorTransform,默认开着,管的就是最后那一步色调映射和色彩空间转换。除非你要把效果放在色调映射之后跑,否则别关它。

循环里最容易调错的一行

renderer.setAnimationLoop(() => {
  ball.rotation.y += 0.005;
  pipeline.render();
});

注意是 pipeline.render(),不是 renderer.render(scene, camera)。

文档专门强调了这一条:用了 RenderPipeline 之后,动画循环里必须调它的 render,不能调渲染器自己的。

调错了不会报错,也不会黑屏,画面就是没有后处理。你会以为是参数没调对,在那三个旋钮上来回试半天。

这个坑我踩过,所以写在前面。

想换成自己的效果

  • 泛光参数:threshold、strength、radius,先把 threshold 从 0 抬到 0.6 看差别
  • 色调映射:renderer.toneMapping 换成 ACESFilmic 或 AgX,再配曝光
  • 加第二个效果:pipeline.outputNode = sceneColor.add( bloomPass ).mul( 某个节点 ),节点能一直往下接

有个前提得说清楚。泛光只对真正亮的像素有用。

模型本身没有高亮材质、场景里没有强光源,把 strength 拖满也只是整体发灰,不会发光。示例里那个机械结构的圆环本来就是红黄自发光的样子,所以一开就明显。换成你自己那些灰扑扑的模型,同一套参数可能一点反应都没有。

想让自己的场景发光,先给材质加 emissive,或者把光源强度提上去。

跑不起来先看这几处

画面没有任何变化————先检查循环里调的是不是 pipeline.render()。

报错说 RenderPipeline 未定义————版本太老,RenderPipeline 是后来的 API,CDN 上的版本号别乱改。

泛光一片糊————threshold 是 0,抬到 0.6 试试。

画面死白————toneMapping 没设置,或者曝光太高。

光晕只在屏幕边缘出现————多半是相机离得太近,物体被裁掉了一部分。

最后

三篇下来你看出来了吗?WebGPU 在 three.js 里能做的事,大致分成了三层。

第一层是用材质描述每个物体长什么样,星系那篇就是这一层,位置和颜色都在材质里算。

第二层是用计算着色器管理一堆数据,粒子那篇是这一层,状态存在显存里,每帧更新。

第三层是对整张画面动手,这篇是这一层,物体已经画完了,剩下的全是图像处理。

三层能叠在一起用。粒子系统加泛光,星系加色调映射,都是常见组合。

真正上手做项目的时候,你会发现难的不是这三层,是"什么时候该用哪一层"。这个问题没有标准答案,多改几个示例,手感自然就有了。


参考来源

  1. three.js 官方示例 webgpu_postprocessing_bloom:https://threejs.org/examples/webgpu_postprocessing_bloom.html
  2. three.js 文档 RenderPipeline(outputNode、render、outputColorTransform):https://threejs.org/docs/pages/RenderPipeline.html
  3. three.js 文档 WebGPURenderer:https://threejs.org/docs/pages/WebGPURenderer.html
  4. 示例页标注的作者:Bloom pass by Prashant Sharma 与 Ben Houston;模型 Primary Ion Drive by Mike Murdock(CC BY 4.0)