Web 图形与 3D / 系统课时

应用模型矩阵摆放场景对象

应用模型矩阵摆放场景对象

同一份顶点数据可以在场景中生成多个位置、大小和方向各不相同的对象。本篇使用 4×4 模型矩阵组合缩放、旋转与平移,并通过 WebGPU Uniform 为每个对象提供独立变换,最终让两个共享几何数据的三角形显示在不同位置。

学习目标

  • 理解局部坐标、世界坐标与模型矩阵之间的关系。
  • 按正确顺序组合平移、旋转和缩放矩阵,并计算顶点变换结果。
  • 使用 WGSL Uniform 和 BindGroup 为多个对象应用独立模型矩阵。

从局部坐标摆放场景对象

假设需要在同一场景中绘制两个三角形。如果直接修改原始顶点数组,就必须为每个对象准备一份不同的坐标数据。当对象数量增加,或者对象需要连续运动时,这种做法会产生大量重复计算。

更合适的方式是让所有对象共享一份局部坐标,再使用各自的模型矩阵计算最终位置。

本例使用一个以原点附近为中心的三角形,三个顶点分别为:

  • 顶点 A:(0.00, 0.45, 0.00)。
  • 顶点 B:(-0.40, -0.30, 0.00)。
  • 顶点 C:(0.40, -0.30, 0.00)。

这些坐标描述对象自身的几何形状,不包含它应该出现在场景中的哪个位置。

模型矩阵通常记为 MM,对于齐次坐标表示的顶点,有:

pworld=Mplocalp_{world}=M p_{local}

其中,plocalp_{local} 是局部空间顶点,pworldp_{world} 是世界空间顶点。实际计算使用四维列向量 (x, y, z, 1),最后的 1 让平移能够参与矩阵乘法。

本例暂时不引入相机,将变换后的坐标直接用于裁剪空间,方便观察模型矩阵的效果。因此两个对象都放在可见范围内,且暂不启用深度测试。

按正确顺序组合变换矩阵

模型矩阵通常由三个基本矩阵组成:

  • 缩放矩阵 S:改变对象在 X、Y、Z 方向上的尺寸。
  • 旋转矩阵 R:围绕指定坐标轴改变对象朝向。
  • 平移矩阵 T:将对象移动到场景中的目标位置。

采用列向量约定时,如果希望先围绕局部原点缩放,再旋转,最后移动到目标位置,应写成:

M=TRSM=T R S

矩阵乘法从右向左作用于顶点。因此,虽然公式先写 T,但实际执行顺序是 S、R、T。

下面为两个对象分别指定一组变换参数:

参数 对象 A 对象 B
平移 (x, y, z) (-0.55, 0, 0) (0.45, 0.15, 0)
Z 轴旋转 +30° -45°
缩放 (sx, sy, sz) (0.8, 0.8, 1) (0.45, 0.9, 1)
显示颜色 青绿色 暖橙色

两个对象使用完全相同的三角形顶点,但分别计算 MAM_A 和 MBM_B。对象 A 等比缩小并逆时针旋转,对象 B 则经过非等比缩放和顺时针旋转。

局部顶点通过缩放旋转平移生成两个独立场景对象的模型矩阵数据流

用具体顶点检查变换顺序

以对象 A 的顶部顶点 (0, 0.45, 0) 为例,可以逐步计算:

  1. 缩放 0.8 后得到 (0, 0.36, 0)。
  2. 绕 Z 轴旋转 30° 后,约为 (-0.180, 0.312, 0)。
  3. 平移 (-0.55, 0, 0) 后,约为 (-0.730, 0.312, 0)。

如果把矩阵顺序错误地写成 M=SRTM=SRT,平移向量也会受到旋转和缩放影响,最终位置便不再是预期的目标位置。

使用 Uniform 应用独立模型矩阵

在 WebGPU 中,可以通过 mat4x4f 保存每个对象的模型矩阵,再使用 Uniform Buffer 将它传入顶点着色器。

本例使用一个完整的 HTML 文件运行 WebGPU,不依赖外部矩阵库。顶点数据直接写在 WGSL 着色器中,避免顶点缓冲区的配置分散对模型变换的注意力。

