Web 图形与 3D / 系统课时

用鼠标拖拽控制轨道相机

用鼠标拖拽控制轨道相机

这个示例让鼠标左键拖拽控制相机绕立方体转动,滚轮改变观察距离,模型本身保持不动。完成后可以从不同角度检查物体,视图矩阵随输入实时更新,并通过角度和距离限制避免翻转或穿入模型。

学习目标

  • 用方位角、俯仰角和距离计算围绕目标点的相机位置。
  • 将拖拽位移与滚轮输入转换为受限的相机参数。
  • 在 WebGL 2 中更新视图矩阵,并验证遮挡、缩放和窗口适配。

让相机沿目标点周围的球面移动

轨道相机始终注视固定目标 target = [0, 0, 0],用 yaw 表示绕世界 Y 轴的方位角,pitch 表示相对水平面的俯仰角,distance 表示相机到目标点的半径。三个参数变化时,只重算相机位置和视图矩阵,不修改立方体顶点。

相机位置由 x = tx + r·cos(pitch)·sin(yaw)、y = ty + r·sin(pitch)、z = tz + r·cos(pitch)·cos(yaw) 得到。角度使用弧度;初始 yaw = 0.65、pitch = 0.35、distance = 5.5。视图矩阵由 lookAt(eye, target) 构造,世界上方向固定为 Y 轴。

轨道相机的目标点、方位角、俯仰角和距离

把输入转换为受限的轨道参数

拖拽时保存上一次鼠标位置,每次用本次位置减去上次位置得到 dx、dy。取灵敏度 0.005 弧度/像素:向右拖动增大 yaw,向下拖动减小 pitch。例如水平拖动 200 像素,方位角增加 1 弧度,约 57.3°。

俯仰角限制为 −80°~80°,避免在相机正上方或正下方使世界上方向与视线平行。滚轮缩放使用 distance *= exp(deltaY × 0.001),再约束到 2.5~12:以像素模式向下滚动 100 单位,距离从 5.5 变为约 6.08。pointer capture 让拖动移出画布后仍能收到松开事件。

实现可拖拽的 WebGL 2 场景

将下列内容保存为 orbit-camera.html,用支持 WebGL 2 的现代浏览器打开即可运行,无需第三方库。示例绘制一个由 8 个顶点、36 个索引构成的彩色立方体,开启深度测试,并使用透视矩阵与随交互更新的视图矩阵。

html
<!doctype html>
<html lang="zh-CN">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>WebGL 2 轨道相机</title>
<style>
  body { margin: 0; }
  canvas { display: block; width: 100vw; height: 100vh; touch-action: none; }
</style>
</head>
<body>
<canvas id="scene"></canvas>
<script>
const canvas = document.querySelector('#scene');
const gl = canvas.getContext('webgl2', { antialias: true });
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 aPosition;
uniform mat4 uView;
uniform mat4 uProjection;
out vec3 vColor;
void main() {
  vColor = (aPosition + vec3(1.0)) * 0.5;
  gl_Position = uProjection * uView * vec4(aPosition, 1.0);
}`);
const fs = compile(gl.FRAGMENT_SHADER, `#version 300 es
precision highp float;
in vec3 vColor;
out vec4 outColor;
void main() { outColor = vec4(vColor, 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));
}
gl.deleteShader(vs);
gl.deleteShader(fs);
gl.useProgram(program);
const viewLocation = gl.getUniformLocation(program, 'uView');
const projectionLocation = gl.getUniformLocation(program, 'uProjection');

const vertices = 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,  1,0,3, 1,3,2,
  0,4,7, 0,7,3,  5,1,2, 5,2,6,
  3,7,6, 3,6,2,  0,1,5, 0,5,4
]);
const vao = gl.createVertexArray();
gl.bindVertexArray(vao);
gl.bindBuffer(gl.ARRAY_BUFFER, gl.createBuffer());
gl.bufferData(gl.ARRAY_BUFFER, vertices, gl.STATIC_DRAW);
gl.enableVertexAttribArray(0);
gl.vertexAttribPointer(0, 3, gl.FLOAT, false, 0, 0);
gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, gl.createBuffer());
gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, indices, gl.STATIC_DRAW);
gl.enable(gl.DEPTH_TEST);
gl.clearColor(0.96, 0.98, 1.0, 1.0);

const target = [0, 0, 0];
let yaw = 0.65, pitch = 0.35, distance = 5.5;
const pitchLimit = 80 * Math.PI / 180;
const clamp = (v, lo, hi) => Math.max(lo, Math.min(hi, v));

