Web 图形与 3D / 系统课时

同一帧串联计算与渲染通道

同一帧串联计算与渲染通道

这一课把位置更新与画面绘制放进同一次 WebGPU 命令编码:ComputePass 先修改 GPU 存储缓冲区,RenderPass 再读取新位置绘制三角形。最终只提交一个命令缓冲区,不必让 CPU 回读计算结果。

学习目标

  • 用一个 GPUCommandEncoder 依次录制计算通道和渲染通道。
  • 让两种管线通过同一 GPUBuffer 交换数据,并正确区分读写权限。
  • 用可运行页面验证计算结果在本帧直接参与绘制。

让写入发生在绘制之前

本例的共享资源是存放三个顶点的 GPUBuffer。每个顶点包含 position: vec2f 与 velocity: vec2f,共 16 字节;三个顶点需要 48 字节。缓冲区同时设置 GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST:前者允许着色器访问,后者允许初始化时用 queue.writeBuffer() 上传数据。

同一帧的正确顺序是先 beginComputePass()、dispatchWorkgroups(1)、end(),再 beginRenderPass()、draw(3)、end(),最后调用 queue.submit([encoder.finish()])。两段 Pass 在同一命令缓冲区中按序执行,WebGPU 处理通道间的资源依赖;这里不需要 CPU 等待或自行插入显式屏障。

单帧计算与渲染共享存储缓冲区的数据流

要注意:计算阶段声明 var<storage, read_write>,顶点阶段声明 var<storage, read>。两个使用 layout: "auto" 的管线可能推导出不同的绑定组布局,因此本例分别创建两个 BindGroup,但它们指向同一个缓冲区;因为顶点着色器通过存储绑定读取数据,无须额外设置 GPUBufferUsage.VERTEX。

一个页面完成计算和绘制

把以下内容保存为 index.html。示例用三个粒子组成三角形,计算着色器将每个顶点的横坐标增加 0.5 × 0.4 = 0.2,随后顶点着色器从刚更新的存储缓冲区读取坐标。@workgroup_size(64) 会启动 64 个调用,只有索引 0~2 有效,其余由边界检查跳过。

html
<!doctype html>
<html lang="zh-CN">
<head>
  <meta charset="utf-8">
  <title>WebGPU 同帧计算与渲染</title>
