Web 图形与 3D / 系统课时

离屏渲染到可复用纹理

离屏渲染到可复用纹理

当一个画面需要先被绘制、再交给后续渲染通道采样时,就需要独立于 Canvas 的离屏颜色纹理。本篇使用 WebGPU 创建兼具渲染附件和纹理绑定用途的 GPUTexture,先保存渐变画面,再通过第二个渲染通道将它显示到画布,并处理资源复用和尺寸变化。

学习目标

  • 使用 RENDER_ATTACHMENT 和 TEXTURE_BINDING 创建可写入、可采样的离屏颜色纹理。
  • 通过两个顺序执行的 RenderPass,完成中间结果的保存与纹理采样。
  • 正确处理纹理格式、绑定组重建和读写冲突,并验证最终画面。

创建具备双重用途的颜色纹理

普通的 Canvas 当前纹理由交换链管理,适合输出最终画面,却不适合作为需要长期保留的中间渲染资源。离屏渲染应通过 device.createTexture() 创建独立纹理,让应用控制其尺寸、格式和生命周期。

本例选择 rgba8unorm,每个像素占用 4 字节,支持颜色附件写入和普通浮点纹理采样。创建时必须同时声明两种用途:

  • GPUTextureUsage.RENDER_ATTACHMENT:允许纹理视图成为 RenderPass 的颜色附件。
  • GPUTextureUsage.TEXTURE_BINDING:允许纹理视图通过 BindGroup 绑定,在后续着色器中采样。

关键配置如下:

配置项 本例取值 作用
size [width, height] 与画布实际绘图像素尺寸一致
format rgba8unorm 保存四通道归一化颜色
sampleCount 1 使用可直接采样的单采样纹理
usage 两种用途按位或 同时允许颜色附件写入和纹理采样
storeOp store 在渲染通道结束后保留颜色结果

例如,1280×720 的单层 RGBA8 纹理需要约 3.52 MiB 的像素存储空间,不包含实现相关开销。如果后续只在 GPU 上采样,不需要添加 COPY_SRC;只有确实要执行纹理复制或读回操作时,才应补充相应的用途标志。

两个渲染通道如何共享结果

整个过程使用两次独立的 RenderPass,但复用同一个离屏 GPUTexture。第一遍负责生产颜色,第二遍负责消费颜色,中间不需要先复制到 CPU,也不需要调用 copyTextureToTexture()。

  1. 创建离屏 GPUTexture,并通过 createView() 获得颜色附件视图。
  2. 开启第一遍 RenderPass,将离屏视图设置为 colorAttachments[0].view,绘制全屏三角形,使用 storeOp: 'store' 保存结果。
  3. 结束第一遍 RenderPass,为同一 GPUTexture 创建采样视图,将其和 Sampler 放入 BindGroup。
  4. 开启第二遍 RenderPass,把 Canvas 当前纹理设为输出附件,在片元着色器中调用 textureSample() 读取离屏颜色。
  5. 结束第二遍并提交命令,浏览器显示最终画面。

离屏颜色纹理在两个渲染通道之间的写入与采样关系

这里有两个需要区分的生命周期:GPUTexture 在多帧之间可以持续存在,Canvas 当前纹理则需要在每次绘制时重新通过 getCurrentTexture() 获取。只要离屏纹理的尺寸和格式没有改变,就可以复用其绑定组,不必每帧重新创建。

实现可运行的离屏渲染

下面是一个完整的 HTML 示例,不依赖第三方库。第一遍将水平和垂直 UV 坐标转换成红色、绿色分量,写入离屏纹理;第二遍采样同一张纹理,将结果铺满 Canvas。

运行前需要支持 WebGPU 的浏览器及安全上下文。把代码保存为 index.html,在该文件所在目录执行 python3 -m http.server 8000,然后打开 http://localhost:8000。如使用 Windows,也可根据已安装的 Python 启动方式调整命令。

