Web 图形与 3D / 系统课时
通过视图矩阵设置观察方向
通过视图矩阵设置观察方向
把相机放到指定位置并对准三维场景中的目标,需要先把世界顶点转换到相机坐标系。本篇通过眼睛位置、目标点和上方向计算 LookAt 视图矩阵,再组合模型与透视投影矩阵,最终得到可拖动滑块切换观察方向的 WebGL 2 场景。
学习目标
- 说明相机世界矩阵与视图矩阵的逆变换关系。
- 根据
eye、target、up计算右手坐标系的 LookAt 视图矩阵。 - 用
P × V × M绘制立方体,验证不同相机角度的画面变化。
相机移动为何要反向变换世界
模型矩阵 M 把物体的局部坐标变为世界坐标;相机世界矩阵 C 表示相机在世界中的位置和朝向。渲染时,相机需要被看作坐标原点,因此视图矩阵是相机世界矩阵的逆矩阵:。
例如,相机位于 (0, 0, 5) 并朝向原点,其世界变换是沿 Z 轴平移 +5;对应的视图变换则平移 -5。世界原点 (0, 0, 0) 因而变为相机空间中的 (0, 0, -5),正好位于相机的负 Z 观察方向。
采用列向量约定时,顶点在顶点着色器里的变换顺序是 :先执行最右侧的模型变换,再执行视图变换,最后投影到裁剪空间。不能把 M 和 V 的位置随意互换。
用 LookAt 建立相机坐标轴
LookAt 由三个输入确定:eye 是相机世界坐标,target 是被观察点,up 是期望的上方向(通常为 [0, 1, 0])。以下约定相机看向自身的负 Z 轴,构建过程为:
back = normalize(eye - target):得到相机正 Z 轴,指向视线的反方向。right = normalize(cross(up, back)):得到相机正 X 轴。trueUp = cross(back, right):得到相机正 Y 轴,并保证三轴互相垂直。
视图矩阵的前三行是 right、trueUp 和 back 的分量;平移列由它们分别与 -eye 的点积构成。上传到 WebGL 时,则把矩阵按列主序依次存放在 Float32Array 中。

这里的 lookAtView 会直接返回视图矩阵。注意不同数学库的命名不完全一致:有些 lookAt 返回相机世界矩阵,需要再取逆;不要不加检查地替换函数。
在浏览器中切换观察方向
将以下内容保存为 camera.html,在支持 WebGL 2 的现代浏览器中打开。示例使用 8 个共享顶点、36 个索引绘制立方体;模型始终只沿 X 平移 0.5,滑块改变的是相机位置及视图矩阵。
<!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 说明)。
当滑块仅改变观察角度、固定的立方体仍稳定显示时,就已经把“移动相机”正确转换成了“用相反的视图变换移动世界”。