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 生成示例
在支持 WebGPU 的 Chrome 或 Edge 中,将下方代码保存为 mipmap.html。从文件所在目录执行 python3 -m http.server 8000,访问 http://localhost:8000/mipmap.html;localhost 可作为安全上下文。程序生成一张高频黑白噪声纹理,再以 64×64 的实际绘图尺寸显示左右两种采样方式。
<!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>预期输出(浏览器控制台):
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、降采样遍数是否为层数减一,以及显示时是否真的使用允许访问完整层级的视图。