Web 图形与 3D / 系统课时

把网格材质封装为渲染对象

把网格材质封装为渲染对象

同一个立方体在场景中出现两次时,不必重复上传顶点,也不必编译两套着色器。把 Mesh、Material 和 Transform 组合成渲染对象后,可以共享 GPU 资源,同时独立设置每个实例的颜色、位置与旋转,并统一调用绘制方法。

学习目标

  • 区分 Mesh、Program、Material、Transform 和渲染对象的职责。
  • 编写可复用的 WebGL 2 渲染对象,绘制两个共享网格的立方体。
  • 检查 Uniform、VAO 的绑定顺序,正确管理共享资源的生命周期。

哪些数据应该共享

Mesh 保存几何数据及其 GPU 句柄:VAO 记录顶点属性布局和索引缓冲绑定,VBO 保存位置,EBO 保存三角形索引。Program 保存链接后的着色器程序及 Uniform 位置。它们通常由多个对象共同引用。

部件 本例存储内容 共享策略
Mesh VAO、VBO、EBO、索引数量 两个立方体共用一份
Program WebGLProgram、uVP/uModel/uColor 位置 两种颜色共用一个
Material Program 引用、颜色参数 颜色不同则各建一份
Transform 位置、Y 轴旋转、统一缩放 每个实例独立
RenderObject Mesh、Material、Transform 的引用 一个场景实例对应一个

两个渲染对象共享网格与着色器的结构

完整实现:一份 Mesh 绘制两次

将以下内容保存为 index.html,用支持 WebGL 2 的浏览器打开。示例的立方体使用 8 个位置顶点和 36 个索引;两个 RenderObject 共享同一个 VAO、VBO、EBO 和 Program。为便于观察立体表面,片元着色器根据位置导数计算面法线,并加入简单方向光。

html
<!doctype html>
<html lang='zh-CN'>
<head><meta charset='utf-8'><title>RenderObject 示例</title></head>
<body>
<canvas id='stage' width='800' height='450'></canvas>
<script>
const canvas = document.getElementById('stage');
const gl = canvas.getContext('webgl2');
if (!gl) throw new Error('浏览器无法创建 WebGL 2 上下文');

const vertexSource = `#version 300 es
layout(location = 0) in vec3 aPosition;
uniform mat4 uVP;
uniform mat4 uModel;
out vec3 vWorld;
void main() {
  vec4 world = uModel * vec4(aPosition, 1.0);
  vWorld = world.xyz;
  gl_Position = uVP * world;
}`;

const fragmentSource = `#version 300 es
precision highp float;
in vec3 vWorld;
uniform vec3 uColor;
out vec4 fragColor;
void main() {
  vec3 n = normalize(cross(dFdx(vWorld), dFdy(vWorld)));
  float light = max(dot(n, normalize(vec3(0.4, 0.7, 0.6))), 0.0);
  fragColor = vec4(uColor * (0.45 + 0.55 * light), 1.0);
}`;

function compile(type, source) {
  const shader = gl.createShader(type);
  gl.shaderSource(shader, source);
  gl.compileShader(shader);
  if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
    throw new Error(gl.getShaderInfoLog(shader));
  }
  return shader;
}

function createProgram() {
  const vs = compile(gl.VERTEX_SHADER, vertexSource);
  const fs = compile(gl.FRAGMENT_SHADER, fragmentSource);
  const handle = gl.createProgram();
  gl.attachShader(handle, vs);
  gl.attachShader(handle, fs);
  gl.linkProgram(handle);
  gl.deleteShader(vs);
  gl.deleteShader(fs);
  if (!gl.getProgramParameter(handle, gl.LINK_STATUS)) {
    throw new Error(gl.getProgramInfoLog(handle));
  }
  return {
    handle,
    uVP: gl.getUniformLocation(handle, 'uVP'),
    uModel: gl.getUniformLocation(handle, 'uModel'),
    uColor: gl.getUniformLocation(handle, 'uColor')
  };
}

class Mesh {
  constructor(positions, indices) {
    this.vao = gl.createVertexArray();
    this.vbo = gl.createBuffer();
    this.ebo = gl.createBuffer();
    this.indexCount = indices.length;

    // 先绑定 VAO,再设置属性布局和索引缓冲。
    gl.bindVertexArray(this.vao);
    gl.bindBuffer(gl.ARRAY_BUFFER, this.vbo);
    gl.bufferData(gl.ARRAY_BUFFER, new Float32Array(positions), gl.STATIC_DRAW);
    gl.enableVertexAttribArray(0);
    gl.vertexAttribPointer(0, 3, gl.FLOAT, false, 0, 0);
    gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, this.ebo);
    gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, new Uint16Array(indices), gl.STATIC_DRAW);
    gl.bindVertexArray(null);
  }
  draw() {
    gl.bindVertexArray(this.vao);
    gl.drawElements(gl.TRIANGLES, this.indexCount, gl.UNSIGNED_SHORT, 0);
  }
  dispose() {
    gl.deleteVertexArray(this.vao);
    gl.deleteBuffer(this.vbo);
    gl.deleteBuffer(this.ebo);
  }
}

class Material {
  constructor(program, color) {
    this.program = program;
    this.color = new Float32Array(color);
  }
  bind() {
    gl.useProgram(this.program.handle);
    gl.uniform3fv(this.program.uColor, this.color);
  }
}

