Web 图形与 3D / 系统课时

生成 Mipmap 降低远景闪烁

生成 Mipmap 降低远景闪烁

远处物体在屏幕上只有几十个像素时,直接采样高分辨率贴图会让细节忽明忽暗。本课从一张 256×256 的纹理生成完整 Mipmap 链,设置三线性过滤,并用两个并排画布观察移动时的闪烁差异。

学习目标

  • 计算纹理的 Mipmap 层数与每层尺寸,正确设置 GPUTexture 用途。
  • 使用渲染通道从上一层降采样到下一层,避免读写同一子资源。
  • 配置采样器的三级过滤参数,验证远景采样的稳定性。

远景采样为什么需要多级纹理

假设 256×256 贴图被缩到屏幕上的 64×64 区域。一个屏幕像素大约覆盖原图 4×4 个纹素;只在原图上做双线性过滤,通常只混合附近 4 个纹素,忽略了其余高频细节,画面稍微移动就可能发生闪烁。

Mipmap 预先保存逐级缩小的图像:第 0 级为原图,第 1 级为 128×128,第 2 级为 64×64,直到第 8 级为 1×1。此时远景可读取接近屏幕采样密度的层级,降低混叠。对于宽高分别为 W、H 的常规二维纹理,完整层数为 floor(log2(max(W, H))) + 1;非 2 的幂尺寸也适用,每级宽高分别向下取整且至少为 1。

逐级生成时如何组织读写

WebGPU 不提供可直接调用的 generateMipmap()。本例创建一张 rgba8unorm 纹理,允许 COPY_DST(写入第 0 级)、TEXTURE_BINDING(在着色器中读取)和 RENDER_ATTACHMENT(把缩小结果写入其他级)。

对每个级别 i(从 1 到 8),读取视图只暴露第 i−1 级,颜色附件视图只暴露第 i 级;片元着色器在较小的目标尺寸上运行并双线性读取上一层。两者属于同一纹理的不同 mip 子资源,因此不会在同一个渲染通道内读写重叠区域。

从原图到低分辨率 Mipmap 层及远景采样的数据流

运行完整的 Mipmap 生成示例

在支持 WebGPU 的 Chrome 或 Edge 中,将下方代码保存为 mipmap.html。从文件所在目录执行 python3 -m http.server 8000,访问 http://localhost:8000/mipmap.html;localhost 可作为安全上下文。程序生成一张高频黑白噪声纹理,再以 64×64 的实际绘图尺寸显示左右两种采样方式。

html
<!doctype html>
<meta charset="utf-8">
<title>Mipmap 远景对比</title>
<style>
  canvas { width: 320px; height: 320px; image-rendering: pixelated; }
</style>
<p>左:只用第 0 级 右:完整 Mipmap</p>
<canvas id="base" width="64" height="64"></canvas>
<canvas id="mip" width="64" height="64"></canvas>
<script type="module">
if (!navigator.gpu) throw new Error('WebGPU 不可用');
const adapter = await navigator.gpu.requestAdapter();
if (!adapter) throw new Error('找不到 WebGPU 适配器');
const device = await adapter.requestDevice();
const format = navigator.gpu.getPreferredCanvasFormat();
const contexts = ['base', 'mip'].map(id => {
  const ctx = document.getElementById(id).getContext('webgpu');
  ctx.configure({ device, format, alphaMode: 'opaque' });
  return ctx;
});

// 构造无需外部图片的高频纹理,便于观察缩小时的闪烁。
const src = document.createElement('canvas');
src.width = src.height = 256;
const g = src.getContext('2d');
const pixels = g.createImageData(256, 256);
for (let p = 0; p < 256 * 256; p++) {
  const v = Math.random() < 0.5 ? 0 : 255;
  const n = p * 4;
  pixels.data[n] = pixels.data[n + 1] = pixels.data[n + 2] = v;
  pixels.data[n + 3] = 255;
}
g.putImageData(pixels, 0, 0);
const mipCount = Math.floor(Math.log2(256)) + 1;
const texture = device.createTexture({
  size: [256, 256], mipLevelCount: mipCount, format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING |
         GPUTextureUsage.RENDER_ATTACHMENT,
});
device.queue.copyExternalImageToTexture({ source: src }, { texture }, [256, 256]);