每个对象的 Uniform 包含:

  • model:16 个 f32,占 64 字节。
  • color:4 个 f32,占 16 字节。
  • 合计 80 字节,满足本例 WGSL 结构体的布局要求。

JavaScript 侧使用列主序组织矩阵,平移分量分别放在数组索引 12、13、14。两个对象分别创建 80 字节的 Uniform Buffer,因此不需要使用动态 Uniform 偏移。

将下面的完整代码保存为 index.html:

html
<!doctype html>
<html lang='zh-CN'>
<head>
  <meta charset='UTF-8'>
  <title>WebGPU 模型矩阵</title>
</head>
<body>
  <canvas id='scene' width='600' height='600'></canvas>
  <p id='status'></p>
  <script type='module'>
    const status = document.querySelector('#status');

    async function main() {
      if (!navigator.gpu) {
        throw new Error('当前浏览器不支持 WebGPU');
      }

      const adapter = await navigator.gpu.requestAdapter();
      if (!adapter) throw new Error('无法获取 GPUAdapter');
      const device = await adapter.requestDevice();

      const canvas = document.querySelector('#scene');
      const context = canvas.getContext('webgpu');
      if (!context) throw new Error('无法获取 WebGPU 画布上下文');

      const format = navigator.gpu.getPreferredCanvasFormat();
      context.configure({ device, format, alphaMode: 'opaque' });

      const shader = device.createShaderModule({
        code: `
          struct ObjectData {
            model: mat4x4f,
            color: vec4f,
          };

          @group(0) @binding(0)
          var<uniform> object: ObjectData;

          struct VertexOutput {
            @builtin(position) position: vec4f,
            @location(0) color: vec4f,
          };

          @vertex
          fn vs(@builtin(vertex_index) index: u32) -> VertexOutput {
            let positions = array<vec3f, 3>(
              vec3f(0.0, 0.45, 0.0),
              vec3f(-0.40, -0.30, 0.0),
              vec3f(0.40, -0.30, 0.0)
            );

            var out: VertexOutput;
            // 局部顶点通过当前对象的模型矩阵变换。
            out.position = object.model * vec4f(positions[index], 1.0);
            out.color = object.color;
            return out;
          }

          @fragment
          fn fs(input: VertexOutput) -> @location(0) vec4f {
            return input.color;
          }
        `,
      });

      const pipeline = device.createRenderPipeline({
        layout: 'auto',
        vertex: { module: shader, entryPoint: 'vs' },
        fragment: {
          module: shader,
          entryPoint: 'fs',
          targets: [{ format }],
        },
        primitive: { topology: 'triangle-list' },
      });

      function identity() {
        return new Float32Array([
          1, 0, 0, 0,
          0, 1, 0, 0,
          0, 0, 1, 0,
          0, 0, 0, 1,
        ]);
      }

      function translate(x, y, z) {
        const m = identity();
        // 列主序矩阵的第四列存储平移分量。
        m[12] = x;
        m[13] = y;
        m[14] = z;
        return m;
      }

      function scale3(x, y, z) {
        const m = identity();
        m[0] = x;
        m[5] = y;
        m[10] = z;
        return m;
      }

      function rotateZ(angle) {
        const m = identity();
        const c = Math.cos(angle);
        const s = Math.sin(angle);
        m[0] = c;
        m[1] = s;
        m[4] = -s;
        m[5] = c;
        return m;
      }

      function multiply(a, b) {
        const out = new Float32Array(16);
        // 按列主序计算 a × b,不交换乘法顺序。
        for (let col = 0; col < 4; col++) {
          for (let row = 0; row < 4; row++) {
            for (let k = 0; k < 4; k++) {
              out[col * 4 + row] +=
                a[k * 4 + row] * b[col * 4 + k];
            }
          }
        }
        return out;
      }

      const objects = [
        {
          x: -0.55, y: 0, angle: Math.PI / 6,
          sx: 0.8, sy: 0.8,
          color: [0.08, 0.62, 0.58, 1],
        },
        {
          x: 0.45, y: 0.15, angle: -Math.PI / 4,
          sx: 0.45, sy: 0.9,
          color: [0.92, 0.48, 0.22, 1],
        },
      ];

      const bindGroups = objects.map((obj) => {
        // M = T × R × S:先缩放,再旋转,最后平移。
        const model = multiply(
          translate(obj.x, obj.y, 0),
          multiply(
            rotateZ(obj.angle),
            scale3(obj.sx, obj.sy, 1)
          )
        );

        const data = new Float32Array(20);
        data.set(model, 0);
        data.set(obj.color, 16);

        const buffer = device.createBuffer({
          size: data.byteLength,
          usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
        });
        device.queue.writeBuffer(buffer, 0, data);

        return device.createBindGroup({
          layout: pipeline.getBindGroupLayout(0),
          entries: [{ binding: 0, resource: { buffer } }],
        });
      });

      const encoder = device.createCommandEncoder();
      const pass = encoder.beginRenderPass({
        colorAttachments: [{
          view: context.getCurrentTexture().createView(),
          clearValue: { r: 0.98, g: 0.99, b: 1, a: 1 },
          loadOp: 'clear',
          storeOp: 'store',
        }],
      });

      pass.setPipeline(pipeline);

      // 几何数据和管线共享,仅切换对象绑定组。
      for (const group of bindGroups) {
        pass.setBindGroup(0, group);
        pass.draw(3);
      }

      pass.end();
      device.queue.submit([encoder.finish()]);
      status.textContent = '已提交两个独立模型矩阵的绘制命令';
    }

    main().catch((error) => {
      status.textContent = `运行失败:${error.message}`;
      console.error(error);
    });
  </script>
