Web 图形与 3D / 系统课时
拆分程序资源与渲染状态管理
拆分程序资源与渲染状态管理
多个物体共用 WebGL 2 上下文时,纹理绑定、混合开关和深度写入状态会在绘制调用之间保留。本课将着色器程序、网格、纹理和渲染器拆成独立模块,通过可运行的双层方块示例,明确 GPU 资源的创建、绘制、状态恢复和释放边界。
学习目标
- 划分 ShaderProgram、Mesh、Texture 和 Renderer 的职责及资源所有权。
- 按正确顺序初始化 GPU 资源,避免未就绪资源参与绘制。
- 集中控制混合、深度测试和资源绑定,排查跨对象的渲染状态污染。
四类对象分别负责什么
WebGL 2 使用有状态的 WebGL2RenderingContext。执行 gl.useProgram()、gl.bindTexture() 或 gl.enable() 后,对应状态会持续生效,直到后续调用修改它。
如果每个游戏对象自行创建资源、设置状态和调用绘制,很容易出现前一个透明物体影响后一个不透明物体的问题。
推荐按以下职责拆分:
| 模块 | 持有的主要资源 | 负责的操作 | 不应该负责 |
|---|---|---|---|
| ShaderProgram | WebGLProgram、Uniform 位置 | 编译、链接、激活、释放程序 | 决定透明绘制顺序 |
| Mesh | VAO、VBO、EBO、索引数量 | 上传顶点和索引、绑定顶点布局 | 修改混合和深度状态 |
| Texture | WebGLTexture | 上传像素、配置采样、绑定纹理单元 | 决定绘制顺序 |
| Renderer | WebGL2 上下文及资源引用 | 组织绘制、设置状态、调用 drawElements | 每帧重新创建静态网格 |
其中 VAO 保存顶点属性配置及索引缓冲区绑定关系,但不会保存 BLEND、DEPTH_TEST 等全局绘制状态。后者应由 Renderer 统一管理。

