Web 图形与 3D / 系统课时

设置三角形绕序与背面剔除

设置三角形绕序与背面剔除

旋转立方体时,某个面突然消失,往往不是缓冲区丢失了顶点,而是三角形绕序与剔除状态不一致。本课通过可切换模式的 WebGL 2 示例,定位消失的面,并确认什么时候应剔除背面、什么时候需要双面绘制。

学习目标

  • 根据观察方向区分 gl.CCW 和 gl.CW,为立方体各面建立一致的绕序。
  • 正确组合 frontFace、cullFace 和 CULL_FACE,理解它们分别控制什么。
  • 运行旋转立方体,复现单面反向、全局正面定义颠倒和关闭剔除的效果。

绕序决定哪个三角形被当作正面

三角形的三个索引不仅决定连接哪些顶点,也决定方向。按投影后的窗口坐标观察,依次连接三个顶点呈逆时针为 CCW,顺时针为 CW。WebGL 默认使用 CCW 判定正面;这不是根据法线属性自动推断的。

例如从立方体的正前方看,朝向观察者的 z=+1 面可按“左下→右下→右上→左上”排列四个顶点,并拆成 (0,1,2) 和 (0,2,3) 两个逆时针三角形。若改成 (0,2,1) 和 (0,3,2),几何位置不变,但正反面判定反转。

立方体正面绕序与错误索引的对照

三个 WebGL 状态各管一件事

操作 作用 典型设置
gl.frontFace(mode) 指定哪种绕序算正面 gl.CCW(默认)或 gl.CW
gl.cullFace(mode) 指定要丢弃的面 gl.BACK(默认)、gl.FRONT、gl.FRONT_AND_BACK
gl.enable(gl.CULL_FACE) 真正开启面剔除 默认关闭;不调用就不会因绕序丢面
gl.disable(gl.CULL_FACE) 暂时关闭剔除,用于排错或双面材质 正反面都参与光栅化

常见的不透明封闭网格使用 gl.frontFace(gl.CCW)、gl.cullFace(gl.BACK) 和 gl.enable(gl.CULL_FACE)。gl.FRONT_AND_BACK 会剔除所有参与面剔除的三角形;它不等同于关闭剔除。面剔除与深度测试也是两件事:关闭 CULL_FACE 后,DEPTH_TEST 仍能遮挡后面的片元。

运行可切换绕序的旋转立方体

将下面内容保存为 culling.html,使用支持 WebGL 2 的桌面浏览器打开。示例为六个面分别存储四个顶点,总计 24 个顶点、36 个索引(12 个三角形);其中 z=+1 面单独使用红色,以便观察失效。

html
<!doctype html>
<html lang="zh-CN">
<head>
  <meta charset="utf-8">
  <title>WebGL 2 绕序与背面剔除</title>