</body>
</html>

预期结果:在支持 WebGPU 的浏览器中加载该页面后,画布左侧显示一个经过等比缩放和逆时针旋转的青绿色三角形,右侧显示一个较窄、顺时针旋转的暖橙色三角形。两个三角形来自相同的局部顶点数组,页面下方显示已提交绘制命令的提示。

这里的两次 pass.draw(3) 共用同一个 RenderPipeline,但每次绘制前通过 setBindGroup(0, group) 切换对象数据。

这种方式把对象的几何结构与其空间变换分开:修改某个对象的平移、旋转或缩放参数,只需要更新它自己的矩阵,不需要修改 WGSL 的局部顶点定义。

运行并验证变换结果

WebGPU 需要安全上下文。开发时可以通过 localhost 运行页面,而不是直接依赖本地文件地址。

确保已经安装 Python 3,在 index.html 所在目录执行:

bash
python3 -m http.server 8000

预期输出(实际监听地址可能因系统而不同):

text
Serving HTTP on <HOST> port 8000 ...

其中 <HOST> 代表实际监听地址。保持服务器运行,在支持 WebGPU 的浏览器中访问 http://localhost:8000/。

核对两个对象的变换

可以按以下顺序检查:

  1. 确认画布上有两个三角形,而不是重叠在原点的一个三角形。
  2. 将对象 A 的 x 从 -0.55 改成 -0.30 并刷新页面。只有青绿色三角形应向右移动。
  3. 将对象 B 的 angle 改成 0 并刷新页面。暖橙色三角形应恢复为未旋转方向,其非等比缩放仍然保留。
  4. 将对象 B 的 sx 从 0.45 改成 0.80。它应明显变宽,而对象 A 保持不变。

这些变化验证了模型矩阵的三个基本职责:平移控制位置、旋转控制朝向、缩放控制尺寸。

如果两个对象总是使用相同的变换,优先检查循环中是否真的调用了 pass.setBindGroup(0, group)。只更新 CPU 内存中的数组,不调用 device.queue.writeBuffer(),也不会自动改变 GPU 缓冲区的数据。

如果平移后出现错误方向或意外缩放,检查 multiply(a, b) 的乘法顺序,以及平移值是否位于列主序数组的 12、13、14 位置。不要直接把按行主序填充的矩阵数据当作 WGSL 的 mat4x4f 上传。

当前示例为了隔离模型矩阵的作用,没有加入观察矩阵和投影矩阵。接入三维相机后,顶点着色器应按投影、观察、模型的顺序组合变换,即先由模型矩阵得到世界空间位置,再转换到观察空间和裁剪空间。多个对象仍然可以共享几何数据与绘制管线,只保留各自独立的模型矩阵。

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

目录与阅读设置

阅读设置

17

记录一个想法

应用模型矩阵摆放场景对象

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

登录哪都通