class RenderObject {
  constructor(mesh, material, transform) {
    this.mesh = mesh;
    this.material = material;
    this.transform = transform;
  }
  draw(vp) {
    // Model 矩阵按实例计算,不能存进共享 Mesh。
    const { position, rotationY, scale } = this.transform;
    const c = Math.cos(rotationY);
    const s = Math.sin(rotationY);
    const model = new Float32Array([
      c * scale, 0, -s * scale, 0,
      0, scale, 0, 0,
      s * scale, 0, c * scale, 0,
      position[0], position[1], position[2], 1
    ]);
    this.material.bind();
    gl.uniformMatrix4fv(this.material.program.uVP, false, vp);
    gl.uniformMatrix4fv(this.material.program.uModel, false, model);
    this.mesh.draw();
  }
}

// WebGL 矩阵使用列主序;结果按 P * V * M 变换。
function multiply(a, b) {
  const out = new Float32Array(16);
  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;
}

function perspective(fov, aspect, near, far) {
  const f = 1 / Math.tan(fov / 2);
  const nf = 1 / (near - far);
  return new Float32Array([
    f / aspect, 0, 0, 0,
    0, f, 0, 0,
    0, 0, (far + near) * nf, -1,
    0, 0, 2 * far * near * nf, 0
  ]);
}

const positions = [
  -0.5, -0.5, -0.5,  0.5, -0.5, -0.5,
   0.5,  0.5, -0.5, -0.5,  0.5, -0.5,
  -0.5, -0.5,  0.5,  0.5, -0.5,  0.5,
   0.5,  0.5,  0.5, -0.5,  0.5,  0.5
];
const indices = [
  4, 5, 6, 4, 6, 7,  1, 0, 3, 1, 3, 2,
  3, 7, 6, 3, 6, 2,  0, 1, 5, 0, 5, 4,
  5, 1, 2, 5, 2, 6,  0, 4, 7, 0, 7, 3
];

const mesh = new Mesh(positions, indices);
const program = createProgram();
const objects = [
  new RenderObject(mesh, new Material(program, [0.12, 0.42, 0.95]),
    { position: [-0.9, 0, 0], rotationY: 0.5, scale: 1 }),
  new RenderObject(mesh, new Material(program, [1.0, 0.5, 0.2]),
    { position: [0.9, 0, 0], rotationY: -0.65, scale: 1 })
];

gl.viewport(0, 0, canvas.width, canvas.height);
gl.enable(gl.DEPTH_TEST);
gl.enable(gl.CULL_FACE);
gl.clearColor(0.96, 0.97, 0.99, 1);
gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT);
const view = new Float32Array([
  1, 0, 0, 0,  0, 1, 0, 0,
  0, 0, 1, 0,  0, 0, -4, 1
]);
const vp = multiply(
  perspective(Math.PI / 3, canvas.width / canvas.height, 0.1, 100),
  view
);
for (const object of objects) object.draw(vp);
console.log(`objects=${objects.length}, sharedMesh=${objects[0].mesh === objects[1].mesh}, sharedProgram=${objects[0].material.program === objects[1].material.program}`);
</script>
</body>
</html>

预期结果:白灰色画布上出现左蓝右橙两个有明暗面的立方体;浏览器开发者工具 Console 显示:

text
objects=2, sharedMesh=true, sharedProgram=true

一次 draw 调用改动了哪些状态

RenderObject.draw(vp) 按固定次序完成一次提交,不重新创建缓冲区,也不重新链接 Program。

  1. 从本实例 Transform 生成 uModel,将局部顶点转换到世界空间。
  2. Material.bind() 激活共享 Program,并写入该材质的 uColor。
  3. 写入相机的 uVP 和本实例的 uModel;每次 uniformMatrix4fv 都作用于当前 Program。
  4. Mesh.draw() 绑定它的 VAO,再由 drawElements 按 36 个索引绘制三角形。

本例绘制一帧会发出 2 次 Draw Call,但几何 GPU 资源仅创建 1 份。uVP 对两个物体相同,示例为简明而重复上传;对象较多时可按 Program 分组,在切换 Program 时上传一次帧级 Uniform,再逐个上传 uModel 和材质参数。

检查封装边界与释放时机

首先确认 Console 的两项共享检查都是 true。然后只把右侧对象的 position 改为 [1.3, 0, 0],重新加载页面:只有橙色立方体移动;只修改右侧 Material 的颜色数组,蓝色立方体也不会变色。这证明实例状态未被意外放入共享 Mesh。

检查两个容易遗漏的细节:

  • ELEMENT_ARRAY_BUFFER 的绑定属于当前 VAO 状态。设置 EBO 后先解绑 VAO;若在 VAO 仍绑定时把 EBO 解绑,后续 drawElements 会缺少索引缓冲。
  • Uniform 位置属于创建它的 Program。若更换 Material 的 Program,必须使用新 Program 的位置,不能拿另一个 Program 的 uModel 位置更新。

这个封装可以把普通独立网格对象的资源和实例状态清晰分开。实例数量显著增加时,先按 Program 和 Material 排序、减少重复状态切换;对大量相同网格再考虑 WebGL 2 的实例化绘制,而不是为每个实例新建一份 VBO。

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

目录与阅读设置

阅读设置

17

记录一个想法

把网格材质封装为渲染对象

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

登录哪都通