Web 图形与 3D / 系统课时

利用动画循环更新模型变换

利用动画循环更新模型变换

让一个立方体持续旋转并左右移动,需要在浏览器准备绘制时读取时间戳,用相邻帧的时间差推进运动,再将新的模型矩阵传给 WebGL 2。完成后,即使切换到其他标签页再返回,动画也不会因为后台停顿而突然跳跃。

学习目标

  • 用 requestAnimationFrame 建立更新与绘制循环,并按真实经过的秒数计算运动。
  • 区分只创建一次的 GPU 资源与每帧需要提交的模型变换。
  • 在页面隐藏、恢复和偶发长帧时避免过大的动画时间步长。

用帧间时间差控制速度

requestAnimationFrame(callback) 会在浏览器准备下一次重绘前调用回调,并传入以毫秒计的时间戳。将本帧与上一帧的差除以 1000,得到 dt(秒)。例如旋转角速度为每秒 1.2 弧度,60 Hz 时一次约旋转 1.2 × 0.0167 ≈ 0.020 弧度;30 Hz 时约旋转 0.040 弧度,两种帧率下每秒转过的角度仍接近相同。

不要每帧固定增加 0.02 弧度:显示器从 60 Hz 变成 120 Hz 时,模型会转得约两倍快。首次回调没有上一帧时间,令 dt = 0;普通动画还可以用 Math.min(dt, 0.05) 将单次更新限制在 50 毫秒,防止卡顿后的大跳变。这样做会舍弃超出阈值的时间,适合视觉动画,不适合要求完整补算的物理模拟。

分开初始化资源与更新变换

程序启动时只创建并配置一次 Program、VAO、顶点缓冲 VBO 和索引缓冲 EBO。它们保存顶点和绘制规则,不应随模型旋转反复创建。每帧只改变 CPU 侧的角度与位移,计算 uModel 矩阵,通过 gl.uniformMatrix4fv 上传,然后清空颜色和深度缓冲并调用 gl.drawElements。

gl.viewport 和投影矩阵也无需每帧重设:只有画布实际像素尺寸改变时才更新。下图把一次性初始化、重复执行的帧循环与页面暂停区分开。

WebGL 2 动画循环的数据更新与页面暂停关系

实现可以直接运行的立方体动画

新建 index.html,将下面内容完整复制进去,使用支持 WebGL 2 的桌面浏览器打开。示例用 8 个顶点和 36 个索引组成立方体;相机固定在原点朝负 Z 方向观察,模型位于约 z = -6 的位置。模型绕 Y 轴旋转,同时在 X 方向往复移动。

html
<!doctype html>
<html lang='zh-CN'>
<head>
  <meta charset='utf-8'>
  <title>WebGL 2 动画循环</title>
  <style>body{margin:24px}canvas{display:block;width:100%;height:360px}</style>
</head>
<body>
<canvas id='scene'></canvas>
<script>
'use strict';
const canvas = document.getElementById('scene');
const gl = canvas.getContext('webgl2');
if (!gl) throw new Error('当前浏览器不支持 WebGL 2');

