Web 图形与 3D / 系统课时

为远处对象降低逻辑更新频率

为远处对象降低逻辑更新频率

远处物体即使只占几个像素,仍可能每帧执行寻路、状态检查或动画参数计算。本课把逻辑更新按交互、可见性和距离分级,同时保留轻量的逐帧显示插值,用可运行的 Three.js 场景检查节流收益和状态跳变。

学习目标

  • 按交互优先、视锥可见性和距离建立互斥的更新档位。
  • 让低频逻辑与逐帧渲染解耦,并平滑过渡展示状态。
  • 用实际逻辑调用数、相机移动和对象选中验证调度效果。

按影响程度分配预算

假定目标渲染帧率是 60 FPS,物体分布在几十个世界单位内。先按下表分级;这些是可调整的起点,不是 Three.js 的内置档位。

判定顺序 判定条件 目标逻辑频率 用途
1 正被选中或操控 60 Hz 交互立即响应
2 未交互,包围球在视锥外 1 Hz 保留低频背景状态
3 视锥内、相机距离小于 28 单位 20 Hz 近景非关键行为
4 视锥内、距离不小于 28 单位 4 Hz 远景装饰行为

先判断交互,再判断视锥,最后判断距离;同一物体一次只进入一个档位。Frustum.intersectsSphere() 做的是保守视锥测试,不等于遮挡检测;mesh.visible 也不会因渲染器自动视锥剔除而变成 false。

对象更新频率分层和连续显示的调度关系

构建可运行的分级更新场景

准备 Node.js 20.19+ 或 22.12+,在空目录中执行以下命令。Vite 负责解析浏览器模块中对 three 的导入;最后一条命令会持续运行开发服务器。

bash
mkdir three-update-tiers
cd three-update-tiers
npm init -y
npm install three
npm install -D vite
npx vite --host 127.0.0.1

预期输出(节选):

text
Local: http://127.0.0.1:<PORT>/

<PORT> 随端口占用情况变化。接着在项目根目录创建 index.html,完整替换为以下示例:

html
<!doctype html>
<html lang="zh-CN">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <title>分级逻辑更新</title>
  <style>
    body { margin: 0; overflow: hidden; }
    #hud { position: fixed; top: 12px; left: 12px; padding: 10px;
           background: white; font: 14px sans-serif; z-index: 1; }
  </style>
</head>
<body>
<div id="hud">点击方块选中;按 W/S 前后移动相机</div>
<script type="module">
  import * as THREE from 'three';

  const scene = new THREE.Scene();
  scene.background = new THREE.Color(0xf5f7fa);
  const camera = new THREE.PerspectiveCamera(60, innerWidth / innerHeight, 0.1, 120);
  camera.position.set(0, 12, 19);
  camera.lookAt(0, 0, -15);
  const renderer = new THREE.WebGLRenderer({ antialias: true });
  renderer.setPixelRatio(Math.min(devicePixelRatio, 2));
  renderer.setSize(innerWidth, innerHeight);
  document.body.appendChild(renderer.domElement);
  scene.add(new THREE.GridHelper(48, 16));

  // 共享几何与材质;缓存每个对象的静态包围球。
  const geometry = new THREE.BoxGeometry(1.4, 1.4, 1.4);
  const material = new THREE.MeshNormalMaterial();
  const actors = [], meshes = [];
  for (let i = 0; i < 72; i++) {
    const anchor = new THREE.Vector3((i % 9 - 4) * 3.1, 0, -Math.floor(i / 9) * 4.5);
    const mesh = new THREE.Mesh(geometry, material);
    mesh.position.copy(anchor);
    mesh.userData.id = i;
    scene.add(mesh);
    meshes.push(mesh);
    actors.push({
      mesh, anchor, sphere: new THREE.Sphere(anchor, 2),
      phase: i * 0.37, inView: true, hz: 0, elapsed: 0, targetY: 0
    });
  }

  // 射线拾取仅在点击时进行,不放进动画循环。
  const raycaster = new THREE.Raycaster();
  const pointer = new THREE.Vector2();
  let selected = null;
  renderer.domElement.addEventListener('pointerdown', (event) => {
    const rect = renderer.domElement.getBoundingClientRect();
    pointer.set(
      (event.clientX - rect.left) / rect.width * 2 - 1,
      -(event.clientY - rect.top) / rect.height * 2 + 1
    );
    raycaster.setFromCamera(pointer, camera);
    selected = raycaster.intersectObjects(meshes, false)[0]?.object ?? null;
  });

  const keys = new Set();
  window.addEventListener('keydown', (event) => keys.add(event.key.toLowerCase()));
  window.addEventListener('keyup', (event) => keys.delete(event.key.toLowerCase()));
  window.addEventListener('resize', () => {
    camera.aspect = innerWidth / innerHeight;
    camera.updateProjectionMatrix();
    renderer.setSize(innerWidth, innerHeight);
    lastCull = -Infinity;
  });

  const frustum = new THREE.Frustum();
  const viewProjection = new THREE.Matrix4();
  let lastCull = -Infinity;
  function refreshView(time) {
    if (time - lastCull < 0.2) return;
    lastCull = time;
    camera.updateMatrixWorld();
    viewProjection.multiplyMatrices(camera.projectionMatrix, camera.matrixWorldInverse);
    frustum.setFromProjectionMatrix(viewProjection, THREE.WebGLCoordinateSystem);
    for (const actor of actors) {
      actor.inView = frustum.intersectsSphere(actor.sphere);
    }
  }

  let previous = performance.now(), sampleStart = previous / 1000, calls = 0;
  const hud = document.querySelector('#hud');
  function frame(now) {
    const dt = Math.min(0.05, Math.max(0, (now - previous) / 1000));
    previous = now;
    const time = now / 1000;
    const move = Number(keys.has('s')) - Number(keys.has('w'));
    camera.position.z = THREE.MathUtils.clamp(camera.position.z + move * 8 * dt, 5, 45);
    camera.lookAt(0, 0, -15);
    refreshView(time);

    for (const actor of actors) {
      const distance2 = camera.position.distanceToSquared(actor.anchor);
      const hz = selected === actor.mesh ? 60
        : !actor.inView ? 1 : distance2 < 28 * 28 ? 20 : 4;
      // 档位变化立即允许采样,保留计时余数但不补算过期帧。
      const step = 1 / hz;
      if (hz !== actor.hz) { actor.hz = hz; actor.elapsed = step; }
      actor.elapsed += dt;
      if (actor.elapsed >= step) {
        actor.targetY = Math.sin(time * 1.3 + actor.phase) * 0.55;
        actor.elapsed %= step;
        calls++;
      }
      // 只给可见对象做轻量显示插值,系数随 dt 调整。
      if (actor.inView) {
        const blend = 1 - Math.exp(-10 * dt);
        actor.mesh.position.y += (actor.targetY - actor.mesh.position.y) * blend;
      }
    }
    renderer.render(scene, camera);
    if (time - sampleStart >= 1) {
      hud.textContent = `逻辑更新 ${calls}/秒|选中 ${selected?.userData.id ?? '无'}|W/S 移动`;
      calls = 0;
      sampleStart = time;
    }
  }
  renderer.setAnimationLoop(frame);