</head>
<body>
  <canvas id="scene" width="640" height="360"></canvas>
  <script type="module">
    const canvas = document.querySelector("#scene");
    if (!navigator.gpu) throw new Error("当前环境不支持 WebGPU");
    const adapter = await navigator.gpu.requestAdapter();
    if (!adapter) throw new Error("无法获取 GPU 适配器");
    const device = await adapter.requestDevice();
    const context = canvas.getContext("webgpu");
    const format = navigator.gpu.getPreferredCanvasFormat();
    context.configure({ device, format, alphaMode: "opaque" });

    // 每个粒子依次存储位置 x/y 和速度 x/y。
    const initialData = new Float32Array([
      -0.65, -0.50, 0.50, 0.00,
       0.00, -0.50, 0.50, 0.00,
      -0.325, 0.55, 0.50, 0.00,
    ]);
    const buffer = device.createBuffer({
      size: initialData.byteLength,
      usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
    });
    device.queue.writeBuffer(buffer, 0, initialData);

    const computeModule = device.createShaderModule({ code: `
      struct Particle {
        position: vec2f,
        velocity: vec2f,
      };
      @group(0) @binding(0)
      var<storage, read_write> particles: array<Particle>;

      @compute @workgroup_size(64)
      fn update(@builtin(global_invocation_id) id: vec3u) {
        if (id.x >= arrayLength(&particles)) { return; }
        particles[id.x].position =
          particles[id.x].position + particles[id.x].velocity * 0.4;
      }
    ` });

    const renderModule = device.createShaderModule({ code: `
      struct Particle {
        position: vec2f,
        velocity: vec2f,
      };
      @group(0) @binding(0)
      var<storage, read> particles: array<Particle>;

      @vertex
      fn vs(@builtin(vertex_index) index: u32)
          -> @builtin(position) vec4f {
        let p = particles[index].position;
        return vec4f(p, 0.0, 1.0);
      }

      @fragment
      fn fs() -> @location(0) vec4f {
        return vec4f(0.04, 0.72, 0.62, 1.0);
      }
    ` });

    const computePipeline = device.createComputePipeline({
      layout: "auto",
      compute: { module: computeModule, entryPoint: "update" },
    });
    const renderPipeline = device.createRenderPipeline({
      layout: "auto",
      vertex: { module: renderModule, entryPoint: "vs" },
      fragment: {
        module: renderModule,
        entryPoint: "fs",
        targets: [{ format }],
      },
      primitive: { topology: "triangle-list" },
    });

    // 两个绑定组使用各自管线推导出的布局,但共享同一缓冲区。
    const computeGroup = device.createBindGroup({
      layout: computePipeline.getBindGroupLayout(0),
      entries: [{ binding: 0, resource: { buffer } }],
    });
    const renderGroup = device.createBindGroup({
      layout: renderPipeline.getBindGroupLayout(0),
      entries: [{ binding: 0, resource: { buffer } }],
    });

    const encoder = device.createCommandEncoder();
    const computePass = encoder.beginComputePass();
    computePass.setPipeline(computePipeline);
    computePass.setBindGroup(0, computeGroup);
    computePass.dispatchWorkgroups(1);
    computePass.end();

    // 计算通道先结束,渲染通道才读取本帧的新位置。
    const renderPass = encoder.beginRenderPass({
      colorAttachments: [{
        view: context.getCurrentTexture().createView(),
        clearValue: { r: 0.03, g: 0.05, b: 0.10, a: 1 },
        loadOp: "clear",
        storeOp: "store",
      }],
    });
    renderPass.setPipeline(renderPipeline);
    renderPass.setBindGroup(0, renderGroup);
    renderPass.draw(3);
    renderPass.end();

    device.queue.submit([encoder.finish()]);
    console.log("已提交:ComputePass → RenderPass;3 个顶点");
  </script>
</body>
</html>

预期输出(浏览器开发者工具 Console;表示命令已提交,不表示 GPU 已完成执行):

text
已提交:ComputePass → RenderPass;3 个顶点

启动并核对屏幕结果

在 index.html 所在目录启动本地服务器。下面的命令适用于安装了 Python 3 且提供 python3 命令的系统;浏览器需支持 WebGPU,页面通过 localhost 访问以满足安全上下文要求。

bash
python3 -m http.server 8000 --bind 127.0.0.1

预期输出:

text
Serving HTTP on 127.0.0.1 port 8000 (http://127.0.0.1:8000/) ...

访问 http://127.0.0.1:8000/index.html,应看到深色画布上的青绿色三角形。其三个顶点的横坐标应分别为 -0.45、0.20、-0.125;相较初始位置统一右移 0.2 个裁剪空间单位,在 640 像素宽的画布上相当于约 64 像素。

为了确认画面读取的是计算结果,可以将计算着色器中的 * 0.4 改为 * 0.0 并刷新。三角形应左移约 64 像素;改回 0.4 后恢复。这个对照比仅检查 Console 日志更能证明 ComputePass 的写入被本帧 RenderPass 使用。

通道衔接的常见错误

现象 原因与修正
beginRenderPass() 或 finish() 报验证错误 前一计算通道未调用 computePass.end();两个 Pass 不能同时保持打开。
顶点着色器编译失败 顶点阶段不允许写存储缓冲区;改为 var<storage, read>,仅在计算阶段使用 read_write。
设置绑定组时出现布局错误 自动推导出的计算与渲染 BindGroup 布局不相同;分别调用对应管线的 getBindGroupLayout(0) 创建绑定组。
仍显示旧位置 检查 dispatchWorkgroups() 是否录制在 draw() 之前,以及渲染绑定的是否为同一个 GPUBuffer。

扩展为连续动画时,把“创建 encoder → 计算 → 渲染 → 提交”的代码放进 requestAnimationFrame() 驱动的帧函数,每帧重新取得 context.getCurrentTexture();管线、缓冲区和绑定组则可以复用。每一帧依然保持先更新、后绘制的顺序。

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

目录与阅读设置

阅读设置

17

记录一个想法

同一帧串联计算与渲染通道

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

登录哪都通