一个 Mesh 可以被多个场景对象共享,同一个 ShaderProgram 也可以服务不同纹理。场景对象只需要引用这些资源,并保存自己的位置、材质参数等实例数据。
按依赖顺序初始化场景
初始化应当先完成 CPU 侧数据准备,再创建 GPU 对象,最后启动绘制。不要在异步纹理仍未加载完成时直接调用依赖该纹理的渲染逻辑。
推荐执行顺序如下:
- 获取 Canvas 的 WebGL 2 上下文,检查
getContext('webgl2')是否返回有效对象。 - 创建 ShaderProgram,调用
createShader()、compileShader()、createProgram()和linkProgram(),检查编译与链接结果。 - 创建 Mesh,上传顶点和索引,配置
vertexAttribPointer(),将布局记录到 VAO。 - 创建 Texture,通过
texImage2D()上传像素并设置纹理过滤参数。 - 确认所有必需资源就绪,创建 Renderer 并开始绘制。
如果纹理来自远程图片,应先等待图片下载和解码完成,再上传 GPU;也可以先上传有效的占位纹理,等真实图片准备好后替换。
对静态资源,Shader 编译、网格上传和纹理创建通常只执行一次。每帧主要更新 Uniform、资源绑定和绘制命令,不需要重新创建 VAO 或 WebGLProgram。
实现最小资源封装与双层绘制
下面的 JavaScript 可直接粘贴到支持 WebGL 2 的浏览器开发者工具 Console 中执行。它会创建一个 640×360 Canvas,绘制蓝色不透明方块和橙色半透明方块,并演示四类模块之间的协作。
const canvas = document.createElement('canvas');
canvas.width = 640;
canvas.height = 360;
document.body.append(canvas);
const gl = canvas.getContext('webgl2', { depth: true, alpha: false });
if (!gl) throw new Error('当前环境不支持 WebGL 2');
class ShaderProgram {
constructor(gl, vertexSource, fragmentSource) {
this.gl = gl;
const compile = (type, source) => {
const shader = gl.createShader(type);
gl.shaderSource(shader, source);
gl.compileShader(shader);
if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
const message = gl.getShaderInfoLog(shader);
gl.deleteShader(shader);
throw new Error(message);
}
return shader;
};
const vertex = compile(gl.VERTEX_SHADER, vertexSource);
let fragment;
let program;
try {
fragment = compile(gl.FRAGMENT_SHADER, fragmentSource);
program = gl.createProgram();
gl.attachShader(program, vertex);
gl.attachShader(program, fragment);
gl.linkProgram(program);
if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
throw new Error(gl.getProgramInfoLog(program));
}
this.handle = program;
this.uOffset = gl.getUniformLocation(program, 'uOffset');
this.uTexture = gl.getUniformLocation(program, 'uTexture');
} catch (error) {
if (program) gl.deleteProgram(program);
throw error;
} finally {
// 链接完成后,独立Shader对象可以释放。
gl.deleteShader(vertex);
if (fragment) gl.deleteShader(fragment);
}
}
use() { this.gl.useProgram(this.handle); }
dispose() { this.gl.deleteProgram(this.handle); }
}
class Mesh {
constructor(gl) {
this.gl = gl;
this.vao = gl.createVertexArray();
this.vbo = gl.createBuffer();
this.ebo = gl.createBuffer();
const vertices = new Float32Array([
-0.5, -0.5, 0, 0, 0,
0.5, -0.5, 0, 1, 0,
0.5, 0.5, 0, 1, 1,
-0.5, 0.5, 0, 0, 1
]);
const indices = new Uint16Array([0, 1, 2, 0, 2, 3]);
this.indexCount = indices.length;
gl.bindVertexArray(this.vao);
gl.bindBuffer(gl.ARRAY_BUFFER, this.vbo);
gl.bufferData(gl.ARRAY_BUFFER, vertices, gl.STATIC_DRAW);
gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, this.ebo);
gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, indices, gl.STATIC_DRAW);
// 每个顶点包含3个位置分量和2个UV分量。
gl.vertexAttribPointer(0, 3, gl.FLOAT, false, 20, 0);
gl.enableVertexAttribArray(0);
gl.vertexAttribPointer(1, 2, gl.FLOAT, false, 20, 12);
gl.enableVertexAttribArray(1);
gl.bindVertexArray(null);
gl.bindBuffer(gl.ARRAY_BUFFER, null);
}
bind() { this.gl.bindVertexArray(this.vao); }
dispose() {
this.gl.deleteVertexArray(this.vao);
this.gl.deleteBuffer(this.vbo);
this.gl.deleteBuffer(this.ebo);
}
}
class Texture {
constructor(gl, rgba) {
this.gl = gl;
this.handle = gl.createTexture();
this.bind(0);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
// 使用1×1像素,避免依赖外部图片资源。
gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, 1, 1, 0,
gl.RGBA, gl.UNSIGNED_BYTE, new Uint8Array(rgba));
gl.bindTexture(gl.TEXTURE_2D, null);
}
bind(unit) {
this.gl.activeTexture(this.gl.TEXTURE0 + unit);
this.gl.bindTexture(this.gl.TEXTURE_2D, this.handle);
}
dispose() { this.gl.deleteTexture(this.handle); }
}
class Renderer {
constructor(gl, program, mesh) {
this.gl = gl;
this.program = program;
this.mesh = mesh;
}
draw(texture, x, y, z) {
const gl = this.gl;
this.program.use();
this.mesh.bind();
texture.bind(0);
gl.uniform1i(this.program.uTexture, 0);
gl.uniform3f(this.program.uOffset, x, y, z);
gl.drawElements(gl.TRIANGLES, this.mesh.indexCount,
gl.UNSIGNED_SHORT, 0);
}
render(opaque, transparent) {
const gl = this.gl;
gl.bindFramebuffer(gl.FRAMEBUFFER, null);
gl.viewport(0, 0, gl.drawingBufferWidth, gl.drawingBufferHeight);
gl.disable(gl.SCISSOR_TEST);
gl.disable(gl.CULL_FACE);
gl.colorMask(true, true, true, true);
gl.enable(gl.DEPTH_TEST);
gl.depthFunc(gl.LESS);
gl.depthMask(true);
gl.disable(gl.BLEND);
gl.clearColor(0.96, 0.97, 1.0, 1.0);
gl.clearDepth(1);
gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT);
try {
// 不透明物体先绘制,并写入深度缓冲。
this.draw(opaque, -0.22, -0.10, 0.2);
// 透明物体参与深度测试,但不修改已有深度。
gl.enable(gl.BLEND);
gl.blendEquation(gl.FUNC_ADD);
gl.blendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA);
gl.depthMask(false);
this.draw(transparent, 0.20, 0.10, -0.2);
} finally {
// 无论绘制是否成功,都恢复约定的帧内状态。
gl.depthMask(true);
gl.disable(gl.BLEND);
gl.bindVertexArray(null);
gl.activeTexture(gl.TEXTURE0);
gl.bindTexture(gl.TEXTURE_2D, null);
gl.useProgram(null);
}
}
}
const vertexSource = `#version 300 es
layout(location = 0) in vec3 aPosition;
layout(location = 1) in vec2 aUV;
uniform vec3 uOffset;
out vec2 vUV;
void main() {
vUV = aUV;
gl_Position = vec4(aPosition + uOffset, 1.0);
}`;
const fragmentSource = `#version 300 es
precision mediump float;
in vec2 vUV;
uniform sampler2D uTexture;
out vec4 outColor;
void main() {
outColor = texture(uTexture, vUV);
}`;
const program = new ShaderProgram(gl, vertexSource, fragmentSource);
const mesh = new Mesh(gl);
const opaque = new Texture(gl, [40, 105, 220, 255]);
const transparent = new Texture(gl, [250, 140, 50, 140]);
const renderer = new Renderer(gl, program, mesh);
renderer.render(opaque, transparent);
console.log('WebGL error code:', gl.getError());
window.addEventListener('pagehide', () => {
opaque.dispose();
transparent.dispose();
mesh.dispose();
program.dispose();
}, { once: true });预期输出(正常支持 WebGL 2 且无其他 WebGL 错误时):
WebGL error code: 0页面可见结果:浅色背景上出现左侧蓝色不透明方块和右侧橙色半透明方块。重叠区域可以透过橙色看到蓝色,蓝色部分不会因为透明绘制而消失。
这里两个方块共享一个 ShaderProgram 和 Mesh,只使用不同的 Texture 与位置 Uniform。增加第三个方块时,不需要重复编译 Shader,也不需要上传相同的顶点数据。
明确绘制状态的设置与恢复边界
WebGL 的状态绑定不是函数局部变量。即使 Renderer.draw() 已经返回,BLEND、当前 Program、VAO 和纹理单元绑定仍可能保留。
因此,同一个 Renderer 负责完整一帧时,应当建立明确的状态约定。
| 绘制阶段 | BLEND | DEPTH_TEST | depthMask |
|---|---|---|---|
| 不透明物体 | 关闭 | 开启 | true |
| 普通 Alpha 透明物体 | 开启 | 开启 | false |
| 透明阶段结束后 | 关闭 | 开启 | true |
透明阶段使用 blendFunc(SRC_ALPHA, ONE_MINUS_SRC_ALPHA),适用于非预乘 Alpha 的常规颜色纹理。若纹理采用预乘 Alpha,应改用匹配的混合因子,例如 ONE 与 ONE_MINUS_SRC_ALPHA,不能混用两套约定。
普通透明物体应在不透明物体之后绘制;多个互相重叠的透明物体通常还需要按观察距离从远到近排序。示例只有一个透明方块,因此没有实现排序队列。
一个典型错误是透明物体绘制后没有恢复 depthMask(true)。下一帧的不透明物体即使启用了深度测试,也可能无法正确更新深度缓冲,导致遮挡异常。
另一种错误是把 gl.enable(gl.BLEND) 写进 Texture 类。纹理资源本身无法决定当前应使用不透明、Alpha 混合还是加法混合;这些设置属于具体绘制阶段。
示例的 Renderer 独占当前上下文,并在每次渲染开始时建立基准状态,在透明绘制结束后恢复关键状态。如果与第三方渲染库共享上下文,仅恢复这些状态还不够,应完整保存并恢复双方会修改的 GL 状态,或采用明确的上下文所有权协议。
资源释放与故障定位
WebGLBuffer、WebGLTexture 和 WebGLProgram 都是 GPU 相关资源。JavaScript 对象失去引用,不等于应用已经明确完成 GPU 资源释放。
在场景销毁、资源不再共享时,应调用对应释放方法:
- ShaderProgram:
gl.deleteProgram()。 - Mesh:
gl.deleteVertexArray()和gl.deleteBuffer()。 - Texture:
gl.deleteTexture()。
示例将这些操作封装为 dispose(),并在页面离开时调用。实际项目中,切换场景时还应按照资源所有权处理释放,避免一个场景删除仍被其他场景引用的共享 Mesh 或 Texture。可以用引用计数或集中式资源管理器记录共享资源的使用者。
出现渲染故障时,按症状缩小范围:
| 症状 | 优先检查 | 修复方向 |
|---|---|---|
| 画面全空白 | Program 链接状态、VAO、viewport | 检查 Shader 日志和顶点属性布局 |
| 第二个对象纹理错误 | 当前纹理单元及 sampler Uniform | 每次绘制显式绑定纹理和指定单元 |
| 透明物体遮挡错误 | BLEND、深度写入和绘制顺序 | 不透明先绘制,透明阶段关闭深度写入 |
| 场景反复切换后资源持续增长 | GPU 对象创建与释放次数 | 复用静态资源并补齐 dispose |
调试时可以在关键绘制阶段使用 gl.getError() 检查 GL 错误,并通过 gl.getParameter(gl.DEPTH_WRITEMASK)、gl.isEnabled(gl.BLEND) 核对实际状态。需要注意,部分画面逻辑错误不会产生 GL 错误码,仍需要结合资源绑定和绘制顺序检查。
如果发生 webglcontextlost,应暂停绘制,并在 webglcontextrestored 后重新创建 GPU 资源。旧的 GPU 句柄不能直接当作恢复后的有效资源继续使用。
资源创建由 ShaderProgram、Mesh 和 Texture 各自负责,帧内状态与绘制顺序由 Renderer 统一负责。保持这两个边界,才能在增加渲染对象和切换场景时,准确判断问题来自资源内容、绑定关系还是绘制状态。