Web 图形与 3D / 系统课时

通过视图矩阵设置观察方向

通过视图矩阵设置观察方向

把相机放到指定位置并对准三维场景中的目标,需要先把世界顶点转换到相机坐标系。本篇通过眼睛位置、目标点和上方向计算 LookAt 视图矩阵,再组合模型与透视投影矩阵,最终得到可拖动滑块切换观察方向的 WebGL 2 场景。

学习目标

  • 说明相机世界矩阵与视图矩阵的逆变换关系。
  • 根据 eye、target、up 计算右手坐标系的 LookAt 视图矩阵。
  • 用 P × V × M 绘制立方体,验证不同相机角度的画面变化。

相机移动为何要反向变换世界

模型矩阵 M 把物体的局部坐标变为世界坐标;相机世界矩阵 C 表示相机在世界中的位置和朝向。渲染时,相机需要被看作坐标原点,因此视图矩阵是相机世界矩阵的逆矩阵:V=C−1V=C^{-1}。

例如,相机位于 (0, 0, 5) 并朝向原点,其世界变换是沿 Z 轴平移 +5;对应的视图变换则平移 -5。世界原点 (0, 0, 0) 因而变为相机空间中的 (0, 0, -5),正好位于相机的负 Z 观察方向。

采用列向量约定时,顶点在顶点着色器里的变换顺序是 pclip=PVMplocalp_{clip}=PVMp_{local}:先执行最右侧的模型变换,再执行视图变换,最后投影到裁剪空间。不能把 M 和 V 的位置随意互换。

用 LookAt 建立相机坐标轴

LookAt 由三个输入确定:eye 是相机世界坐标,target 是被观察点,up 是期望的上方向(通常为 [0, 1, 0])。以下约定相机看向自身的负 Z 轴,构建过程为:

  1. back = normalize(eye - target):得到相机正 Z 轴,指向视线的反方向。
  2. right = normalize(cross(up, back)):得到相机正 X 轴。
  3. trueUp = cross(back, right):得到相机正 Y 轴,并保证三轴互相垂直。

视图矩阵的前三行是 right、trueUp 和 back 的分量;平移列由它们分别与 -eye 的点积构成。上传到 WebGL 时,则把矩阵按列主序依次存放在 Float32Array 中。

LookAt 相机三轴与模型、视图、投影的空间变换关系

这里的 lookAtView 会直接返回视图矩阵。注意不同数学库的命名不完全一致:有些 lookAt 返回相机世界矩阵,需要再取逆;不要不加检查地替换函数。

在浏览器中切换观察方向

将以下内容保存为 camera.html,在支持 WebGL 2 的现代浏览器中打开。示例使用 8 个共享顶点、36 个索引绘制立方体;模型始终只沿 X 平移 0.5,滑块改变的是相机位置及视图矩阵。

html
<!doctype html>
<html lang="zh-CN">
<head>
  <meta charset="utf-8">
  <title>WebGL 2 LookAt 相机</title>
  <style>
    body { font: 16px sans-serif; }
    canvas { display: block; max-width: 100%; margin-top: 12px; }
  </style>
