From a158b85f4eff6f3fdfa4dfdaa01087fca9fabcf6 Mon Sep 17 00:00:00 2001 From: "Mr.doob" Date: Thu, 5 Mar 2026 17:23:48 +0900 Subject: [PATCH 1/4] USDComposer: Add light support. Co-Authored-By: Claude Opus 4.6 --- examples/jsm/loaders/usd/USDComposer.js | 130 ++++++++++++++++++++++++ 1 file changed, 130 insertions(+) diff --git a/examples/jsm/loaders/usd/USDComposer.js b/examples/jsm/loaders/usd/USDComposer.js index 239255747d8cbe..786a4732d77947 100644 --- a/examples/jsm/loaders/usd/USDComposer.js +++ b/examples/jsm/loaders/usd/USDComposer.js @@ -5,8 +5,10 @@ import { BufferGeometry, CapsuleGeometry, ClampToEdgeWrapping, + Color, ConeGeometry, CylinderGeometry, + DirectionalLight, Euler, Group, Matrix4, @@ -17,14 +19,17 @@ import { Object3D, OrthographicCamera, PerspectiveCamera, + PointLight, Quaternion, QuaternionKeyframeTrack, + RectAreaLight, RepeatWrapping, ShapeUtils, SkinnedMesh, Skeleton, Bone, SphereGeometry, + SpotLight, SRGBColorSpace, Texture, Vector2, @@ -725,6 +730,15 @@ class USDComposer { parent.add( obj ); this._buildHierarchy( obj, path ); + } else if ( typeName === 'DistantLight' || typeName === 'SphereLight' || typeName === 'RectLight' || typeName === 'DiskLight' ) { + + const obj = this._buildLight( path, typeName ); + obj.name = name; + const attrs = this._getAttributes( path ); + this.applyTransform( obj, spec.fields, attrs ); + parent.add( obj ); + this._buildHierarchy( obj, path ); + } else if ( typeName === 'Cube' || typeName === 'Sphere' || typeName === 'Cylinder' || typeName === 'Cone' || typeName === 'Capsule' ) { const obj = this._buildGeomPrimitive( path, spec, typeName ); @@ -1435,6 +1449,122 @@ class USDComposer { } + /** + * Build a light from a UsdLux light spec. + */ + _buildLight( path, typeName ) { + + const attrs = this._getAttributes( path ); + + const intensity = this._parseNumber( attrs[ 'inputs:intensity' ], 1 ); + const baseColor = attrs[ 'inputs:color' ] || [ 1, 1, 1 ]; + const enableColorTemperature = attrs[ 'inputs:enableColorTemperature' ] === true; + const colorTemperature = this._parseNumber( attrs[ 'inputs:colorTemperature' ], 6500 ); + + const color = new Color( baseColor[ 0 ], baseColor[ 1 ], baseColor[ 2 ] ); + + if ( enableColorTemperature ) { + + const temp = this._colorTemperature( colorTemperature ); + color.multiply( temp ); + + } + + let light; + + switch ( typeName ) { + + case 'DistantLight': + light = new DirectionalLight( color, intensity ); + break; + + case 'SphereLight': { + + const coneAngle = this._parseNumber( attrs[ 'shaping:cone:angle' ], 0 ); + + if ( coneAngle > 0 ) { + + const angle = coneAngle * Math.PI / 180; + const softness = this._parseNumber( attrs[ 'shaping:cone:softness' ], 0 ); + light = new SpotLight( color, intensity, 0, angle, softness ); + + } else { + + light = new PointLight( color, intensity ); + + } + + break; + + } + + case 'RectLight': { + + const width = this._parseNumber( attrs[ 'inputs:width' ], 1 ); + const height = this._parseNumber( attrs[ 'inputs:height' ], 1 ); + light = new RectAreaLight( color, intensity, width, height ); + break; + + } + + case 'DiskLight': { + + const radius = this._parseNumber( attrs[ 'inputs:radius' ], 0.5 ); + const side = radius * 2; + light = new RectAreaLight( color, intensity, side, side ); + break; + + } + + } + + return light; + + } + + /** + * Convert a color temperature in Kelvin to an RGB Color. + * Based on Tanner Helland's algorithm. + */ + _colorTemperature( kelvin ) { + + const temp = kelvin / 100; + let r, g, b; + + if ( temp <= 66 ) { + + r = 1; + g = 0.39008157876901960784 * Math.log( temp ) - 0.63184144378862745098; + + } else { + + r = 1.29293618606274509804 * Math.pow( temp - 60, - 0.1332047592 ); + g = 1.12989086089529411765 * Math.pow( temp - 60, - 0.0755148492 ); + + } + + if ( temp >= 66 ) { + + b = 1; + + } else if ( temp <= 19 ) { + + b = 0; + + } else { + + b = 0.54320678911019607843 * Math.log( temp - 10 ) - 1.19625408914; + + } + + return new Color( + Math.min( Math.max( r, 0 ), 1 ), + Math.min( Math.max( g, 0 ), 1 ), + Math.min( Math.max( b, 0 ), 1 ) + ); + + } + _parseNumber( value, fallback ) { const n = Number( value ); From 54001d867612924f2c953c9904539774af119236 Mon Sep 17 00:00:00 2001 From: DDDDD12138 <43703884+DDDDD12138@users.noreply.github.com> Date: Thu, 5 Mar 2026 17:09:43 +0800 Subject: [PATCH 2/4] Manual: Translate manual/zh/game.html to Chinese (#33123) --- manual/en/game.html | 4 +- manual/fr/game.html | 4 +- manual/ko/game.html | 4 +- manual/zh/game.html | 1618 ++++++++++++++++++++++++++++++++++++++++++- 4 files changed, 1618 insertions(+), 12 deletions(-) diff --git a/manual/en/game.html b/manual/en/game.html index 50785afd630667..8e3a280d89e691 100644 --- a/manual/en/game.html +++ b/manual/en/game.html @@ -1401,7 +1401,7 @@

Making a Game

When I first started this I used just one radius for all animals but of course that was no good as the pug is much smaller than the horse. So I added the difference sizes but I wanted to be able to visualize -things. To do that I made a StatusDisplayHelper component.

+things. To do that I made a StateDisplayHelper component.

I uses a PolarGridHelper to draw a circle around each character and it uses html elements to let each character show some status using the techniques covered in the article on aligning html elements to 3D.

@@ -1673,7 +1673,7 @@

Making a Game

To make a coroutine you make a JavaScript generator function. A generator function is preceded by the keyword function* (the asterisk is important!)

Generator functions can yield. For example

-
function* countOTo9() {
+
function* count0To9() {
   for (let i = 0; i < 10; ++i) {
     console.log(i);
     yield;
diff --git a/manual/fr/game.html b/manual/fr/game.html
index bc87447df8ee68..21b96c6d2c2823 100644
--- a/manual/fr/game.html
+++ b/manual/fr/game.html
@@ -1196,7 +1196,7 @@ 
Créer un jeu

 
Lorsque j'ai commencé cela, j'ai utilisé un seul rayon pour tous les animaux,
 mais bien sûr, ce n'était pas bon, car le carlin est beaucoup plus petit que le cheval.
 J'ai donc ajouté les différentes tailles, mais je voulais pouvoir visualiser
-les choses. Pour ce faire, j'ai créé un composant StatusDisplayHelper.

+les choses. Pour ce faire, j'ai créé un composant StateDisplayHelper.

 
J'utilise un PolarGridHelper pour dessiner un cercle autour de chaque personnage,
 et il utilise des éléments html pour permettre à chaque personnage d'afficher un certain statut en utilisant
 les techniques couvertes dans l'article sur l'alignement des éléments html en 3D.

@@ -1498,7 +1498,7 @@ 
Créer un jeu

 
Pour créer une coroutine, vous créez une fonction génératrice JavaScript.
 Une fonction génératrice est précédée du mot-clé function* (l'astérisque est important !)

 
Les fonctions génératrices peuvent yield (céder). Par exemple

-
function* countOTo9() {
+
function* count0To9() {
   for (let i = 0; i < 10; ++i) {
     console.log(i);
     yield;
diff --git a/manual/ko/game.html b/manual/ko/game.html
index b2aa2e07d3a6fc..7df5ab41148927 100644
--- a/manual/ko/game.html
+++ b/manual/ko/game.html
@@ -1206,7 +1206,7 @@ 
로 게임 만들기

 +    globals.playerRadius = model.size / 2;
 

 
이제 와 생각해보니 플레이어가 아니라 기차의 머리를 바라보게 하는 편이 더 나았겠네요. 이건 나중에 돌아와 고치도록 하겠습니다.

-
예제를 처음 만들었을 때는 동물들이 모두 같은 크기의 경계 원(radius)을 썼지만, 이렇게 하고 보니 말과 퍼그(강아지)의 크기가 같은 게 말이 안 된다는 생각이 들었습니다. 그래서 각 모델의 크기에 따라 경계 원을 따로 지정했죠. 그리고 상태를 보여주면 좋겠다는 생각이 들어 상태를 보여 줄 StatusDisplayHelper 컴포넌트를 추가했습니다.

+
예제를 처음 만들었을 때는 동물들이 모두 같은 크기의 경계 원(radius)을 썼지만, 이렇게 하고 보니 말과 퍼그(강아지)의 크기가 같은 게 말이 안 된다는 생각이 들었습니다. 그래서 각 모델의 크기에 따라 경계 원을 따로 지정했죠. 그리고 상태를 보여주면 좋겠다는 생각이 들어 상태를 보여 줄 StateDisplayHelper 컴포넌트를 추가했습니다.

 
또한 PolarGridHelper를 써 각 캐릭터의 경계 원이 보이도록 했고, HTML 요소를 3D로 정렬하기에서 썼던 방법으로 각 캐릭터의 상태를 HTML로 보여주도록 했습니다.

 
먼저 각 요소를 담을 HTML을 추가합니다.

 
<body>
@@ -1438,7 +1438,7 @@ 
로 게임 만들기

 
위 클래스는 다른 코루틴이 실행되는 동안 요소를 안전하게 제거/추가하도록 SafeArray와 비슷한 구조로 만들었습니다. 또한 이 클래스는 중첩된 코루틴도 처리합니다.

 
코루틴을 만들려면 자바스크립트의 제너레이터 함수를 만들어야 합니다. 제너레이터 함수는 function*이라는 키워드로 생성하죠(별표를 붙여야 합니다!).

 
제너레이터 함수는 yield 키워드로 실행 순서를 양보(yield)할 수 있습니다.

-
function* countOTo9() {
+
function* count0To9() {
   for (let i = 0; i < 10; ++i) {
     console.log(i);
     yield;
diff --git a/manual/zh/game.html b/manual/zh/game.html
index 1a6bd3c0641de1..3e5cf057883f45 100644
--- a/manual/zh/game.html
+++ b/manual/zh/game.html
@@ -1,10 +1,10 @@
 
     
-    Making a Game
+    制作一个游戏
     
     
     
-    
+    
     
     
     
@@ -18,18 +18,1624 @@
   }
 }
 
-    
   
   
     

       

-        
Making a Game

+        
制作一个游戏

       

       

         

-          
抱歉，还没有中文翻译哦。 欢迎加入翻译! 😄

-
英文原文链接.

+          
很多人想用 three.js 来写游戏。这篇文章希望能给你一些如何开始的思路。

+
至少在我写这篇文章的时候，它可能会成为本站最长的文章。这里的代码可能过度设计了，但在我编写每个新功能时，都会遇到需要解决的问题，而这些解决方案都来自我以前写过的其他游戏。换句话说，每个新的解决方案看起来都很重要，所以我会尽量解释为什么需要它们。当然，你的游戏越小，就越不需要这里展示的某些解决方案，但这本身是一个相当小的游戏，然而由于 3D 角色的复杂性，许多事情比 2D 角色需要更多的组织。

+
举个例子，如果你在制作 2D 版的吃豆人，吃豆人转弯时会瞬间完成 90 度旋转，没有中间过程。但在 3D 游戏中，我们通常需要角色在多帧之间旋转。这个简单的变化就会增加很多复杂性，并需要不同的解决方案。

+
这里的大部分代码实际上并不是 three.js 的代码，这一点很重要，three.js 不是一个游戏引擎。Three.js 是一个 3D 库。它提供了一个场景图以及在场景图中显示 3D 对象的功能，但它不提供制作游戏所需的所有其他东西。没有碰撞检测，没有物理引擎，没有输入系统，没有寻路等等...所以，我们必须自己提供这些功能。

+
我最终写了相当多的代码来制作这个简单的未完成的游戏原型，而且我觉得可能过度设计了，应该有更简单的解决方案，但我觉得我实际上还没有写够代码，希望我能解释我认为还缺少什么。

+
这里的许多想法深受 Unity 的影响。如果你不熟悉 Unity，那可能并不重要。我提到它只是因为有数以万计的游戏是使用这些理念发布的。

+
让我们从 three.js 部分开始。我们需要为游戏加载模型。

+
在 opengameart.org 上我找到了这个由 quaternius 制作的动画骑士模型

+

 
+
quaternius 还制作了这些动画动物。

+

+
+
这些看起来是很好的起步模型，所以我们首先需要加载它们。

+
我们之前讲过加载 glTF 文件。这次的不同之处在于我们需要加载多个模型，而且在所有模型加载完成之前不能开始游戏。

+
幸运的是 three.js 提供了 LoadingManager 来满足这个需求。我们创建一个 LoadingManager 并将它传递给其他加载器。LoadingManager 提供了 onProgress 和 onLoad 属性供我们附加回调函数。当所有文件加载完成时会调用 onLoad 回调。每个单独的文件加载完成后会调用 onProgress 回调，让我们有机会显示加载进度。

+
从加载 glTF 文件的代码开始，我移除了所有与场景取景相关的代码，并添加了以下代码来加载所有模型。

+
const manager = new THREE.LoadingManager();
+manager.onLoad = init;
+const models = {
+  pig:    { url: 'resources/models/animals/Pig.gltf' },
+  cow:    { url: 'resources/models/animals/Cow.gltf' },
+  llama:  { url: 'resources/models/animals/Llama.gltf' },
+  pug:    { url: 'resources/models/animals/Pug.gltf' },
+  sheep:  { url: 'resources/models/animals/Sheep.gltf' },
+  zebra:  { url: 'resources/models/animals/Zebra.gltf' },
+  horse:  { url: 'resources/models/animals/Horse.gltf' },
+  knight: { url: 'resources/models/knight/KnightCharacter.gltf' },
+};
+{
+  const gltfLoader = new GLTFLoader(manager);
+  for (const model of Object.values(models)) {
+    gltfLoader.load(model.url, (gltf) => {
+      model.gltf = gltf;
+    });
+  }
+}
+
+function init() {
+  // 待实现
+}
+

+
这段代码会加载上面所有的模型，LoadingManager 会在完成后调用 init。我们稍后会使用 models 对象来访问已加载的模型，所以每个模型的 GLTFLoader 回调会将加载的数据附加到该模型的信息上。

+
所有模型及其动画目前大约 6.6MB。这是一个相当大的下载量。假设你的服务器支持压缩（本站的服务器就支持），可以将它们压缩到大约 1.4MB。这肯定比 6.6MB 好，但仍然不是很小的数据量。如果我们添加一个进度条，让用户知道还需要等待多长时间，那就好了。

+
所以，让我们添加一个 onProgress 回调。调用时会传入 3 个参数：最后加载的对象的 url，到目前为止已加载的项目数量，以及项目总数。

+
让我们设置一些 HTML 来做加载条

+
<body>
+  <canvas id="c"></canvas>
++  <div id="loading">
++    <div>
++      <div>...loading...</div>
++      <div class="progress"><div id="progressbar"></div></div>
++    </div>
++  </div>
+</body>
+

+
我们会查找 #progressbar div，并将其宽度从 0% 设置到 100% 来显示进度。我们只需要在回调中设置它即可。

+
const manager = new THREE.LoadingManager();
+manager.onLoad = init;
+
++const progressbarElem = document.querySelector('#progressbar');
++manager.onProgress = (url, itemsLoaded, itemsTotal) => {
++  progressbarElem.style.width = `${itemsLoaded / itemsTotal * 100 | 0}%`;
++};
+

+
我们已经设置了 init 在所有模型加载完成时被调用，所以我们可以通过隐藏 #loading 元素来关闭进度条。

+
function init() {
++  // 隐藏加载条
++  const loadingElem = document.querySelector('#loading');
++  loadingElem.style.display = 'none';
+}
+

+
这是一堆用于样式化进度条的 CSS。CSS 使 #loading <div> 占满整个页面并居中其子元素。CSS 创建了一个 .progress 区域来包含进度条。CSS 还为进度条添加了对角条纹的 CSS 动画。

+
#loading {
+  position: absolute;
+  left: 0;
+  top: 0;
+  width: 100%;
+  height: 100%;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  text-align: center;
+  font-size: xx-large;
+  font-family: sans-serif;
+}
+#loading>div>div {
+  padding: 2px;
+}
+.progress {
+  width: 50vw;
+  border: 1px solid black;
+}
+#progressbar {
+  width: 0;
+  transition: width ease-out .5s;
+  height: 1em;
+  background-color: #888;
+  background-image: linear-gradient(
+    -45deg,
+    rgba(255, 255, 255, .5) 25%,
+    transparent 25%,
+    transparent 50%,
+    rgba(255, 255, 255, .5) 50%,
+    rgba(255, 255, 255, .5) 75%,
+    transparent 75%,
+    transparent
+  );
+  background-size: 50px 50px;
+  animation: progressanim 2s linear infinite;
+}
+
+@keyframes progressanim {
+  0% {
+    background-position: 50px 50px;
+  }
+  100% {
+    background-position: 0 0;
+  }
+}
+

+
现在我们有了进度条，让我们来处理模型。这些模型有动画，我们希望能够访问这些动画。动画默认存储在数组中，但我们希望能够通过名称轻松访问它们，所以让我们为每个模型设置一个 animations 属性来实现这一点。当然，这意味着动画必须有唯一的名称。

+
+function prepModelsAndAnimations() {
++  Object.values(models).forEach(model => {
++    const animsByName = {};
++    model.gltf.animations.forEach((clip) => {
++      animsByName[clip.name] = clip;
++    });
++    model.animations = animsByName;
++  });
++}
+
+function init() {
+  // 隐藏加载条
+  const loadingElem = document.querySelector('#loading');
+  loadingElem.style.display = 'none';
+
++  prepModelsAndAnimations();
+}
+

+
让我们显示带动画的模型。

+
与之前加载 glTF 文件的例子不同，这次我们可能想要显示每个模型的多个实例。为此，我们不是像在加载 glTF 文章中那样直接添加加载的 gltf 场景，而是要克隆场景，特别是为蒙皮动画角色克隆场景。幸运的是有一个工具函数 SkeletonUtils.clone 可以用来做这件事。所以，首先我们需要引入这个工具。

+
import * as THREE from 'three';
+import {OrbitControls} from 'three/addons/controls/OrbitControls.js';
+import {GLTFLoader} from 'three/addons/loaders/GLTFLoader.js';
++import * as SkeletonUtils from 'three/addons/utils/SkeletonUtils.js';
+

+
然后我们可以克隆刚刚加载的模型

+
function init() {
+  // 隐藏加载条
+  const loadingElem = document.querySelector('#loading');
+  loadingElem.style.display = 'none';
+
+  prepModelsAndAnimations();
+
++  Object.values(models).forEach((model, ndx) => {
++    const clonedScene = SkeletonUtils.clone(model.gltf.scene);
++    const root = new THREE.Object3D();
++    root.add(clonedScene);
++    scene.add(root);
++    root.position.x = (ndx - 3) * 3;
++  });
+}
+

+
上面的代码中，对于每个模型，我们克隆了加载的 gltf.scene 并将其挂载到一个新的 Object3D 上。我们需要将它挂载到另一个对象上，因为播放动画时，动画会将动画位置应用到加载场景中的节点上，这意味着我们将无法控制这些位置。

+
要播放动画，每个克隆的模型都需要一个 AnimationMixer。一个 AnimationMixer 包含一个或多个 AnimationAction。AnimationAction 引用一个 AnimationClip。AnimationAction 有各种播放设置，可以链接到另一个动作或在动作之间交叉淡入淡出。让我们先获取第一个 AnimationClip 并为它创建一个动作。默认情况下，动作会永远循环播放其片段。

+
+const mixers = [];
+
+function init() {
+  // 隐藏加载条
+  const loadingElem = document.querySelector('#loading');
+  loadingElem.style.display = 'none';
+
+  prepModelsAndAnimations();
+
+  Object.values(models).forEach((model, ndx) => {
+    const clonedScene = SkeletonUtils.clone(model.gltf.scene);
+    const root = new THREE.Object3D();
+    root.add(clonedScene);
+    scene.add(root);
+    root.position.x = (ndx - 3) * 3;
+
++    const mixer = new THREE.AnimationMixer(clonedScene);
++    const firstClip = Object.values(model.animations)[0];
++    const action = mixer.clipAction(firstClip);
++    action.play();
++    mixers.push(mixer);
+  });
+}
+

+
我们调用了 play 来启动动作，并将所有 AnimationMixer 存储在一个名为 mixers 的数组中。最后我们需要在渲染循环中更新每个 AnimationMixer，计算自上一帧以来经过的时间并将其传递给 AnimationMixer.update。

+
+let then = 0;
+function render(now) {
++  now *= 0.001;  // 转换为秒
++  const deltaTime = now - then;
++  then = now;
+
+  if (resizeRendererToDisplaySize(renderer)) {
+    const canvas = renderer.domElement;
+    camera.aspect = canvas.clientWidth / canvas.clientHeight;
+    camera.updateProjectionMatrix();
+  }
+
++  for (const mixer of mixers) {
++    mixer.update(deltaTime);
++  }
+
+  renderer.render(scene, camera);
+
+  requestAnimationFrame(render);
+}
+

+
这样我们应该能加载每个模型并播放其第一个动画了。

+

+  

+  点击此处在新标签页中打开
+

+
+

+
让我们能够检查所有动画。我们将所有片段作为动作添加，然后一次只启用一个。

+
-const mixers = [];
++const mixerInfos = [];
+
+function init() {
+  // 隐藏加载条
+  const loadingElem = document.querySelector('#loading');
+  loadingElem.style.display = 'none';
+
+  prepModelsAndAnimations();
+
+  Object.values(models).forEach((model, ndx) => {
+    const clonedScene = SkeletonUtils.clone(model.gltf.scene);
+    const root = new THREE.Object3D();
+    root.add(clonedScene);
+    scene.add(root);
+    root.position.x = (ndx - 3) * 3;
+
+    const mixer = new THREE.AnimationMixer(clonedScene);
+-    const firstClip = Object.values(model.animations)[0];
+-    const action = mixer.clipAction(firstClip);
+-    action.play();
+-    mixers.push(mixer);
++    const actions = Object.values(model.animations).map((clip) => {
++      return mixer.clipAction(clip);
++    });
++    const mixerInfo = {
++      mixer,
++      actions,
++      actionNdx: -1,
++    };
++    mixerInfos.push(mixerInfo);
++    playNextAction(mixerInfo);
+  });
+}
+
++function playNextAction(mixerInfo) {
++  const {actions, actionNdx} = mixerInfo;
++  const nextActionNdx = (actionNdx + 1) % actions.length;
++  mixerInfo.actionNdx = nextActionNdx;
++  actions.forEach((action, ndx) => {
++    const enabled = ndx === nextActionNdx;
++    action.enabled = enabled;
++    if (enabled) {
++      action.play();
++    }
++  });
++}
+

+
上面的代码为每个 AnimationClip 创建了一个 AnimationAction 数组。它创建了一个 mixerInfos 对象数组，其中包含对每个模型的 AnimationMixer 和所有 AnimationAction 的引用。然后它调用 playNextAction，将除了一个动作之外的所有动作的 enabled 设为 false。

+
我们需要为新数组更新渲染循环

+
-for (const mixer of mixers) {
++for (const {mixer} of mixerInfos) {
+  mixer.update(deltaTime);
+}
+

+
让我们实现按键 1 到 8 来播放每个模型的下一个动画

+
window.addEventListener('keydown', (e) => {
+  const mixerInfo = mixerInfos[e.keyCode - 49];
+  if (!mixerInfo) {
+    return;
+  }
+  playNextAction(mixerInfo);
+});
+

+
现在你应该能点击示例，然后按 1 到 8 键来循环切换每个模型的可用动画。

+

+  

+  点击此处在新标签页中打开
+

+
+

+
这基本上就是本文 three.js 部分的全部内容了。我们讲解了加载多个文件、克隆蒙皮模型以及在它们上播放动画。在真正的游戏中，你需要对 AnimationAction 对象做更多的操作。

+
让我们开始构建游戏基础架构

+
制作现代游戏的一个常见模式是使用实体组件系统（Entity Component System）。在实体组件系统中，游戏中的对象被称为实体（entity），由一组组件（component）组成。你通过决定将哪些组件附加到实体上来构建实体。那么，让我们来构建一个实体组件系统。

+
我们将实体称为 GameObject。它实际上只是组件的集合和一个 three.js Object3D。

+
function removeArrayElement(array, element) {
+  const ndx = array.indexOf(element);
+  if (ndx >= 0) {
+    array.splice(ndx, 1);
+  }
+}
+
+class GameObject {
+  constructor(parent, name) {
+    this.name = name;
+    this.components = [];
+    this.transform = new THREE.Object3D();
+    parent.add(this.transform);
+  }
+  addComponent(ComponentType, ...args) {
+    const component = new ComponentType(this, ...args);
+    this.components.push(component);
+    return component;
+  }
+  removeComponent(component) {
+    removeArrayElement(this.components, component);
+  }
+  getComponent(ComponentType) {
+    return this.components.find(c => c instanceof ComponentType);
+  }
+  update() {
+    for (const component of this.components) {
+      component.update();
+    }
+  }
+}
+

+
调用 GameObject.update 会调用所有组件的 update。

+
我添加 name 只是为了帮助调试，这样在调试器中查看 GameObject 时可以看到一个名称来帮助识别。

+
有些东西可能看起来有点奇怪：

+
GameObject.addComponent 用于创建组件。我不确定这是好主意还是坏主意。我的想法是，组件存在于游戏对象之外没有意义，所以我认为如果创建组件时自动将该组件添加到游戏对象并将游戏对象传递给组件的构造函数会比较好。换句话说，添加组件时你这样做

+
const gameObject = new GameObject(scene, 'foo');
+gameObject.addComponent(TypeOfComponent);
+

+
如果我不这样做，你就需要这样写

+
const gameObject = new GameObject(scene, 'foo');
+const component = new TypeOfComponent(gameObject);
+gameObject.addComponent(component);
+

+
第一种方式更短更自动化，这是更好还是更差，因为它看起来不太常规？我不知道。

+
GameObject.getComponent 通过类型查找组件。这意味着你不能在一个游戏对象上有两个相同类型的组件，或者至少如果你有的话，在不添加其他 API 的情况下只能查找到第一个。

+
一个组件查找另一个组件是很常见的，查找时必须按类型匹配，否则你可能会找到错误的组件。我们也可以给每个组件一个名称，然后按名称查找。这样会更灵活，因为你可以有多个相同类型的组件，但也会更繁琐。同样，我不确定哪种更好。

+
现在来看组件本身。这是它们的基类。

+
// 所有组件的基类
+class Component {
+  constructor(gameObject) {
+    this.gameObject = gameObject;
+  }
+  update() {
+  }
+}
+

+
组件需要基类吗？JavaScript 不像大多数严格类型语言，所以实际上我们可以没有基类，让每个组件在其构造函数中做它想做的事，知道第一个参数始终是组件的游戏对象。如果它不关心游戏对象就不存储它。但我还是觉得这个公共基类是好的。它意味着如果你有一个组件的引用，你总是可以找到它的父游戏对象，从父对象你可以轻松查找其他组件以及查看它的变换。

+
要管理游戏对象，我们可能需要某种游戏对象管理器。你可能认为我们可以只维护一个游戏对象数组，但在真正的游戏中，游戏对象的组件可能在运行时添加和移除其他游戏对象。例如，一个枪游戏对象可能在每次开火时添加一个子弹游戏对象。一个怪物游戏对象可能在被杀死时移除自己。这样我们就会遇到一个问题，我们可能有这样的代码

+
for (const gameObject of globalArrayOfGameObjects) {
+  gameObject.update();
+}
+

+
如果在某个组件的 update 函数中在循环中途向 globalArrayOfGameObjects 添加或移除游戏对象，上面的循环就会失败或产生意外行为。

+
为了防止这个问题，我们需要一些更安全的东西。这是一个尝试。

+
class SafeArray {
+  constructor() {
+    this.array = [];
+    this.addQueue = [];
+    this.removeQueue = new Set();
+  }
+  get isEmpty() {
+    return this.addQueue.length + this.array.length > 0;
+  }
+  add(element) {
+    this.addQueue.push(element);
+  }
+  remove(element) {
+    this.removeQueue.add(element);
+  }
+  forEach(fn) {
+    this._addQueued();
+    this._removeQueued();
+    for (const element of this.array) {
+      if (this.removeQueue.has(element)) {
+        continue;
+      }
+      fn(element);
+    }
+    this._removeQueued();
+  }
+  _addQueued() {
+    if (this.addQueue.length) {
+      this.array.splice(this.array.length, 0, ...this.addQueue);
+      this.addQueue = [];
+    }
+  }
+  _removeQueued() {
+    if (this.removeQueue.size) {
+      this.array = this.array.filter(element => !this.removeQueue.has(element));
+      this.removeQueue.clear();
+    }
+  }
+}
+

+
上面的类允许你向 SafeArray 添加或移除元素，但在遍历时不会直接修改数组本身。新元素会被添加到 addQueue，要移除的元素添加到 removeQueue，然后在循环之外进行实际的添加或移除。

+
使用它，这是我们管理游戏对象的类。

+
class GameObjectManager {
+  constructor() {
+    this.gameObjects = new SafeArray();
+  }
+  createGameObject(parent, name) {
+    const gameObject = new GameObject(parent, name);
+    this.gameObjects.add(gameObject);
+    return gameObject;
+  }
+  removeGameObject(gameObject) {
+    this.gameObjects.remove(gameObject);
+  }
+  update() {
+    this.gameObjects.forEach(gameObject => gameObject.update());
+  }
+}
+

+
有了这些，现在让我们创建第一个组件。这个组件只负责管理像我们刚才创建的那种蒙皮 three.js 对象。为了简单起见，它只有一个方法 setAnimation，接受要播放的动画名称并播放它。

+
class SkinInstance extends Component {
+  constructor(gameObject, model) {
+    super(gameObject);
+    this.model = model;
+    this.animRoot = SkeletonUtils.clone(this.model.gltf.scene);
+    this.mixer = new THREE.AnimationMixer(this.animRoot);
+    gameObject.transform.add(this.animRoot);
+    this.actions = {};
+  }
+  setAnimation(animName) {
+    const clip = this.model.animations[animName];
+    // 关闭所有当前动作
+    for (const action of Object.values(this.actions)) {
+      action.enabled = false;
+    }
+    // 获取或创建该片段的动作
+    const action = this.mixer.clipAction(clip);
+    action.enabled = true;
+    action.reset();
+    action.play();
+    this.actions[animName] = action;
+  }
+  update() {
+    this.mixer.update(globals.deltaTime);
+  }
+}
+

+
你可以看到，它基本上就是我们之前的代码，克隆加载的场景，然后设置一个 AnimationMixer。setAnimation 为特定的 AnimationClip 添加一个 AnimationAction（如果还不存在的话），并禁用所有现有的动作。

+
代码引用了 globals.deltaTime。让我们创建一个 globals 对象

+
const globals = {
+  time: 0,
+  deltaTime: 0,
+};
+

+
并在渲染循环中更新它

+
let then = 0;
+function render(now) {
+  // 转换为秒
+  globals.time = now * 0.001;
+  // 确保 deltaTime 不会太大
+  globals.deltaTime = Math.min(globals.time - then, 1 / 20);
+  then = globals.time;
+

+
上面确保 deltaTime 不超过 1/20 秒的检查是因为，如果我们隐藏标签页，就会得到一个巨大的 deltaTime 值。我们可能隐藏标签页几秒或几分钟，然后当标签页被切回前台时 deltaTime 会非常大，如果我们有这样的代码，可能会把角色传送到游戏世界的另一端

+
position += velocity * deltaTime;
+

+
通过限制 deltaTime 的最大值可以防止这个问题。

+
现在让我们为玩家创建一个组件。

+
class Player extends Component {
+  constructor(gameObject) {
+    super(gameObject);
+    const model = models.knight;
+    this.skinInstance = gameObject.addComponent(SkinInstance, model);
+    this.skinInstance.setAnimation('Run');
+  }
+}
+

+
玩家用 'Run' 调用 setAnimation。为了知道有哪些可用的动画，我修改了之前的示例来打印动画名称

+
function prepModelsAndAnimations() {
+  Object.values(models).forEach(model => {
++    console.log('------->:', model.url);
+    const animsByName = {};
+    model.gltf.animations.forEach((clip) => {
+      animsByName[clip.name] = clip;
++      console.log('  ', clip.name);
+    });
+    model.animations = animsByName;
+  });
+}
+

+
运行后在 JavaScript 控制台中得到了这个列表。

+
 ------->:  resources/models/animals/Pig.gltf
+    Idle
+    Death
+    WalkSlow
+    Jump
+    Walk
+ ------->:  resources/models/animals/Cow.gltf
+    Walk
+    Jump
+    WalkSlow
+    Death
+    Idle
+ ------->:  resources/models/animals/Llama.gltf
+    Jump
+    Idle
+    Walk
+    Death
+    WalkSlow
+ ------->:  resources/models/animals/Pug.gltf
+    Jump
+    Walk
+    Idle
+    WalkSlow
+    Death
+ ------->:  resources/models/animals/Sheep.gltf
+    WalkSlow
+    Death
+    Jump
+    Walk
+    Idle
+ ------->:  resources/models/animals/Zebra.gltf
+    Jump
+    Walk
+    Death
+    WalkSlow
+    Idle
+ ------->:  resources/models/animals/Horse.gltf
+    Jump
+    WalkSlow
+    Death
+    Walk
+    Idle
+ ------->:  resources/models/knight/KnightCharacter.gltf
+    Run_swordRight
+    Run
+    Idle_swordLeft
+    Roll_sword
+    Idle
+    Run_swordAttack
+
幸运的是，所有动物的动画名称都是一样的，这在之后会很方便。目前我们只关心玩家有一个叫 Run 的动画。

+
让我们使用这些组件。这是更新后的 init 函数。它所做的就是创建一个 GameObject 并添加一个 Player 组件。

+
const globals = {
+  time: 0,
+  deltaTime: 0,
+};
++const gameObjectManager = new GameObjectManager();
+
+function init() {
+  // 隐藏加载条
+  const loadingElem = document.querySelector('#loading');
+  loadingElem.style.display = 'none';
+
+  prepModelsAndAnimations();
+
++  {
++    const gameObject = gameObjectManager.createGameObject(scene, 'player');
++    gameObject.addComponent(Player);
++  }
+}
+

+
我们需要在渲染循环中调用 gameObjectManager.update

+
let then = 0;
+function render(now) {
+  // 转换为秒
+  globals.time = now * 0.001;
+  // 确保 deltaTime 不会太大
+  globals.deltaTime = Math.min(globals.time - then, 1 / 20);
+  then = globals.time;
+
+  if (resizeRendererToDisplaySize(renderer)) {
+    const canvas = renderer.domElement;
+    camera.aspect = canvas.clientWidth / canvas.clientHeight;
+    camera.updateProjectionMatrix();
+  }
+
+-  for (const {mixer} of mixerInfos) {
+-    mixer.update(deltaTime);
+-  }
++  gameObjectManager.update();
+
+  renderer.render(scene, camera);
+
+  requestAnimationFrame(render);
+}
+

+
如果我们运行它，会得到一个单独的玩家。

+

+  

+  点击此处在新标签页中打开
+

+
+

+
仅仅为了一个实体组件系统就写了这么多代码，但这是大多数游戏需要的基础设施。

+
让我们添加一个输入系统。与其直接读取按键，我们将创建一个类，让代码的其他部分可以检查 left 或 right。这样我们可以分配多种方式来输入 left 或 right 等。我们先从按键开始

+
// 保持按键/按钮的状态
+//
+// 你可以检查
+//
+//   inputManager.keys.left.down
+//
+// 来查看左键是否当前被按住
+// 你也可以检查
+//
+//   inputManager.keys.left.justPressed
+//
+// 来查看左键是否在这一帧被按下
+//
+// 按键有 'left', 'right', 'a', 'b', 'up', 'down'
+class InputManager {
+  constructor() {
+    this.keys = {};
+    const keyMap = new Map();
+
+    const setKey = (keyName, pressed) => {
+      const keyState = this.keys[keyName];
+      keyState.justPressed = pressed && !keyState.down;
+      keyState.down = pressed;
+    };
+
+    const addKey = (keyCode, name) => {
+      this.keys[name] = { down: false, justPressed: false };
+      keyMap.set(keyCode, name);
+    };
+
+    const setKeyFromKeyCode = (keyCode, pressed) => {
+      const keyName = keyMap.get(keyCode);
+      if (!keyName) {
+        return;
+      }
+      setKey(keyName, pressed);
+    };
+
+    addKey(37, 'left');
+    addKey(39, 'right');
+    addKey(38, 'up');
+    addKey(40, 'down');
+    addKey(90, 'a');
+    addKey(88, 'b');
+
+    window.addEventListener('keydown', (e) => {
+      setKeyFromKeyCode(e.keyCode, true);
+    });
+    window.addEventListener('keyup', (e) => {
+      setKeyFromKeyCode(e.keyCode, false);
+    });
+  }
+  update() {
+    for (const keyState of Object.values(this.keys)) {
+      if (keyState.justPressed) {
+        keyState.justPressed = false;
+      }
+    }
+  }
+}
+

+
上面的代码跟踪按键是按下还是松开，你可以通过检查例如 inputManager.keys.left.down 来判断一个键是否当前被按下。它还为每个键提供了 justPressed 属性，这样你可以检查用户是否刚刚按下了该键。例如跳跃键，你不想知道按钮是否被持续按住，你想知道用户是否现在按下了它。

+
让我们创建一个 InputManager 实例

+
const globals = {
+  time: 0,
+  deltaTime: 0,
+};
+const gameObjectManager = new GameObjectManager();
++const inputManager = new InputManager();
+

+
并在渲染循环中更新它

+
function render(now) {
+
+  ...
+
+  gameObjectManager.update();
++  inputManager.update();
+
+  ...
+}
+

+
它需要在 gameObjectManager.update 之后调用，否则 justPressed 在组件的 update 函数中永远不会为 true。

+
让我们在 Player 组件中使用它

+
+const kForward = new THREE.Vector3(0, 0, 1);
+const globals = {
+  time: 0,
+  deltaTime: 0,
++  moveSpeed: 16,
+};
+
+class Player extends Component {
+  constructor(gameObject) {
+    super(gameObject);
+    const model = models.knight;
+    this.skinInstance = gameObject.addComponent(SkinInstance, model);
+    this.skinInstance.setAnimation('Run');
++    this.turnSpeed = globals.moveSpeed / 4;
+  }
++  update() {
++    const {deltaTime, moveSpeed} = globals;
++    const {transform} = this.gameObject;
++    const delta = (inputManager.keys.left.down  ?  1 : 0) +
++                  (inputManager.keys.right.down ? -1 : 0);
++    transform.rotation.y += this.turnSpeed * delta * deltaTime;
++    transform.translateOnAxis(kForward, moveSpeed * deltaTime);
++  }
+}
+

+
上面的代码使用 Object3D.transformOnAxis 来向前移动玩家。Object3D.transformOnAxis 在本地空间中工作，所以只有当对象在场景的根级别时才有效，如果它是其他东西的子对象则不行 1

+
我们还添加了一个全局 moveSpeed，并基于移动速度计算 turnSpeed。转向速度基于移动速度，以确保角色能够足够快地转向以到达目标。如果 turnSpeed 太小，角色会围绕目标转圈但永远无法到达。我没有费心去计算给定移动速度所需的转向速度，只是猜的。

+
到目前为止的代码可以工作，但如果玩家跑出屏幕就无法知道他们在哪里了。让我们实现如果他们离开屏幕超过一定时间就传送回原点。我们可以使用 three.js 的 Frustum 类来检查一个点是否在摄像机的视锥体内。

+
我们需要从摄像机构建一个视锥体。我们可以在 Player 组件中做这件事，但其他对象可能也想使用它，所以让我们添加另一个带有管理视锥体组件的游戏对象。

+
class CameraInfo extends Component {
+  constructor(gameObject) {
+    super(gameObject);
+    this.projScreenMatrix = new THREE.Matrix4();
+    this.frustum = new THREE.Frustum();
+  }
+  update() {
+    const {camera} = globals;
+    this.projScreenMatrix.multiplyMatrices(
+        camera.projectionMatrix,
+        camera.matrixWorldInverse);
+    this.frustum.setFromProjectionMatrix(this.projScreenMatrix);
+  }
+}
+

+
然后让我们在初始化时设置另一个游戏对象。

+
function init() {
+  // 隐藏加载条
+  const loadingElem = document.querySelector('#loading');
+  loadingElem.style.display = 'none';
+
+  prepModelsAndAnimations();
+
++  {
++    const gameObject = gameObjectManager.createGameObject(camera, 'camera');
++    globals.cameraInfo = gameObject.addComponent(CameraInfo);
++  }
+
+  {
+    const gameObject = gameObjectManager.createGameObject(scene, 'player');
+    gameObject.addComponent(Player);
+  }
+}
+

+
现在我们可以在 Player 组件中使用它了。

+
class Player extends Component {
+  constructor(gameObject) {
+    super(gameObject);
+    const model = models.knight;
+    this.skinInstance = gameObject.addComponent(SkinInstance, model);
+    this.skinInstance.setAnimation('Run');
+    this.turnSpeed = globals.moveSpeed / 4;
++    this.offscreenTimer = 0;
++    this.maxTimeOffScreen = 3;
+  }
+  update() {
+-    const {deltaTime, moveSpeed} = globals;
++    const {deltaTime, moveSpeed, cameraInfo} = globals;
+    const {transform} = this.gameObject;
+    const delta = (inputManager.keys.left.down  ?  1 : 0) +
+                  (inputManager.keys.right.down ? -1 : 0);
+    transform.rotation.y += this.turnSpeed * delta * deltaTime;
+    transform.translateOnAxis(kForward, moveSpeed * deltaTime);
+
++    const {frustum} = cameraInfo;
++    if (frustum.containsPoint(transform.position)) {
++      this.offscreenTimer = 0;
++    } else {
++      this.offscreenTimer += deltaTime;
++      if (this.offscreenTimer >= this.maxTimeOffScreen) {
++        transform.position.set(0, 0, 0);
++      }
++    }
+  }
+}
+

+
在试运行之前还有一件事，让我们为移动端添加触摸屏支持。首先添加一些 HTML 用于触摸

+
<body>
+  <canvas id="c"></canvas>
++  <div id="ui">
++    <div id="left"><img src="../resources/images/left.svg"></div>
++    <div style="flex: 0 0 40px;"></div>
++    <div id="right"><img src="../resources/images/right.svg"></div>
++  </div>
+  <div id="loading">
+    <div>
+      <div>...loading...</div>
+      <div class="progress"><div id="progressbar"></div></div>
+    </div>
+  </div>
+</body>
+

+
以及一些 CSS 来样式化它

+
#ui {
+  position: absolute;
+  left: 0;
+  top: 0;
+  width: 100%;
+  height: 100%;
+  display: flex;
+  justify-items: center;
+  align-content: stretch;
+}
+#ui>div {
+  display: flex;
+  align-items: flex-end;
+  flex: 1 1 auto;
+}
+.bright {
+  filter: brightness(2);
+}
+#left {
+  justify-content: flex-end;
+}
+#right {
+  justify-content: flex-start;
+}
+#ui img {
+  padding: 10px;
+  width: 80px;
+  height: 80px;
+  display: block;
+}
+

+
这里的想法是有一个 #ui div 覆盖整个页面。里面有两个 div，#left 和 #right，它们都几乎是页面宽度的一半，高度为整个屏幕。中间有一个 40px 的分隔。如果用户在左侧或右侧滑动手指，我们需要更新 InputManager 中的 keys.left 和 keys.right。这使整个屏幕都对触摸敏感，这比仅使用小箭头要好。

+
class InputManager {
+  constructor() {
+    this.keys = {};
+    const keyMap = new Map();
+
+    const setKey = (keyName, pressed) => {
+      const keyState = this.keys[keyName];
+      keyState.justPressed = pressed && !keyState.down;
+      keyState.down = pressed;
+    };
+
+    const addKey = (keyCode, name) => {
+      this.keys[name] = { down: false, justPressed: false };
+      keyMap.set(keyCode, name);
+    };
+
+    const setKeyFromKeyCode = (keyCode, pressed) => {
+      const keyName = keyMap.get(keyCode);
+      if (!keyName) {
+        return;
+      }
+      setKey(keyName, pressed);
+    };
+
+    addKey(37, 'left');
+    addKey(39, 'right');
+    addKey(38, 'up');
+    addKey(40, 'down');
+    addKey(90, 'a');
+    addKey(88, 'b');
+
+    window.addEventListener('keydown', (e) => {
+      setKeyFromKeyCode(e.keyCode, true);
+    });
+    window.addEventListener('keyup', (e) => {
+      setKeyFromKeyCode(e.keyCode, false);
+    });
+
++    const sides = [
++      { elem: document.querySelector('#left'),  key: 'left'  },
++      { elem: document.querySelector('#right'), key: 'right' },
++    ];
++
++    const clearKeys = () => {
++      for (const {key} of sides) {
++          setKey(key, false);
++      }
++    };
++
++    const handleMouseMove = (e) => {
++      e.preventDefault();
++      // 这是必要的，因为我们调用了 preventDefault()；
++      // 我们还给 canvas 添加了 tabindex 以便它可以
++      // 获得焦点
++      canvas.focus();
++      window.addEventListener('pointermove', handleMouseMove);
++      window.addEventListener('pointerup', handleMouseUp);
++
++      for (const {elem, key} of sides) {
++        let pressed = false;
++        const rect = elem.getBoundingClientRect();
++        const x = e.clientX;
++        const y = e.clientY;
++        const inRect = x >= rect.left && x < rect.right &&
++                       y >= rect.top && y < rect.bottom;
++        if (inRect) {
++          pressed = true;
++        }
++        setKey(key, pressed);
++      }
++    };
++
++    function handleMouseUp() {
++      clearKeys();
++      window.removeEventListener('pointermove', handleMouseMove, {passive: false});
++      window.removeEventListener('pointerup', handleMouseUp);
++    }
++
++    const uiElem = document.querySelector('#ui');
++    uiElem.addEventListener('pointerdown', handleMouseMove, {passive: false});
++
++    uiElem.addEventListener('touchstart', (e) => {
++      // 阻止滚动
++      e.preventDefault();
++    }, {passive: false});
+  }
+  update() {
+    for (const keyState of Object.values(this.keys)) {
+      if (keyState.justPressed) {
+        keyState.justPressed = false;
+      }
+    }
+  }
+}
+

+
现在我们应该能用左右方向键或在触摸屏上用手指来控制角色了

+

+  

+  点击此处在新标签页中打开
+

+
+

+
理想情况下，如果玩家离开屏幕我们会做其他事情，比如移动摄像机或者离开屏幕就死亡，但这篇文章已经够长了，所以目前传送回中心是最简单的方案。

+
让我们添加一些动物。我们可以像 Player 类似地开始，创建一个 Animal 组件。

+
class Animal extends Component {
+  constructor(gameObject, model) {
+    super(gameObject);
+    const skinInstance = gameObject.addComponent(SkinInstance, model);
+    skinInstance.mixer.timeScale = globals.moveSpeed / 4;
+    skinInstance.setAnimation('Idle');
+  }
+}
+

+
上面的代码设置 AnimationMixer.timeScale 来设置动画相对于移动速度的播放速度。这样如果我们调整移动速度，动画也会相应加速或减速。

+
首先我们可以设置每种动物各一个

+
function init() {
+  // 隐藏加载条
+  const loadingElem = document.querySelector('#loading');
+  loadingElem.style.display = 'none';
+
+  prepModelsAndAnimations();
+  {
+    const gameObject = gameObjectManager.createGameObject(camera, 'camera');
+    globals.cameraInfo = gameObject.addComponent(CameraInfo);
+  }
+
+  {
+    const gameObject = gameObjectManager.createGameObject(scene, 'player');
+    globals.player = gameObject.addComponent(Player);
+    globals.congaLine = [gameObject];
+  }
+
++  const animalModelNames = [
++    'pig',
++    'cow',
++    'llama',
++    'pug',
++    'sheep',
++    'zebra',
++    'horse',
++  ];
++  animalModelNames.forEach((name, ndx) => {
++    const gameObject = gameObjectManager.createGameObject(scene, name);
++    gameObject.addComponent(Animal, models[name]);
++    gameObject.transform.position.x = (ndx + 1) * 5;
++  });
+}
+

+
这样我们会得到站在屏幕上的动物，但我们希望它们做些什么。

+
让我们让它们在玩家靠近时跟随玩家排成康加舞队列。为此我们需要几种状态。

+
    
+
  • 空闲（Idle）：
    
+
    动物等待玩家靠近
    
+
    • 
+
  • 等待队尾（Wait for End of Line）：
    
+
    动物被玩家标记了，但现在需要等待队列末尾的动物过来，这样它才能加入队尾。
    
+
    • 
+
  • 走向队尾（Go to Last）：
    
+
    动物需要走到它跟随的动物之前所在的位置，同时记录它跟随的动物当前的位置历史。
    
+
    • 
+
  • 跟随（Follow）
    
+
    动物需要持续记录它跟随的动物的位置历史，同时移动到它跟随的动物之前所在的位置。
    
+
    • 
+

+
处理这样的不同状态有很多方式。一种常见的方式是使用有限状态机（Finite State Machine），并构建一些类来帮助我们管理状态。

+
那么，让我们来实现它。

+
class FiniteStateMachine {
+  constructor(states, initialState) {
+    this.states = states;
+    this.transition(initialState);
+  }
+  get state() {
+    return this.currentState;
+  }
+  transition(state) {
+    const oldState = this.states[this.currentState];
+    if (oldState && oldState.exit) {
+      oldState.exit.call(this);
+    }
+    this.currentState = state;
+    const newState = this.states[state];
+    if (newState.enter) {
+      newState.enter.call(this);
+    }
+  }
+  update() {
+    const state = this.states[this.currentState];
+    if (state.update) {
+      state.update.call(this);
+    }
+  }
+}
+

+
这是一个简单的类。我们传给它一个包含一堆状态的对象。每个状态有 3 个可选函数：enter、update 和 exit。要切换状态，我们调用 FiniteStateMachine.transition 并传入新状态的名称。如果当前状态有 exit 函数就会被调用。然后如果新状态有 enter 函数也会被调用。最后每一帧 FiniteStateMachine.update 会调用当前状态的 update 函数。

+
让我们用它来管理动物的状态。

+
// 如果 obj1 和 obj2 足够近则返回 true
+function isClose(obj1, obj1Radius, obj2, obj2Radius) {
+  const minDist = obj1Radius + obj2Radius;
+  const dist = obj1.position.distanceTo(obj2.position);
+  return dist < minDist;
+}
+
+// 将 v 限制在 -min 和 +min 之间
+function minMagnitude(v, min) {
+  return Math.abs(v) > min
+      ? min * Math.sign(v)
+      : v;
+}
+
+const aimTowardAndGetDistance = function() {
+  const delta = new THREE.Vector3();
+
+  return function aimTowardAndGetDistance(source, targetPos, maxTurn) {
+    delta.subVectors(targetPos, source.position);
+    // 计算我们想要面朝的方向
+    const targetRot = Math.atan2(delta.x, delta.z) + Math.PI * 1.5;
+    // 沿最短方向旋转
+    const deltaRot = (targetRot - source.rotation.y + Math.PI * 1.5) % (Math.PI * 2) - Math.PI;
+    // 确保转向速度不超过 maxTurn
+    const deltaRotation = minMagnitude(deltaRot, maxTurn);
+    // 将旋转保持在 0 到 Math.PI * 2 之间
+    source.rotation.y = THREE.MathUtils.euclideanModulo(
+        source.rotation.y + deltaRotation, Math.PI * 2);
+    // 返回到目标的距离
+    return delta.length();
+  };
+}();
+
+class Animal extends Component {
+  constructor(gameObject, model) {
+    super(gameObject);
++    const hitRadius = model.size / 2;
+    const skinInstance = gameObject.addComponent(SkinInstance, model);
+    skinInstance.mixer.timeScale = globals.moveSpeed / 4;
++    const transform = gameObject.transform;
++    const playerTransform = globals.player.gameObject.transform;
++    const maxTurnSpeed = Math.PI * (globals.moveSpeed / 4);
++    const targetHistory = [];
++    let targetNdx = 0;
++
++    function addHistory() {
++      const targetGO = globals.congaLine[targetNdx];
++      const newTargetPos = new THREE.Vector3();
++      newTargetPos.copy(targetGO.transform.position);
++      targetHistory.push(newTargetPos);
++    }
++
++    this.fsm = new FiniteStateMachine({
++      idle: {
++        enter: () => {
++          skinInstance.setAnimation('Idle');
++        },
++        update: () => {
++          // 检查玩家是否靠近
++          if (isClose(transform, hitRadius, playerTransform, globals.playerRadius)) {
++            this.fsm.transition('waitForEnd');
++          }
++        },
++      },
++      waitForEnd: {
++        enter: () => {
++          skinInstance.setAnimation('Jump');
++        },
++        update: () => {
++          // 获取康加舞队列末尾的游戏对象
++          const lastGO = globals.congaLine[globals.congaLine.length - 1];
++          const deltaTurnSpeed = maxTurnSpeed * globals.deltaTime;
++          const targetPos = lastGO.transform.position;
++          aimTowardAndGetDistance(transform, targetPos, deltaTurnSpeed);
++          // 检查康加舞队列的最后一个是否靠近
++          if (isClose(transform, hitRadius, lastGO.transform, globals.playerRadius)) {
++            this.fsm.transition('goToLast');
++          }
++        },
++      },
++      goToLast: {
++        enter: () => {
++          // 记住我们跟随的是谁
++          targetNdx = globals.congaLine.length - 1;
++          // 将自己加入康加舞队列
++          globals.congaLine.push(gameObject);
++          skinInstance.setAnimation('Walk');
++        },
++        update: () => {
++          addHistory();
++          // 走向历史记录中最旧的点
++          const targetPos = targetHistory[0];
++          const maxVelocity = globals.moveSpeed * globals.deltaTime;
++          const deltaTurnSpeed = maxTurnSpeed * globals.deltaTime;
++          const distance = aimTowardAndGetDistance(transform, targetPos, deltaTurnSpeed);
++          const velocity = distance;
++          transform.translateOnAxis(kForward, Math.min(velocity, maxVelocity));
++          if (distance <= maxVelocity) {
++            this.fsm.transition('follow');
++          }
++        },
++      },
++      follow: {
++        update: () => {
++          addHistory();
++          // 移除最旧的历史记录并将自己放到那个位置
++          const targetPos = targetHistory.shift();
++          transform.position.copy(targetPos);
++          const deltaTurnSpeed = maxTurnSpeed * globals.deltaTime;
++          aimTowardAndGetDistance(transform, targetHistory[0], deltaTurnSpeed);
++        },
++      },
++    }, 'idle');
++  }
++  update() {
++    this.fsm.update();
++  }
+}
+

+
这是一大段代码，但它实现了上面描述的功能。希望你逐步浏览每个状态时会觉得很清晰。

+
我们还需要添加一些东西。我们需要让玩家将自己添加到 globals 中，以便动物可以找到它，并且我们需要用玩家的 GameObject 来开始康加舞队列。

+
function init() {
+
+  ...
+
+  {
+    const gameObject = gameObjectManager.createGameObject(scene, 'player');
++    globals.player = gameObject.addComponent(Player);
++    globals.congaLine = [gameObject];
+  }
+
+}
+

+
我们还需要计算每个模型的大小

+
function prepModelsAndAnimations() {
++  const box = new THREE.Box3();
++  const size = new THREE.Vector3();
+  Object.values(models).forEach(model => {
++    box.setFromObject(model.gltf.scene);
++    box.getSize(size);
++    model.size = size.length();
+    const animsByName = {};
+    model.gltf.animations.forEach((clip) => {
+      animsByName[clip.name] = clip;
+      // 这个应该在 .blend 文件中修复
+      if (clip.name === 'Walk') {
+        clip.duration /= 2;
+      }
+    });
+    model.animations = animsByName;
+  });
+}
+

+
我们还需要让玩家记录自己的大小

+
class Player extends Component {
+  constructor(gameObject) {
+    super(gameObject);
+    const model = models.knight;
++    globals.playerRadius = model.size / 2;
+

+
现在想想，让动物瞄准康加舞队列的头部而不是特定的玩家可能会更聪明。也许我以后会回来改。

+
刚开始时我对所有动物只用一个半径，但这当然不好，因为哈巴狗比马小得多。所以我添加了不同的大小，但我想要能够可视化这些东西。为此我创建了一个 StateDisplayHelper 组件。

+
它使用 PolarGridHelper 在每个角色周围画一个圆圈，并使用 HTML 元素让每个角色显示一些状态，使用的是将 HTML 元素对齐到 3D 的文章中介绍的技术。

+
首先我们需要添加一些 HTML 来承载这些元素

+
<body>
+  <canvas id="c"></canvas>
+  <div id="ui">
+    <div id="left"><img src="../resources/images/left.svg"></div>
+    <div style="flex: 0 0 40px;"></div>
+    <div id="right"><img src="../resources/images/right.svg"></div>
+  </div>
+  <div id="loading">
+    <div>
+      <div>...loading...</div>
+      <div class="progress"><div id="progressbar"></div></div>
+    </div>
+  </div>
++  <div id="labels"></div>
+</body>
+

+
并添加一些 CSS

+
#labels {
+  position: absolute;  /* 让我们可以在容器内定位自己 */
+  left: 0;             /* 将位置设为容器的左上角 */
+  top: 0;
+  color: white;
+  width: 100%;
+  height: 100%;
+  overflow: hidden;
+  pointer-events: none;
+}
+#labels>div {
+  position: absolute;  /* 让我们可以在容器内定位它们 */
+  left: 0;             /* 将它们的默认位置设为容器的左上角 */
+  top: 0;
+  font-size: large;
+  font-family: monospace;
+  user-select: none;   /* 禁止文本被选中 */
+  text-shadow:         /* 创建黑色描边 */
+    -1px -1px 0 #000,
+     0   -1px 0 #000,
+     1px -1px 0 #000,
+     1px  0   0 #000,
+     1px  1px 0 #000,
+     0    1px 0 #000,
+    -1px  1px 0 #000,
+    -1px  0   0 #000;
+}
+

+
然后这是组件

+
const labelContainerElem = document.querySelector('#labels');
+
+class StateDisplayHelper extends Component {
+  constructor(gameObject, size) {
+    super(gameObject);
+    this.elem = document.createElement('div');
+    labelContainerElem.appendChild(this.elem);
+    this.pos = new THREE.Vector3();
+
+    this.helper = new THREE.PolarGridHelper(size / 2, 1, 1, 16);
+    gameObject.transform.add(this.helper);
+  }
+  setState(s) {
+    this.elem.textContent = s;
+  }
+  setColor(cssColor) {
+    this.elem.style.color = cssColor;
+    this.helper.material.color.set(cssColor);
+  }
+  update() {
+    const {pos} = this;
+    const {transform} = this.gameObject;
+    const {canvas} = globals;
+    pos.copy(transform.position);
+
+    // 获取该位置的归一化屏幕坐标
+    // x 和 y 的范围在 -1 到 +1 之间，x = -1 在左边
+    // y = -1 在底部
+    pos.project(globals.camera);
+
+    // 将归一化位置转换为 CSS 坐标
+    const x = (pos.x *  .5 + .5) * canvas.clientWidth;
+    const y = (pos.y * -.5 + .5) * canvas.clientHeight;
+
+    // 将元素移动到该位置
+    this.elem.style.transform = `translate(-50%, -50%) translate(${x}px,${y}px)`;
+  }
+}
+

+
然后我们可以这样将它们添加到动物上

+
class Animal extends Component {
+  constructor(gameObject, model) {
+    super(gameObject);
++    this.helper = gameObject.addComponent(StateDisplayHelper, model.size);
+
+     ...
+
+  }
+  update() {
+    this.fsm.update();
++    const dir = THREE.MathUtils.radToDeg(this.gameObject.transform.rotation.y);
++    this.helper.setState(`${this.fsm.state}:${dir.toFixed(0)}`);
+  }
+}
+

+
趁此机会让我们也实现用 lil-gui 来开关它们，就像我们在其他地方使用的那样

+
import * as THREE from 'three';
+import {OrbitControls} from 'three/addons/controls/OrbitControls.js';
+import {GLTFLoader} from 'three/addons/loaders/GLTFLoader.js';
+import * as SkeletonUtils from 'three/addons/utils/SkeletonUtils.js';
++import {GUI} from 'three/addons/libs/lil-gui.module.min.js';
+

+
+const gui = new GUI();
++gui.add(globals, 'debug').onChange(showHideDebugInfo);
++showHideDebugInfo();
+
+const labelContainerElem = document.querySelector('#labels');
++function showHideDebugInfo() {
++  labelContainerElem.style.display = globals.debug ? '' : 'none';
++}
++showHideDebugInfo();
+
+class StateDisplayHelper extends Component {
+
+  ...
+
+  update() {
++    this.helper.visible = globals.debug;
++    if (!globals.debug) {
++      return;
++    }
+
+    ...
+  }
+}
+

+
这样我们就有了一个游戏的雏形

+

+  

+  点击此处在新标签页中打开
+

+
+

+
最初我打算做一个贪吃蛇游戏，随着你将动物添加到队列中，游戏会变得更难，因为你需要避免撞到它们。我还会在场景中放置一些障碍物，也许还有围栏或围绕周边的某种屏障。

+
不幸的是，这些动物又长又细。从上面看，这是斑马。

+

+
+
目前的代码使用圆形碰撞，这意味着如果我们有像围栏这样的障碍物，那么这将被视为碰撞

+

+
+
这不行。即使是动物与动物之间也会有同样的问题。

+
我考虑过写一个 2D 矩形对矩形的碰撞系统，但很快意识到这可能需要很多代码。检查两个任意方向的矩形是否重叠本身代码量不大，对于只有少量对象的游戏可能够用，但当对象多了之后你很快就需要优化碰撞检测。首先你可能需要遍历所有可能相互碰撞的对象，检查它们的包围球、包围圆或轴对齐包围盒。一旦你知道哪些对象可能碰撞，你还需要做更多工作来检查它们是否实际碰撞了。通常即使检查包围球也太费劲，你需要某种更好的空间结构来更快地只检查可能彼此靠近的对象。

+
然后，一旦你写了检查两个对象是否碰撞的代码，你通常想要做一个碰撞系统，而不是手动询问"我是否与这些对象碰撞"。碰撞系统会发出事件或调用与碰撞相关的回调。优势在于它可以一次检查所有碰撞，这样没有对象会被检查多次，而如果你手动调用某个"我是否碰撞"的函数，对象往往会被多次检查，浪费时间。

+
制作这样的碰撞系统可能只需要 100-300 行代码来检查任意方向的矩形，但这仍然是很多额外的代码，所以最好先不做。

+
另一个解决方案是尝试找一些从顶部看大致是圆形的其他角色。例如其他人形角色而不是动物，这样圆形检测可能适用于动物之间的碰撞。但对于动物与围栏之间则不行，我们必须添加圆形对矩形的检测。我考虑过把围栏做成灌木丛或柱子，圆形的东西，但那样我可能需要 120 到 200 个来围绕游戏区域，这就会遇到上面提到的优化问题。

+
这就是为什么很多游戏使用现有的解决方案。这些解决方案通常是物理库的一部分。物理库需要知道对象是否相互碰撞，所以在提供物理效果的基础上还可以用来检测碰撞。

+
如果你在寻找解决方案，一些 three.js 示例使用了 ammo.js，这可能是一个选择。

+
另一个解决方案可能是将障碍物放在网格上，让每个动物和玩家只需要查看网格。虽然这样性能会很好，但我觉得这最好留作读者的练习 😜

+
还有一件事，很多游戏系统有一种叫做协程（coroutines）的东西。协程是可以在运行时暂停并在之后继续的例程。

+
让我们让主角发出音符，就像它在通过唱歌带领队伍一样。我们有很多方式可以实现这个，但现在让我们用协程来做。

+
首先，这是一个管理协程的类

+
function* waitSeconds(duration) {
+  while (duration > 0) {
+    duration -= globals.deltaTime;
+    yield;
+  }
+}
+
+class CoroutineRunner {
+  constructor() {
+    this.generatorStacks = [];
+    this.addQueue = [];
+    this.removeQueue = new Set();
+  }
+  isBusy() {
+    return this.addQueue.length + this.generatorStacks.length > 0;
+  }
+  add(generator, delay = 0) {
+    const genStack = [generator];
+    if (delay) {
+      genStack.push(waitSeconds(delay));
+    }
+    this.addQueue.push(genStack);
+  }
+  remove(generator) {
+    this.removeQueue.add(generator);
+  }
+  update() {
+    this._addQueued();
+    this._removeQueued();
+    for (const genStack of this.generatorStacks) {
+      const main = genStack[0];
+      // 处理一个协程移除另一个协程的情况
+      if (this.removeQueue.has(main)) {
+        continue;
+      }
+      while (genStack.length) {
+        const topGen = genStack[genStack.length - 1];
+        const {value, done} = topGen.next();
+        if (done) {
+          if (genStack.length === 1) {
+            this.removeQueue.add(topGen);
+            break;
+          }
+          genStack.pop();
+        } else if (value) {
+          genStack.push(value);
+        } else {
+          break;
+        }
+      }
+    }
+    this._removeQueued();
+  }
+  _addQueued() {
+    if (this.addQueue.length) {
+      this.generatorStacks.splice(this.generatorStacks.length, 0, ...this.addQueue);
+      this.addQueue = [];
+    }
+  }
+  _removeQueued() {
+    if (this.removeQueue.size) {
+      this.generatorStacks = this.generatorStacks.filter(genStack => !this.removeQueue.has(genStack[0]));
+      this.removeQueue.clear();
+    }
+  }
+}
+

+
它和 SafeArray 做了类似的事情，确保在其他协程运行时添加或移除协程是安全的。它还处理嵌套协程。

+
要创建协程，你需要创建一个 JavaScript 生成器函数。生成器函数前面有关键字 function*（星号很重要！）

+
生成器函数可以 yield。例如

+
function* count0To9() {
+  for (let i = 0; i < 10; ++i) {
+    console.log(i);
+    yield;
+  }
+}
+

+
如果我们将这个函数添加到上面的 CoroutineRunner 中，它会每帧打印一个数字（0 到 9），或者更准确地说是每次调用 runner.update 时打印一个。

+
const runner = new CoroutineRunner();
+runner.add(count0To9);
+while(runner.isBusy()) {
+  runner.update();
+}
+

+
协程在完成时会自动被移除。要提前移除一个协程，在它结束之前你需要保持对其生成器的引用，像这样

+
const gen = count0To9();
+runner.add(gen);
+
+// 稍后某个时候
+
+runner.remove(gen);
+

+
无论如何，在玩家中让我们使用协程每隔 0.5 到 1 秒发出一个音符

+
class Player extends Component {
+  constructor(gameObject) {
+
+    ...
+
++    this.runner = new CoroutineRunner();
++
++    function* emitNotes() {
++      for (;;) {
++        yield waitSeconds(rand(0.5, 1));
++        const noteGO = gameObjectManager.createGameObject(scene, 'note');
++        noteGO.transform.position.copy(gameObject.transform.position);
++        noteGO.transform.position.y += 5;
++        noteGO.addComponent(Note);
++      }
++    }
++
++    this.runner.add(emitNotes());
+  }
+  update() {
++    this.runner.update();
+
+  ...
+
+  }
+}
+
+function rand(min, max) {
+  if (max === undefined) {
+    max = min;
+    min = 0;
+  }
+  return Math.random() * (max - min) + min;
+}
+

+
你可以看到我们创建了一个 CoroutineRunner 并添加了一个 emitNotes 协程。这个函数会永远运行，等待 0.5 到 1 秒然后创建一个带有 Note 组件的游戏对象。

+
对于 Note 组件，首先让我们制作一个带有音符的纹理，我们不加载音符图片，而是像画布纹理文章中介绍的那样使用画布来制作。

+
function makeTextTexture(str) {
+  const ctx = document.createElement('canvas').getContext('2d');
+  ctx.canvas.width = 64;
+  ctx.canvas.height = 64;
+  ctx.font = '60px sans-serif';
+  ctx.textAlign = 'center';
+  ctx.textBaseline = 'middle';
+  ctx.fillStyle = '#FFF';
+  ctx.fillText(str, ctx.canvas.width / 2, ctx.canvas.height / 2);
+  return new THREE.CanvasTexture(ctx.canvas);
+}
+const noteTexture = makeTextTexture('♪');
+

+
我们创建的纹理是白色的，这意味着使用时我们可以设置材质的颜色来获得任意颜色的音符。

+
现在我们有了 noteTexture，这是 Note 组件。它使用了 SpriteMaterial 和 Sprite，就像我们在广告牌文章中介绍的那样

+
class Note extends Component {
+  constructor(gameObject) {
+    super(gameObject);
+    const {transform} = gameObject;
+    const noteMaterial = new THREE.SpriteMaterial({
+      color: new THREE.Color().setHSL(rand(1), 1, 0.5),
+      map: noteTexture,
+      side: THREE.DoubleSide,
+      transparent: true,
+    });
+    const note = new THREE.Sprite(noteMaterial);
+    note.scale.setScalar(3);
+    transform.add(note);
+    this.runner = new CoroutineRunner();
+    const direction = new THREE.Vector3(rand(-0.2, 0.2), 1, rand(-0.2, 0.2));
+
+    function* moveAndRemove() {
+      for (let i = 0; i < 60; ++i) {
+        transform.translateOnAxis(direction, globals.deltaTime * 10);
+        noteMaterial.opacity = 1 - (i / 60);
+        yield;
+      }
+      transform.parent.remove(transform);
+      gameObjectManager.removeGameObject(gameObject);
+    }
+
+    this.runner.add(moveAndRemove());
+  }
+  update() {
+    this.runner.update();
+  }
+}
+

+
它所做的就是设置一个 Sprite，然后选择一个随机速度，以该速度移动变换 60 帧，同时通过设置材质的 opacity 使音符淡出。循环结束后，它将变换从场景中移除，并将音符本身从活动游戏对象中移除。

+
最后一件事，让我们添加更多动物

+
function init() {
+
+   ...
+
+  const animalModelNames = [
+    'pig',
+    'cow',
+    'llama',
+    'pug',
+    'sheep',
+    'zebra',
+    'horse',
+  ];
++  const base = new THREE.Object3D();
++  const offset = new THREE.Object3D();
++  base.add(offset);
++
++  // 将动物排列成螺旋形
++  const numAnimals = 28;
++  const arc = 10;
++  const b = 10 / (2 * Math.PI);
++  let r = 10;
++  let phi = r / b;
++  for (let i = 0; i < numAnimals; ++i) {
++    const name = animalModelNames[rand(animalModelNames.length) | 0];
+    const gameObject = gameObjectManager.createGameObject(scene, name);
+    gameObject.addComponent(Animal, models[name]);
++    base.rotation.y = phi;
++    offset.position.x = r;
++    offset.updateWorldMatrix(true, false);
++    offset.getWorldPosition(gameObject.transform.position);
++    phi += arc / r;
++    r = b * phi;
+  }
+

+

+  

+  点击此处在新标签页中打开
+

+
+

+
你可能会问，为什么不用 setTimeout？setTimeout 的问题是它与游戏时钟无关。例如上面我们将帧之间允许的最大时间设为 1/20 秒。我们的协程系统会遵守这个限制，但 setTimeout 不会。

+
当然我们可以自己做一个简单的计时器

+
class Player ... {
+  update() {
+    this.noteTimer -= globals.deltaTime;
+    if (this.noteTimer <= 0) {
+      // 重置计时器
+      this.noteTimer = rand(0.5, 1);
+      // 创建一个带有音符组件的游戏对象
+    }
+  }
+

+
对于这个特定情况这可能更好，但随着你添加越来越多的东西，你的类中会添加越来越多的变量，而使用协程你通常可以触发后就不用管了。

+
鉴于我们动物的简单状态，我们也可以用以下形式的协程来实现它们

+
// 伪代码！
+function* animalCoroutine() {
+   setAnimation('Idle');
+   while(playerIsTooFar()) {
+     yield;
+   }
+   const target = endOfLine;
+   setAnimation('Jump');
+   while(targetIsTooFar()) {
+     aimAt(target);
+     yield;
+   }
+   setAnimation('Walk')
+   while(notAtOldestPositionOfTarget()) {
+     addHistory();
+     aimAt(target);
+     yield;
+   }
+   for(;;) {
+     addHistory();
+     const pos = history.unshift();
+     transform.position.copy(pos);
+     aimAt(history[0]);
+     yield;
+   }
+}
+

+
这样做是可行的，但当然一旦我们的状态不再是线性的，我们就不得不切换到 FiniteStateMachine。

+
我也不确定协程是否应该独立于它们的组件运行。我们可以创建一个全局的 CoroutineRunner 并将所有协程放在上面。但这会使清理变得更难。目前如果游戏对象被移除，它的所有组件都会被移除，因此创建的协程运行器不再被调用，一切都会被垃圾回收。如果我们有一个全局运行器，那么每个组件都有责任移除它添加的任何协程，否则需要某种其他机制将协程注册到特定组件或游戏对象，以便移除一个时也移除其他的。

+
一个正常的游戏引擎会处理更多问题。目前游戏对象或其组件的运行没有顺序。它们只是按添加顺序运行。许多游戏系统会添加优先级，以便可以设置或更改顺序。

+
我们遇到的另一个问题是 Note 从场景中移除其游戏对象的变换。这似乎应该在 GameObject 中发生，因为最初是 GameObject 添加的变换。也许 GameObject 应该有一个 dispose 方法，由 GameObjectManager.removeGameObject 调用？

+
还有一个问题是我们手动调用 gameObjectManager.update 和 inputManager.update。也许应该有一个 SystemManager，这些全局服务可以将自己添加进去，每个服务的 update 函数都会被调用。这样如果我们添加了像 CollisionManager 这样的新服务，我们只需要将它添加到系统管理器中，而不必编辑渲染循环。

+
我会把这些问题留给你。希望这篇文章给了你一些关于制作自己游戏引擎的思路。

+
也许我应该搞一个 Game Jam。如果你点击最后一个示例上方的 jsfiddle 或 codepen 按钮，它们会在这些网站上打开，准备好编辑。添加一些功能，把游戏改成一只哈巴狗带领一群骑士。用骑士的翻滚动画做保龄球，制作一个动物保龄球游戏。制作一个动物接力赛。如果你做出了很酷的游戏，请在下面的评论中发布链接。

+

+[1]: 从技术上讲，如果所有父对象都没有任何平移、旋转或缩放，它仍然可以工作 §。
+

         

       

     


From 2655fa0e905fcf37369bb883347ce3c0e35929f6 Mon Sep 17 00:00:00 2001
From: Dan Rossi 
Date: Thu, 5 Mar 2026 20:44:54 +1100
Subject: [PATCH 3/4] WebXRController: Add grip update event if enabled.
 (#33118)

Co-authored-by: Michael Herzog 
---
 src/renderers/webxr/WebXRController.js | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/src/renderers/webxr/WebXRController.js b/src/renderers/webxr/WebXRController.js
index 3c90d9b79a4d6c..936fd93aa4b51c 100644
--- a/src/renderers/webxr/WebXRController.js
+++ b/src/renderers/webxr/WebXRController.js
@@ -109,6 +109,7 @@ class WebXRController {
 			this._grip.linearVelocity = new Vector3();
 			this._grip.hasAngularVelocity = false;
 			this._grip.angularVelocity = new Vector3();
+			this._grip.eventsEnabled = false;
 
 		}
 
@@ -321,6 +322,17 @@ class WebXRController {
 
 						}
 
+						// grip update event if enabled
+						if ( grip.eventsEnabled ) {
+
+							grip.dispatchEvent( {
+								type: 'gripUpdated',
+								data: inputSource,
+								target: this
+							} );
+
+						}
+
 					}
 
 				}

From 192c265780ea9093724d9be79434a29bfa48efe4 Mon Sep 17 00:00:00 2001
From: Boris Kourtoukov 
Date: Thu, 5 Mar 2026 11:25:47 +0100
Subject: [PATCH 4/4] GLTFExporter: Add `EXT_texture_webp` support. (#33117)

---
 examples/jsm/exporters/GLTFExporter.js      |  23 ++++++++++---
 examples/misc_exporter_gltf.html            |  34 +++++++++++++++++++-
 examples/screenshots/misc_exporter_gltf.jpg | Bin 93551 -> 52007 bytes
 3 files changed, 52 insertions(+), 5 deletions(-)

diff --git a/examples/jsm/exporters/GLTFExporter.js b/examples/jsm/exporters/GLTFExporter.js
index a4c36a1005c5e6..a348e7f4b76a19 100644
--- a/examples/jsm/exporters/GLTFExporter.js
+++ b/examples/jsm/exporters/GLTFExporter.js
@@ -1533,15 +1533,30 @@ class GLTFWriter {
 
 		}
 
-		let mimeType = map.userData.mimeType;
+		const mimeType = map.userData.mimeType;
 
-		if ( mimeType === 'image/webp' ) mimeType = 'image/png';
+		const imageIndex = this.processImage( map.image, map.format, map.flipY, mimeType );
 
 		const textureDef = {
-			sampler: this.processSampler( map ),
-			source: this.processImage( map.image, map.format, map.flipY, mimeType )
+			sampler: this.processSampler( map )
 		};
 
+		if ( mimeType === 'image/webp' ) {
+
+			textureDef.extensions = textureDef.extensions || {};
+			textureDef.extensions[ 'EXT_texture_webp' ] = {
+				source: imageIndex
+			};
+
+			this.extensionsUsed[ 'EXT_texture_webp' ] = true;
+			this.extensionsRequired[ 'EXT_texture_webp' ] = true;
+
+		} else {
+
+			textureDef.source = imageIndex;
+
+		}
+
 		if ( map.name ) textureDef.name = map.name;
 
 		await this._invokeAllAsync( async function ( ext ) {
diff --git a/examples/misc_exporter_gltf.html b/examples/misc_exporter_gltf.html
index 146e0b92e8efde..c2840acc5e3fcf 100644
--- a/examples/misc_exporter_gltf.html
+++ b/examples/misc_exporter_gltf.html
@@ -98,7 +98,7 @@
 			let container;
 
 			let camera, object, object2, material, geometry, scene1, scene2, renderer;
-			let gridHelper, sphere, model, coffeemat;
+			let gridHelper, sphere, model, coffeemat, webpBox;
 
 			const params = {
 				trs: false,
@@ -112,6 +112,7 @@
 				exportObjects: exportObjects,
 				exportSceneObject: exportSceneObject,
 				exportCompressedObject: exportCompressedObject,
+				exportWebPModel: exportWebPModel,
 			};
 
 			init();
@@ -501,6 +502,30 @@
 
 				} );
 
+				// ---------------------------------------------------------------------
+				// Box with WebP texture (EXT_texture_webp)
+				// ---------------------------------------------------------------------
+				const canvas = document.createElement( 'canvas' );
+				canvas.width = 64;
+				canvas.height = 64;
+				const ctx = canvas.getContext( '2d' );
+				ctx.fillStyle = '#005BBB';
+				ctx.fillRect( 0, 0, 64, 64 );
+				ctx.fillStyle = '#FFD500';
+				ctx.fillRect( 16, 16, 32, 32 );
+
+				const webpTexture = new THREE.CanvasTexture( canvas );
+				webpTexture.userData.mimeType = 'image/webp';
+				webpTexture.colorSpace = THREE.SRGBColorSpace;
+
+				webpBox = new THREE.Mesh(
+					new THREE.BoxGeometry( 100, 100, 100 ),
+					new THREE.MeshBasicMaterial( { map: webpTexture } )
+				);
+				webpBox.position.set( 400, 0, 0 );
+				webpBox.name = 'WebPBox';
+				scene1.add( webpBox );
+
 				//
 
 				const gui = new GUI();
@@ -519,6 +544,7 @@
 				h.add( params, 'exportObjects' ).name( 'Export Sphere With Grid' );
 				h.add( params, 'exportSceneObject' ).name( 'Export Scene 1 and Object' );
 				h.add( params, 'exportCompressedObject' ).name( 'Export Coffeemat (from compressed data)' );
+				h.add( params, 'exportWebPModel' ).name( 'Export WebP Model (EXT_texture_webp)' );
 
 				gui.open();
 
@@ -566,6 +592,12 @@
 
 			}
 
+			function exportWebPModel() {
+
+				exportGLTF( webpBox );
+
+			}
+
 			function onWindowResize() {
 
 				camera.aspect = window.innerWidth / window.innerHeight;
diff --git a/examples/screenshots/misc_exporter_gltf.jpg b/examples/screenshots/misc_exporter_gltf.jpg
index ee8072602102db0cf0ed3801d4f1871fd3b3efcd..6866d46dae5fe9656c3826af1346f0313ff0b91a 100644
GIT binary patch
literal 52007
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
AA^-pY

literal 93551
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
sNh7Lhbtm_AgRL;X$LLfse?!)u$NSqZ|06I
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­mub=xnF7I
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