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。为便于观察立体表面,片元着色器根据位置导数计算面法线,并加入简单方向光。
<!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 显示:
objects=2, sharedMesh=true, sharedProgram=true一次 draw 调用改动了哪些状态
RenderObject.draw(vp) 按固定次序完成一次提交,不重新创建缓冲区,也不重新链接 Program。
- 从本实例 Transform 生成
uModel,将局部顶点转换到世界空间。 Material.bind()激活共享 Program,并写入该材质的uColor。- 写入相机的
uVP和本实例的uModel;每次uniformMatrix4fv都作用于当前 Program。 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。