const vertexSource = `#version 300 es
layout(location = 0) in vec3 aPosition;
uniform mat4 uProjection;
uniform mat4 uModel;
out vec3 vColor;
void main() {
  vColor = aPosition * 0.35 + 0.6;
  gl_Position = uProjection * uModel * vec4(aPosition, 1.0);
}`;
const fragmentSource = `#version 300 es
precision highp float;
in vec3 vColor;
out vec4 outColor;
void main() {
  outColor = 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));
}

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,
  7,6,2, 7,2,3, 0,1,5, 0,5,4
]);

// 网格数据只上传一次;VAO 记录属性读取方式和索引缓冲绑定。
const vao = gl.createVertexArray();
const vbo = gl.createBuffer();
const ebo = gl.createBuffer();
gl.bindVertexArray(vao);
gl.bindBuffer(gl.ARRAY_BUFFER, vbo);
gl.bufferData(gl.ARRAY_BUFFER, vertices, gl.STATIC_DRAW);
gl.vertexAttribPointer(0, 3, gl.FLOAT, false, 0, 0);
gl.enableVertexAttribArray(0);
gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, ebo);
gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, indices, gl.STATIC_DRAW);
gl.bindVertexArray(null);

gl.useProgram(program);
gl.bindVertexArray(vao);
gl.enable(gl.DEPTH_TEST);
gl.clearColor(0.97, 0.98, 1.0, 1.0);
const uProjection = gl.getUniformLocation(program, 'uProjection');
const uModel = gl.getUniformLocation(program, 'uModel');

function resizeIfNeeded() {
  const dpr = Math.min(window.devicePixelRatio || 1, 2);
  const w = Math.max(1, Math.round(canvas.clientWidth * dpr));
  const h = Math.max(1, Math.round(canvas.clientHeight * dpr));
  if (canvas.width === w && canvas.height === h) return;
  canvas.width = w;
  canvas.height = h;
  gl.viewport(0, 0, w, h);
  const near = 0.1, far = 100, scale = 1 / Math.tan(Math.PI / 6);
  const projection = new Float32Array([
    scale * h / w, 0, 0, 0,
    0, scale, 0, 0,
    0, 0, (near + far) / (near - far), -1,
    0, 0, 2 * near * far / (near - far), 0
  ]);
  gl.uniformMatrix4fv(uProjection, false, projection);
}

const model = new Float32Array(16);
model[5] = model[15] = 1;
model[14] = -6;
let elapsed = 0;
let lastTime = null;
let rafId = null;

function frame(now) {
  rafId = null;
  const dt = lastTime === null ? 0
    : Math.min(Math.max((now - lastTime) / 1000, 0), 0.05);
  lastTime = now;
  elapsed += dt;
  resizeIfNeeded();

  // 改变模型矩阵,不重建着色器或顶点缓冲。
  const angle = elapsed * 1.2;
  const c = Math.cos(angle), s = Math.sin(angle);
  model[0] = c;  model[2] = -s;
  model[8] = s;  model[10] = c;
  model[12] = Math.sin(elapsed * 0.7) * 1.2;
  gl.uniformMatrix4fv(uModel, false, model);
  gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT);
  gl.drawElements(gl.TRIANGLES, indices.length, gl.UNSIGNED_SHORT, 0);
  rafId = requestAnimationFrame(frame);
}

// 页面恢复后重新建立时间基准,避免把隐藏时间算作一帧。
function start() {
  if (rafId !== null || document.hidden) return;
  lastTime = null;
  rafId = requestAnimationFrame(frame);
}
function stop() {
  if (rafId !== null) cancelAnimationFrame(rafId);
  rafId = null;
  lastTime = null;
}
document.addEventListener('visibilitychange', () => {
  if (document.hidden) stop();
  else start();
});
start();
</script>
</body>
</html>

预期结果:浅色背景中出现带渐变顶点色的立方体,以每秒约 1.2 弧度的速度旋转,水平移动幅度为正负 1.2 个世界单位。调整窗口宽度后形状不被拉伸;切走标签页几秒后返回,模型从暂停位置继续运动。

处理后台停顿与动画恢复

多数浏览器会在后台标签页暂停或降低 requestAnimationFrame 频率,但不能据此假设恢复时的时间差一定很小。示例在 visibilitychange 触发且 document.hidden 为真时,调用 cancelAnimationFrame,同时清除帧编号和上一帧时间;恢复时重新请求下一帧,并让首帧的 dt 为 0。

即使页面未变为隐藏状态,若一次主线程阻塞持续 800 毫秒,Math.min(..., 0.05) 仍只允许推进 50 毫秒。它避免视觉对象瞬移,但会让模拟时间落后墙上时钟。如果是角色碰撞或需要确定性回放的物理状态,应改用固定时间步长与受限次数的补算,而不是直接照搬这一上限。

验证运动速度与资源复用

  1. 保持页面显示约 5 秒,观察模型持续匀速转动;60 Hz、120 Hz 设备视觉速度应接近,因为旋转角由累计秒数决定,而非固定帧数。
  2. 切换到其他标签页约 10 秒后返回;模型不应突然越过大量角度。若移除 lastTime = null 并取消 50 毫秒上限,就更容易复现时间跳变。
  3. 打开浏览器开发者工具的 Performance 面板录制数秒,检查动画期间的脚本执行。对照源码确认 createBuffer、bufferData、createProgram 只在初始化时调用,循环内只有矩阵上传与绘制。
  4. 缩放浏览器窗口,确认立方体没有被横向压扁。示例只在绘图缓冲尺寸改变时更新 viewport 与透视投影,并把设备像素比最多取为 2,以限制高分辨率屏幕的缓冲尺寸。

这套循环适合可视化模型与轻量场景交互:运动状态按秒推进、GPU 网格常驻、模型矩阵逐帧更新、隐藏页面时显式暂停。

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

目录与阅读设置

阅读设置

17

记录一个想法

利用动画循环更新模型变换

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

登录哪都通