</head>
<body>
  <label>观察角度:<input id="angle" type="range" min="0" max="360" value="0"></label>
  <output id="value">0°</output>
  <canvas id="scene" width="640" height="360"></canvas>
  <script>
    const canvas = document.querySelector('#scene');
    const angle = document.querySelector('#angle');
    const value = document.querySelector('#value');
    const gl = canvas.getContext('webgl2');
    if (!gl) throw new Error('当前环境不支持 WebGL 2');

    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 vs = compile(gl.VERTEX_SHADER, `#version 300 es
      layout(location = 0) in vec3 a_position;
      uniform mat4 u_mvp;
      out vec3 v_color;
      void main() {
        gl_Position = u_mvp * vec4(a_position, 1.0);
        v_color = (a_position + vec3(1.0)) * 0.5;
      }`);
    const fs = compile(gl.FRAGMENT_SHADER, `#version 300 es
      precision highp float;
      in vec3 v_color;
      out vec4 out_color;
      void main() { out_color = vec4(v_color, 1.0); }`);
    const program = gl.createProgram();
    gl.attachShader(program, vs);
    gl.attachShader(program, fs);
    gl.linkProgram(program);
    if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
      throw new Error(gl.getProgramInfoLog(program));
    }
    const uMvp = gl.getUniformLocation(program, 'u_mvp');

    const positions = new Float32Array([
      -1,-1,-1, 1,-1,-1, 1,1,-1, -1,1,-1,
      -1,-1, 1, 1,-1, 1, 1,1, 1, -1,1, 1
    ]);
    const indices = new Uint16Array([
      4,5,6, 4,6,7, 0,2,1, 0,3,2,
      0,4,7, 0,7,3, 1,2,6, 1,6,5,
      3,7,6, 3,6,2, 0,1,5, 0,5,4
    ]);
    // EBO 绑定属于 VAO 状态,绘制时重新绑定 VAO 即可复用索引布局。
    const vao = gl.createVertexArray();
    gl.bindVertexArray(vao);
    const vbo = gl.createBuffer();
    gl.bindBuffer(gl.ARRAY_BUFFER, vbo);
    gl.bufferData(gl.ARRAY_BUFFER, positions, gl.STATIC_DRAW);
    gl.enableVertexAttribArray(0);
    gl.vertexAttribPointer(0, 3, gl.FLOAT, false, 0, 0);
    const ebo = gl.createBuffer();
    gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, ebo);
    gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, indices, gl.STATIC_DRAW);
    gl.bindVertexArray(null);

    const sub = (a, b) => a.map((n, i) => n - b[i]);
    const dot = (a, b) => a.reduce((s, n, i) => s + n * b[i], 0);
    const cross = (a, b) => [
      a[1]*b[2] - a[2]*b[1],
      a[2]*b[0] - a[0]*b[2],
      a[0]*b[1] - a[1]*b[0]
    ];
    function unit(v) {
      const len = Math.hypot(...v);
      if (len < 1e-6) throw new Error('相机视线或 up 向量退化');
      return v.map(n => n / len);
    }

    // 直接构造世界空间到相机空间的逆变换矩阵,按列主序存储。
    function lookAtView(eye, target, up) {
      const z = unit(sub(eye, target));
      const x = unit(cross(up, z));
      const y = cross(z, x);
      return new Float32Array([
        x[0], y[0], z[0], 0,
        x[1], y[1], z[1], 0,
        x[2], y[2], z[2], 0,
        -dot(x, eye), -dot(y, eye), -dot(z, eye), 1
      ]);
    }
    function perspective(fov, aspect, near, far) {
      const f = 1 / Math.tan(fov / 2);
      const d = 1 / (near - far);
      return new Float32Array([
        f/aspect,0,0,0, 0,f,0,0,
        0,0,(near+far)*d,-1, 0,0,2*near*far*d,0
      ]);
    }
    function translation(x, y, z) {
      return new Float32Array([
        1,0,0,0, 0,1,0,0, 0,0,1,0, x,y,z,1
      ]);
    }
    function multiply(a, b) {
      const out = new Float32Array(16);
      for (let c = 0; c < 4; c++) {
        for (let r = 0; r < 4; r++) {
          for (let k = 0; k < 4; k++) {
            out[c*4+r] += a[k*4+r] * b[c*4+k];
          }
        }
      }
      return out;
    }

    const model = translation(0.5, 0, 0);
    const projection = perspective(Math.PI / 3, 640 / 360, 0.1, 100);
    gl.enable(gl.DEPTH_TEST);

    function render() {
      // 固定模型矩阵,通过水平圆轨道上的 eye 改变观察方向。
      const radians = Number(angle.value) * Math.PI / 180;
      const eye = [4 * Math.sin(radians), 2, 4 * Math.cos(radians)];
      const view = lookAtView(eye, [0, 0, 0], [0, 1, 0]);
      // 列向量约定:模型先变换,然后视图,最后投影。
      const mvp = multiply(projection, multiply(view, model));
      gl.viewport(0, 0, canvas.width, canvas.height);
      gl.clearColor(0.96, 0.98, 1, 1);
      gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT);
      gl.useProgram(program);
      gl.bindVertexArray(vao);
      gl.uniformMatrix4fv(uMvp, false, mvp);
      gl.drawElements(gl.TRIANGLES, indices.length, gl.UNSIGNED_SHORT, 0);
      value.textContent = angle.value + '°';
    }
    angle.addEventListener('input', render);
    render();
  </script>
</body>
</html>

预期结果:页面显示带渐变色面的立方体,初始角度为 0°。将滑块移到 90°,视点从大致 (0, 2, 4) 移到 (4, 2, 0),立方体的可见面和投影位置发生变化;移到 180° 则从另一侧观察。几何缓冲区及 model 始终不变,变化只来自 eye 和 view。

用数值和画面排查方向错误

先用容易手算的相机验证:输入 eye=[0,0,5]、target=[0,0,0]、up=[0,1,0],正确的 lookAtView 应当让 view[12]=0、view[13]=0、view[14]=-5。如果这里得到 +5,通常是把相机世界矩阵当成视图矩阵,或把 eye-target 方向写反了。

对照下面几个可复现的现象逐一定位:

  • 物体随相机平移向同方向跑:检查是否用了 C 而不是 C 的逆,或把 P × V × M 误写成 P × M × V。
  • 物体被裁掉或出现前后颠倒:确认相机朝向负 Z、near=0.1、far=100,且 0 < near < far。
  • 一拖滑块画面就翻转或全黑:确认 eye 不等于 target,up 不与视线平行;例如从正上方观察时不要仍用与视线共线的 [0,1,0]。
  • 矩阵看似正确但形状扭曲:检查 multiply(a,b) 的顺序及列主序索引,uniformMatrix4fv 的 transpose 必须传 false(MDN 说明)。

当滑块仅改变观察角度、固定的立方体仍稳定显示时,就已经把“移动相机”正确转换成了“用相反的视图变换移动世界”。

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

目录与阅读设置

阅读设置

17

记录一个想法

通过视图矩阵设置观察方向

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

登录哪都通