html
<!doctype html>
<html lang='zh-CN'>
<head>
<meta charset='utf-8'>
<title>WebGPU 离屏纹理</title>
<style>
  body { margin: 24px; background: #edf2f6; }
  canvas { display: block; width: min(90vw, 640px); height: auto; }
</style>
</head>
<body>
<canvas id='view' width='640' height='360'></canvas>
<script type='module'>
const canvas = document.querySelector('#view');
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 canvasFormat = navigator.gpu.getPreferredCanvasFormat();
context.configure({ device, format: canvasFormat, alphaMode: 'opaque' });

const shader = device.createShaderModule({ code: `
struct VertexOut {
  @builtin(position) position: vec4f,
  @location(0) uv: vec2f,
};

@vertex fn vertexMain(@builtin(vertex_index) index: u32) -> VertexOut {
  let vertices = array<vec2f, 3>(
    vec2f(-1.0, -1.0), vec2f(3.0, -1.0), vec2f(-1.0, 3.0)
  );
  let p = vertices[index];
  var out: VertexOut;
  out.position = vec4f(p, 0.0, 1.0);
  out.uv = vec2f((p.x + 1.0) * 0.5, (1.0 - p.y) * 0.5);
  return out;
}

// 第一遍:生成颜色数据。
@fragment fn sceneMain(input: VertexOut) -> @location(0) vec4f {
  return vec4f(input.uv.x, input.uv.y, 0.3, 1.0);
}

@group(0) @binding(0) var source: texture_2d<f32>;
@group(0) @binding(1) var sampling: sampler;

// 第二遍:从离屏纹理取回颜色。
@fragment fn displayMain(input: VertexOut) -> @location(0) vec4f {
  return textureSample(source, sampling, input.uv);
}
` });

function pipeline(fragmentEntry, format) {
  return device.createRenderPipeline({
    layout: 'auto',
    vertex: { module: shader, entryPoint: 'vertexMain' },
    fragment: {
      module: shader,
      entryPoint: fragmentEntry,
      targets: [{ format }],
    },
    primitive: { topology: 'triangle-list' },
  });
}

const scenePipeline = pipeline('sceneMain', 'rgba8unorm');
const displayPipeline = pipeline('displayMain', canvasFormat);
const sampler = device.createSampler({
  magFilter: 'linear',
  minFilter: 'linear',
});

let offscreen;
let displayBindGroup;

function render() {
  const scale = window.devicePixelRatio || 1;
  const max = device.limits.maxTextureDimension2D;
  const width = Math.min(max, Math.max(1,
    Math.round(canvas.clientWidth * scale)));
  const height = Math.min(max, Math.max(1,
    Math.round(canvas.clientHeight * scale)));

  if (!offscreen || canvas.width !== width || canvas.height !== height) {
    canvas.width = width;
    canvas.height = height;
    offscreen?.destroy();

    // 尺寸变化后重建纹理及引用它的绑定组。
    offscreen = device.createTexture({
      size: [width, height],
      format: 'rgba8unorm',
      sampleCount: 1,
      usage: GPUTextureUsage.RENDER_ATTACHMENT |
             GPUTextureUsage.TEXTURE_BINDING,
    });
    displayBindGroup = device.createBindGroup({
      layout: displayPipeline.getBindGroupLayout(0),
      entries: [
        { binding: 0, resource: offscreen.createView() },
        { binding: 1, resource: sampler },
      ],
    });
  }

  const encoder = device.createCommandEncoder();

  // 第一遍:写入并保留离屏颜色。
  const scenePass = encoder.beginRenderPass({
    colorAttachments: [{
      view: offscreen.createView(),
      clearValue: { r: 0, g: 0, b: 0, a: 1 },
      loadOp: 'clear',
      storeOp: 'store',
    }],
  });
  scenePass.setPipeline(scenePipeline);
  scenePass.draw(3);
  scenePass.end();

  // 第二遍:采样离屏颜色并输出到 Canvas。
  const displayPass = encoder.beginRenderPass({
    colorAttachments: [{
      view: context.getCurrentTexture().createView(),
      clearValue: { r: 0, g: 0, b: 0, a: 1 },
      loadOp: 'clear',
      storeOp: 'store',
    }],
  });
  displayPass.setPipeline(displayPipeline);
  displayPass.setBindGroup(0, displayBindGroup);
  displayPass.draw(3);
  displayPass.end();

  device.queue.submit([encoder.finish()]);
}

render();
window.addEventListener('resize', render);
</script>
</body>
</html>

预期结果:页面出现一张铺满画布的平滑渐变图。左上角红、绿分量最低,向右红色逐渐增强,向下绿色逐渐增强,蓝色分量基本保持不变。示例不输出固定的控制台日志;成功渲染的直接证据是 Canvas 上的渐变画面。

这里使用一个覆盖整个视口的超大三角形,两遍都执行 draw(3)。第二遍虽然使用相同的顶点着色器,却通过 displayMain 对离屏纹理进行采样,因此显示通道不需要重新计算第一遍的颜色。

验证中间结果是否正确复用

仅看到渐变还不够,需要确认画面确实经过了离屏纹理,而不是第一遍直接写入了 Canvas。可以按以下顺序检查:

  1. 在 displayMain 中,将返回表达式改为 vec4f(textureSample(source, sampling, input.uv).rgb * 0.5, 1.0)。刷新页面后,整张渐变应明显变暗,第一遍的 sceneMain 无需修改。
  2. 恢复原始采样表达式,缩小或放大浏览器窗口。画布应维持完整渐变,纹理尺寸随实际绘图像素变化。
  3. 在浏览器开发者工具中检查控制台,正常情况下不应出现 GPU 验证错误、纹理用途不匹配或无效绑定组错误。

第二项验证依赖示例中的尺寸更新逻辑:只有像素尺寸改变时才销毁旧离屏纹理,创建新的 GPUTexture,并重新建立采样 BindGroup。若尺寸未改变,后续调用 render() 将复用相同的纹理对象和绑定组。

在实际动画中,可以使用 requestAnimationFrame() 每帧调用 render(),但不应该每帧无条件执行 createTexture()。例如 1280×720 的 RGBA8 离屏颜色纹理,重复分配既会增加资源管理负担,也可能造成显存占用波动。

处理附件、采样和生命周期错误

离屏纹理具备两种用途,并不意味着两种用途能在任何时候同时使用。以下几个边界直接影响多通道渲染的正确性。

常见问题 原因 修正方式
创建纹理后无法作为附件使用 缺少 RENDER_ATTACHMENT 创建时合并用途标志
采样绑定失败 缺少 TEXTURE_BINDING 添加纹理采样用途
管线与附件格式不匹配 颜色目标格式不同 分别匹配离屏格式和 Canvas 格式
第二遍读取结果不确定 第一遍使用 storeOp: 'discard' 使用 storeOp: 'store'
缩放后纹理视图失效 仍绑定旧纹理视图 重新创建纹理和 BindGroup

还要区分单采样与多重采样纹理。本例采用 sampleCount: 1,因此可以使用 texture_2d<f32> 和 textureSample() 直接读取。如果第一遍改用四倍 MSAA,通常应另外配置单采样的解析目标,通过颜色附件的 resolveTarget 保存可供第二遍采样的结果,而不是将多重采样附件直接绑定给普通 texture_2d<f32>。

对于真正需要跨多帧保留历史颜色的效果,例如拖尾或时间累积,还需要调整清除策略。当前示例每次以 loadOp: 'clear' 开始第一遍绘制,因此复用的是纹理资源本身,并不是把上一帧画面不断叠加。历史帧反馈通常需要两张纹理轮换,避免当前帧读取与写入同一资源时产生冲突。

完成这些检查后,离屏 GPUTexture 就可以作为后处理、颜色校正或多通道合成的中间输入:前一遍渲染负责生成纹理内容,后一遍通过采样使用结果,纹理只在尺寸或配置发生变化时重新分配。

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

目录与阅读设置

阅读设置

17

记录一个想法

离屏渲染到可复用纹理

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

登录哪都通