</head>
<body>
  <label for="mode">剔除实验:</label>
  <select id="mode">
    <option value="normal">正确绕序 + 剔除背面</option>
    <option value="broken">红色面反向 + 剔除背面</option>
    <option value="double">红色面反向 + 关闭剔除</option>
    <option value="cw">全局 CW + 剔除背面</option>
    <option value="front">CCW + 剔除正面</option>
  </select>
  <p id="state"></p>
  <canvas id="canvas" width="640" height="360"></canvas>
  <script>
    const canvas = document.querySelector('#canvas');
    const gl = canvas.getContext('webgl2');
    if (!gl) throw new Error('当前环境不支持 WebGL 2');

    const vertexSource = `#version 300 es
    layout(location=0) in vec3 aPosition;
    layout(location=1) in vec3 aColor;
    uniform float uAngle;
    uniform mat4 uProjection;
    out vec3 vColor;
    void main() {
      float c = cos(uAngle), s = sin(uAngle);
      vec3 p = vec3(c*aPosition.x + s*aPosition.z,
                    aPosition.y,
                   -s*aPosition.x + c*aPosition.z);
      float t = 0.35;
      p = vec3(p.x, cos(t)*p.y - sin(t)*p.z,
                    sin(t)*p.y + cos(t)*p.z);
      p.z -= 5.0;
      gl_Position = uProjection * vec4(p, 1.0);
      vColor = aColor;
    }`;
    const fragmentSource = `#version 300 es
    precision highp float;
    in vec3 vColor;
    out vec4 fragColor;
    void main() { fragColor = vec4(vColor, 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;
    }
    const program = gl.createProgram();
    gl.attachShader(program, compile(gl.VERTEX_SHADER, vertexSource));
    gl.attachShader(program, compile(gl.FRAGMENT_SHADER, fragmentSource));
    gl.linkProgram(program);
    if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
      throw new Error(gl.getProgramInfoLog(program));
    }
    gl.useProgram(program);

    // 每个面的顶点都按从立方体外侧观察为 CCW 的顺序排列。
    const faces = [
      {v:[[-1,-1, 1],[ 1,-1, 1],[ 1, 1, 1],[-1, 1, 1]], c:[1,.25,.2]},
      {v:[[ 1,-1,-1],[-1,-1,-1],[-1, 1,-1],[ 1, 1,-1]], c:[.2,.7,1]},
      {v:[[ 1,-1, 1],[ 1,-1,-1],[ 1, 1,-1],[ 1, 1, 1]], c:[.3,.8,.4]},
      {v:[[-1,-1,-1],[-1,-1, 1],[-1, 1, 1],[-1, 1,-1]], c:[1,.7,.2]},
      {v:[[-1, 1, 1],[ 1, 1, 1],[ 1, 1,-1],[-1, 1,-1]], c:[.7,.4,1]},
      {v:[[-1,-1,-1],[ 1,-1,-1],[ 1,-1, 1],[-1,-1, 1]], c:[.25,.8,.75]}
    ];
    const vertices = [], normal = [], broken = [];
    faces.forEach((face, i) => {
      face.v.forEach(p => vertices.push(...p, ...face.c));
      const b = i * 4;
      const good = [b,b+1,b+2, b,b+2,b+3];
      normal.push(...good);
      // 只反转第 0 个面(红色)的两个三角形,不删除任何顶点。
      broken.push(...(i === 0
        ? [b,b+2,b+1, b,b+3,b+2] : good));
    });

    const vao = gl.createVertexArray();
    gl.bindVertexArray(vao);
    const vbo = gl.createBuffer();
    gl.bindBuffer(gl.ARRAY_BUFFER, vbo);
    gl.bufferData(gl.ARRAY_BUFFER, new Float32Array(vertices), gl.STATIC_DRAW);
    gl.enableVertexAttribArray(0);
    gl.vertexAttribPointer(0, 3, gl.FLOAT, false, 24, 0);
    gl.enableVertexAttribArray(1);
    gl.vertexAttribPointer(1, 3, gl.FLOAT, false, 24, 12);
    const ebo = gl.createBuffer();
    gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, ebo);

    const modeSelect = document.querySelector('#mode');
    function applyMode() {
      const mode = modeSelect.value;
      const indices = mode === 'broken' || mode === 'double' ? broken : normal;
      gl.bindVertexArray(vao);
      gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, ebo);
      gl.bufferData(gl.ELEMENT_ARRAY_BUFFER,
                    new Uint16Array(indices), gl.DYNAMIC_DRAW);
      gl.frontFace(mode === 'cw' ? gl.CW : gl.CCW);
      gl.cullFace(mode === 'front' ? gl.FRONT : gl.BACK);
      if (mode === 'double') gl.disable(gl.CULL_FACE);
      else gl.enable(gl.CULL_FACE);
      document.querySelector('#state').textContent =
        `绕序:${mode === 'cw' ? 'CW' : 'CCW'};剔除:${
          mode === 'double' ? '关闭' : mode === 'front' ? 'FRONT' : 'BACK'}`;
    }
    modeSelect.addEventListener('change', applyMode);
    applyMode();

    // 深度测试始终开启;改变的是剔除状态而不是遮挡规则。
    gl.enable(gl.DEPTH_TEST);
    gl.clearColor(.06, .09, .14, 1);
    const near = .1, far = 100, f = 1 / Math.tan(Math.PI / 6);
    const projection = new Float32Array([
      f / (canvas.width / canvas.height),0,0,0,
      0,f,0,0,
      0,0,(far + near) / (near - far),-1,
      0,0,2 * far * near / (near - far),0
    ]);
    gl.uniformMatrix4fv(gl.getUniformLocation(program, 'uProjection'),
                        false, projection);
    const angleLocation = gl.getUniformLocation(program, 'uAngle');
    function frame(time) {
      gl.viewport(0, 0, gl.drawingBufferWidth, gl.drawingBufferHeight);
      gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT);
      gl.uniform1f(angleLocation, time * .0007);
      gl.drawElements(gl.TRIANGLES, 36, gl.UNSIGNED_SHORT, 0);
      requestAnimationFrame(frame);
    }
    requestAnimationFrame(frame);
  </script>
</body>
</html>

预期结果:页面显示持续旋转的六色立方体和模式选择框。切到“红色面反向 + 剔除背面”时,红色面转到朝向观察者的一侧会形成缺口,其他面可能透过缺口可见;切到“红色面反向 + 关闭剔除”时,红色面恢复显示。页面不会产生固定的终端输出。

用可见结果定位错误

  1. 先选“正确绕序 + 剔除背面”:转到任意一侧时,朝外的面均可见,背向观察者的三角形被丢弃。
  2. 再选“红色面反向 + 剔除背面”:当红色面本应朝向相机时出现缺口,说明该面的两个三角形索引方向与其他面不一致。
  3. 选“红色面反向 + 关闭剔除”:若缺口消失,问题集中在绕序或剔除设置;若仍有缺口,还要检查索引范围、顶点坐标和深度缓冲区。
  4. 比较“全局 CW + 剔除背面”与“CCW + 剔除正面”:这两种设置都会优先留下原本背向观察者的面,因此可能看见立方体内部较远处的表面,不能用来修补仅一个面的反向索引。

真实项目中,遇到模型局部缺面,应先临时执行 gl.disable(gl.CULL_FACE) 验证,再检查受影响三角形的索引顺序。若整个模型做过单轴负缩放,镜像变换也可能反转屏幕绕序;应按材质与网格的既定正面约定处理,不要无条件给所有模型改用 gl.CW。双面薄片可关闭剔除,但封闭不透明网格通常保留背面剔除。

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

目录与阅读设置

阅读设置

17

记录一个想法

设置三角形绕序与背面剔除

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

登录哪都通