function perspective(fov, aspect, near, far) {
  const f = 1 / Math.tan(fov / 2);
  return new Float32Array([
    f / aspect, 0, 0, 0,
    0, f, 0, 0,
    0, 0, (far + near) / (near - far), -1,
    0, 0, 2 * far * near / (near - far), 0
  ]);
}

function lookAt(eye, center) {
  // 视线反方向 z 与世界上方向 [0,1,0] 构成正交基。
  let z = eye.map((v, i) => v - center[i]);
  z = z.map(v => v / Math.hypot(...z));
  let x = [z[2], 0, -z[0]];
  const len = Math.hypot(...x);
  x = x.map(v => v / len);
  const y = [
    z[1] * x[2],
    z[2] * x[0] - z[0] * x[2],
    -z[1] * x[0]
  ];
  const dot = (a, b) => a.reduce((s, v, i) => s + v * b[i], 0);
  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 render() {
  const dpr = Math.min(window.devicePixelRatio || 1, 2);
  const width = Math.max(1, Math.round(canvas.clientWidth * dpr));
  const height = Math.max(1, Math.round(canvas.clientHeight * dpr));
  if (canvas.width !== width || canvas.height !== height) {
    canvas.width = width;
    canvas.height = height;
  }
  gl.viewport(0, 0, width, height);

  // 球坐标转换为相机位置;模型顶点不会跟随输入改变。
  const eye = [
    target[0] + distance * Math.cos(pitch) * Math.sin(yaw),
    target[1] + distance * Math.sin(pitch),
    target[2] + distance * Math.cos(pitch) * Math.cos(yaw)
  ];
  gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT);
  gl.uniformMatrix4fv(viewLocation, false, lookAt(eye, target));
  gl.uniformMatrix4fv(
    projectionLocation, false, perspective(Math.PI / 3, width / height, 0.1, 100)
  );
  gl.bindVertexArray(vao);
  gl.drawElements(gl.TRIANGLES, indices.length, gl.UNSIGNED_SHORT, 0);
}

let activePointer = null, lastX = 0, lastY = 0;
canvas.addEventListener('pointerdown', e => {
  if (e.button !== 0 || activePointer !== null) return;
  activePointer = e.pointerId;
  lastX = e.clientX;
  lastY = e.clientY;
  canvas.setPointerCapture(e.pointerId);
});
canvas.addEventListener('pointermove', e => {
  if (e.pointerId !== activePointer) return;
  const dx = e.clientX - lastX;
  const dy = e.clientY - lastY;
  lastX = e.clientX;
  lastY = e.clientY;
  yaw += dx * 0.005;
  pitch = clamp(pitch - dy * 0.005, -pitchLimit, pitchLimit);
  render();
});
function endDrag(e) {
  if (e.pointerId !== activePointer) return;
  activePointer = null;
  if (canvas.hasPointerCapture(e.pointerId)) {
    canvas.releasePointerCapture(e.pointerId);
  }
}
canvas.addEventListener('pointerup', endDrag);
canvas.addEventListener('pointercancel', endDrag);
canvas.addEventListener('lostpointercapture', () => { activePointer = null; });
canvas.addEventListener('wheel', e => {
  e.preventDefault();
  // 兼容滚轮事件按像素、行或页报告增量的设备。
  const unit = e.deltaMode === 1 ? 16 : e.deltaMode === 2 ? canvas.clientHeight : 1;
  distance = clamp(distance * Math.exp(e.deltaY * unit * 0.001), 2.5, 12);
  render();
}, { passive: false });
window.addEventListener('resize', render);
render();
</script>
</body>
</html>

预期结果:页面显示渐变着色的立方体。按住左键水平拖动可切换可见面,竖向拖动可从高处或低处观察;滚轮向下转动会拉远,向上转动会拉近。松开鼠标后画面停留在当前视角,不会继续旋转。

验收控制边界与常见问题

先连续向上、向下拖动,视角最多到 +80° 和 −80°,不会翻到物体另一侧;再反复缩放,距离始终在 2.5~12 内。改变浏览器窗口尺寸,立方体不应被拉宽或压扁,因为投影矩阵每次都使用最新的绘图缓冲宽高比。

如果拖动毫无反应,检查画布是否收到 pointerdown 和 pointermove;如果立方体面片互相穿透,确认启用 gl.DEPTH_TEST 且每次重绘都清理深度缓冲。相机接近竖直方向时出现突然旋转,通常是没有限制 pitch,导致 lookAt 的水平右轴长度趋近零。

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

目录与阅读设置

阅读设置

17

记录一个想法

用鼠标拖拽控制轨道相机

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

登录哪都通