</script>
</body>
</html>

预期结果:浏览器打开终端给出的本地地址,可见 72 个上下轻微浮动的立方体;点击任意方块后,该对象进入 60 Hz 档位;按住 W/S 移动相机,左上角每秒刷新一次实际逻辑更新次数。此数字由页面运行时统计,不应预设固定值。

分离逻辑采样与视觉过渡

示例只按档位刷新 targetY,每帧调用 renderer.render(),并用 1 - Math.exp(-10 * dt) 将当前 position.y 平滑移向目标。时间常数约为 0.1 秒,帧率变化时插值快慢仍近似一致;与每次逻辑更新直接赋值给位置相比,画面不容易产生台阶式跳变。

示例以秒为单位累计 elapsed,达到 1 / hz 才采样一次,并用取余保留剩余时间。即使掉帧也最多执行一次,不会为补足错过的周期突然连做几十次工作。切换档位时把累计量设为当前档位的周期,可让刚进入近景或被选中的物体立即获得新目标。示例用正弦函数代表可降频逻辑,生产环境才替换成昂贵的感知扫描、行为判断或远景装饰状态计算。

验证收益与回到视野时的连续性

  1. 保持相机不动,记录左上角连续 10 秒的逻辑更新次数;然后把示例中 const hz 的判定临时改成始终使用 60,比较同一场景的调用数与 Chrome DevTools Performance 主线程耗时。
  2. 恢复分级后,按住 W/S 穿过 28 单位阈值,观察近景、远景对象的上下运动是否突然跳到新位置;点击远景方块,再观察其交互是否及时提升频率。
  3. 在浏览器后台停留数秒后返回,检查是否产生成批补算或明显位置弹跳;示例中每帧最多一次采样与最大 0.05 秒的 dt 限幅用来抑制这两类问题。

理论上,若 60 个对象中有 10 个近景、40 个远景、10 个视锥外,全部 60 Hz 每秒是 3600 次逻辑调用;分级后近景 200 次、远景 160 次、视锥外 10 次,合计 370 次,约减少 90%。这只是调用次数预算,不是 CPU 耗时或 FPS 的保证值。真实验收仍须比较相同相机路线下的脚本耗时、帧时间 P95 和交互响应。

当对象数量上千时,视锥检测本身也需要预算:示例每 0.2 秒复用同一个 Frustum,静态锚点配保守包围球;有大范围移动的对象必须同步更新球心,或者按空间分区批量判定。只有逻辑计算确实占用可观 CPU 时间、且画面与交互检查均通过时,降低更新频率才算有效优化。

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

目录与阅读设置

阅读设置

17

记录一个想法

为远处对象降低逻辑更新频率

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

登录哪都通