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 统一管理。

WebGL 2 四类模块的资源关系与渲染状态边界

一个 Mesh 可以被多个场景对象共享,同一个 ShaderProgram 也可以服务不同纹理。场景对象只需要引用这些资源,并保存自己的位置、材质参数等实例数据。

按依赖顺序初始化场景

初始化应当先完成 CPU 侧数据准备,再创建 GPU 对象,最后启动绘制。不要在异步纹理仍未加载完成时直接调用依赖该纹理的渲染逻辑。

推荐执行顺序如下:

  1. 获取 Canvas 的 WebGL 2 上下文,检查 getContext('webgl2') 是否返回有效对象。
  2. 创建 ShaderProgram,调用 createShader()、compileShader()、createProgram() 和 linkProgram(),检查编译与链接结果。
  3. 创建 Mesh,上传顶点和索引,配置 vertexAttribPointer(),将布局记录到 VAO。
  4. 创建 Texture,通过 texImage2D() 上传像素并设置纹理过滤参数。
  5. 确认所有必需资源就绪,创建 Renderer 并开始绘制。

如果纹理来自远程图片,应先等待图片下载和解码完成,再上传 GPU;也可以先上传有效的占位纹理,等真实图片准备好后替换。

对静态资源,Shader 编译、网格上传和纹理创建通常只执行一次。每帧主要更新 Uniform、资源绑定和绘制命令,不需要重新创建 VAO 或 WebGLProgram。

实现最小资源封装与双层绘制

下面的 JavaScript 可直接粘贴到支持 WebGL 2 的浏览器开发者工具 Console 中执行。它会创建一个 640×360 Canvas,绘制蓝色不透明方块和橙色半透明方块,并演示四类模块之间的协作。

js
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 错误时):

text
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 统一负责。保持这两个边界,才能在增加渲染对象和切换场景时,准确判断问题来自资源内容、绑定关系还是绘制状态。

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

目录与阅读设置

阅读设置

17

记录一个想法

拆分程序资源与渲染状态管理

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

登录哪都通