const module = device.createShaderModule({ code: `
  struct VOut { @builtin(position) pos: vec4f, @location(0) uv: vec2f }
  @vertex fn vs(@builtin(vertex_index) i: u32) -> VOut {
    let p = array<vec2f, 3>(vec2f(-1, -1), vec2f(3, -1), vec2f(-1, 3));
    var out: VOut;
    out.pos = vec4f(p[i], 0.0, 1.0);
    out.uv = p[i] * vec2f(0.5, -0.5) + vec2f(0.5, 0.5);
    return out;
  }
  @group(0) @binding(0) var s: sampler;
  @group(0) @binding(1) var t: texture_2d<f32>;
  @group(0) @binding(2) var<uniform> shift: vec2f;
  @fragment fn fs(v: VOut) -> @location(0) vec4f {
    return textureSample(t, s, v.uv + shift);
  }
` });
const makePipeline = targetFormat => device.createRenderPipeline({
  layout: 'auto', vertex: { module, entryPoint: 'vs' },
  fragment: { module, entryPoint: 'fs', targets: [{ format: targetFormat }] },
});
const mipPipeline = makePipeline('rgba8unorm');
const screenPipeline = makePipeline(format);
const sampler = device.createSampler({
  addressModeU: 'repeat', addressModeV: 'repeat',
  magFilter: 'linear', minFilter: 'linear', mipmapFilter: 'linear',
});
const shift = device.createBuffer({
  size: 8, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
});
const makeGroup = (pipeline, view) => device.createBindGroup({
  layout: pipeline.getBindGroupLayout(0),
  entries: [
    { binding: 0, resource: sampler },
    { binding: 1, resource: view },
    { binding: 2, resource: { buffer: shift } },
  ],
});

// 每一遍只从上一层采样,把结果写进当前层。
const encoder = device.createCommandEncoder();
for (let level = 1; level < mipCount; level++) {
  const readView = texture.createView({ baseMipLevel: level - 1, mipLevelCount: 1 });
  const writeView = texture.createView({ baseMipLevel: level, mipLevelCount: 1 });
  const pass = encoder.beginRenderPass({
    colorAttachments: [{ view: writeView, loadOp: 'clear', storeOp: 'store' }],
  });
  pass.setPipeline(mipPipeline);
  pass.setBindGroup(0, makeGroup(mipPipeline, readView));
  pass.draw(3);
  pass.end();
}
device.queue.submit([encoder.finish()]);
const views = [texture.createView({ mipLevelCount: 1 }), texture.createView()];
const groups = views.map(view => makeGroup(screenPipeline, view));
console.log(`Mipmap 层数:${mipCount}`);

function frame(ms) {
  // 缓慢平移 UV,观察没有预过滤时的时间混叠。
  device.queue.writeBuffer(shift, 0, new Float32Array([ms * 0.00002, 0]));
  const command = device.createCommandEncoder();
  for (let i = 0; i < contexts.length; i++) {
    const pass = command.beginRenderPass({
      colorAttachments: [{
        view: contexts[i].getCurrentTexture().createView(),
        loadOp: 'clear', storeOp: 'store',
      }],
    });
    pass.setPipeline(screenPipeline);
    pass.setBindGroup(0, groups[i]);
    pass.draw(3);
    pass.end();
  }
  device.queue.submit([command.finish()]);
  requestAnimationFrame(frame);
}
requestAnimationFrame(frame);
</script>

预期输出(浏览器控制台):

text
Mipmap 层数:9

页面可见结果:左边黑白细点随着 UV 缓慢移动而明显跳动,右边显示接近中灰的稳定纹理。这里用放大显示 64×64 画布的方式,方便分辨两者的像素差异;真实场景通常由透视投影产生类似的缩小效果。

过滤参数与工程边界

minFilter: 'linear' 负责单个 mip 内的双线性过滤;mipmapFilter: 'linear' 负责相邻 mip 之间的线性混合,合称三线性过滤;magFilter 则处理放大情况。仅配置 mipmapFilter 不会自动生成任何 mip 数据,也不能替代正确的层级数量。

本例的渲染式降采样适用于支持颜色附件的格式。若用计算着色器生成,可采用 @workgroup_size(8, 8),对 128×128 目标级调用 dispatchWorkgroups(16, 16),但纹理还必须具有 STORAGE_BINDING 用途,且格式支持存储纹理写入。无论走哪条路径,都应确保各级在首次采样前已经写满。

如果画面依然闪烁,先检查纹理视图是否覆盖全部 mip、降采样遍数是否为层数减一,以及显示时是否真的使用允许访问完整层级的视图。

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

目录与阅读设置

阅读设置

17

记录一个想法

生成 Mipmap 降低远景闪烁

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

登录哪都通