PORTFOLIO & WEB DESIGN MEMORANDOM BLOG   
PORTFOLIO & WEB DESIGN MEMORANDOM BLOG   

Three.js 基礎学習⑤|アニメーションの仕組みを理解する

1. 今回学ぶこと

Three.jsでは、JavaScriptを使って3Dオブジェクトを動かすことができます。

例えば、次のような演出です。

  • オブジェクトを回転させる
  • 上下に浮遊させる
  • 拡大・縮小させる
  • カメラを移動させる
  • マウスの動きに合わせて反応させる
  • スクロールに合わせて3Dモデルを動かす

今回は、これらの動きを作るための基本的な仕組みを学びます。

2. requestAnimationFrame()とは?

Three.jsでアニメーションを作る際に、基本となるのが`requestAnimationFrame()`です。

これは、ブラウザに対して「次の画面描画のタイミングで、この処理を実行してください」と依頼するJavaScriptの機能です。

基本構造のコード

1//js
2
3function animate() {
4
5
6
7  requestAnimationFrame(animate);
8
9
10
11  renderer.render(scene, camera);
12
13
14
15}
16
17
18
19animate();

このコードでは、次の処理を繰り返しています。

  • 1. animate関数を実行する
  • 2. 次の描画タイミングでanimate関数を再実行するよう予約する
  • 3. SceneをCameraを通して描画する
  • 4. 再びanimate関数が実行される

この繰り返しによって、画面が連続的に更新されます。

requestAnimationFrame()が重要な理由

一般的なディスプレイは、1秒間に60回程度画面を更新します。

そのため、アニメーション処理を画面の更新タイミングに合わせることで、滑らかな動きを作りやすくなります。

また、ブラウザの画面が表示されていない場合などには、描画処理が自動的に抑制されることがあります。

回転アニメーションを作る

1//js
2
3function animate() {
4
5
6
7  requestAnimationFrame(animate);
8
9
10
11  box.rotation.y += 0.01;
12
13
14
15  renderer.render(scene, camera);
16
17
18
19}
20
21
22
23animate();

`box.rotation.y += 0.01`によって、1フレームごとにY軸の回転角度を増やしています。

これを繰り返すことで、立方体が回転し続けます。

ただし、この方法ではフレームレートによって回転速度が変わります。

例えば、1秒間に60回更新される環境と120回更新される環境では、1秒間に加算される回転量が異なります。

そこで、次に時間を使ったアニメーションを学びます。

3. Clockを使って時間を管理する

Three.jsには、時間の経過を管理するための`Clock`という機能があります。

これを利用すると、アニメーションを時間に合わせて制御できます。

Clockの基本構造

1//js
2
3const clock = new THREE.Clock();
4
5
6
7function animate() {
8
9
10
11  requestAnimationFrame(animate);
12
13
14
15  const elapsedTime = clock.getElapsedTime();
16
17
18
19  box.rotation.y = elapsedTime;
20
21
22
23  renderer.render(scene, camera);
24
25
26
27}
28
29
30
31animate();

getElapsedTime()とは?

1//js
2
3const elapsedTime = clock.getElapsedTime();

`getElapsedTime()`は、Clockを開始してからの経過時間を秒単位で取得します。

例えば、次のような数値になります。

経過時間 取得する値
1秒 1
2秒 2
3秒 3
5秒 5

この時間を回転角度に利用すると、時間の経過に合わせて回転するアニメーションを作れます。

時間を使った回転アニメーション

1//js
2
3const clock = new THREE.Clock();
4
5
6
7function animate() {
8
9
10
11  requestAnimationFrame(animate);
12
13
14
15  const elapsedTime = clock.getElapsedTime();
16
17
18
19  box.rotation.y = elapsedTime * 0.5;
20
21
22
23  renderer.render(scene, camera);
24
25
26
27}
28
29
30
31animate();

`elapsedTime * 0.5`によって、時間の経過に対して回転速度を調整しています。

数値を大きくすると速くなり、小さくすると遅くなります。

※`THREE.Clock`はThree.js r170でも利用できますが、現在の新しいThree.jsでは、`THREE.Timer`などを使う時間管理方法もあります。ここでは基礎理解のためClockを使用しています。

4. Math.sin()を使って自然な動きを作る

アニメーションでは、単純に数値を増やすだけでなく、自然な動きを表現することも重要です。

そこで利用するのが`Math.sin()`です。

Math.sin()とは?

`Math.sin()`は、サイン波と呼ばれる周期的な数値の変化を作るJavaScriptの数学関数です。

数値は-1〜1の範囲を周期的に変化します。

例えば、次のような動きです。

  • -1:最も低い位置
  • 0:中央の位置
  • 1:最も高い位置

この性質を利用すると、上下に浮遊するようなアニメーションを作れます。

上下に浮遊するアニメーション

1//js
2
3const clock = new THREE.Clock();
4
5
6
7function animate() {
8
9
10
11  requestAnimationFrame(animate);
12
13
14
15  const elapsedTime = clock.getElapsedTime();
16
17
18
19  box.position.y = Math.sin(elapsedTime) * 0.5;
20
21
22
23  renderer.render(scene, camera);
24
25
26
27}
28
29
30
31animate();

コードの解説

1//js
2
3Math.sin(elapsedTime)

経過時間をもとに、-1〜1の範囲で変化する数値を取得しています。

1//js
2
3* 0.5

変化する範囲を半分にしています。

その結果、オブジェクトはY座標が-0.5〜0.5の範囲で上下に動きます。

動く速さを変更する

1//js
2
3box.position.y = Math.sin(elapsedTime * 2) * 0.5;

`elapsedTime * 2`にすると、動きの周期が速くなります。

移動する幅を変更する

1//js
2
3box.position.y = Math.sin(elapsedTime) * 1.5;

最後の数値を大きくすると、上下に移動する幅が大きくなります。

つまり、次のように考えます。

1//js
2
3Math.sin(時間 * 速度) * 移動幅

  • 時間:経過時間
  • 速度:動きの周期を調整
  • 移動幅:移動する範囲を調整

5. Math.cos()を使って動きを作る

`Math.cos()`も、`Math.sin()`と同じように周期的に変化する数値を作る関数です。

基本構造

1//js
2
3box.position.x = Math.cos(elapsedTime) * 2;

この場合、オブジェクトはX軸方向に左右へ移動します。

Math.sin()との違い

Math.sin()とMath.cos()は、波の開始位置が異なります。

関数 時間が0のとき
Math.sin(0) 0
Math.cos(0) 1

この違いを利用すると、複数のオブジェクトの動きに時間差をつけることもできます。

円を描くように移動させる

1//js
2
3box.position.x = Math.cos(elapsedTime) * 2;
4
5box.position.z = Math.sin(elapsedTime) * 2;

X軸とZ軸を同時に変化させることで、オブジェクトが円を描くように移動します。

この仕組みは、惑星の公転や周囲を回るオブジェクトなどの表現にも利用できます。

6. Delta Timeを使って速度を一定にする

ここまで学んだアニメーションでは、時間を使って動きを制御してきました。

さらに重要なのが、`Delta Time`という考え方です。

Delta Timeは、前回のフレームから今回のフレームまでに経過した時間を表します。

なぜDelta Timeが必要なのか?

例えば、次のコードを考えてみましょう。

1//js
2
3box.rotation.y += 0.01;

これは、1フレームごとに0.01ラジアン回転させています。

しかし、1秒間に60回更新される場合と120回更新される場合では、1秒間に回転する量が変わります。

そこで、Delta Timeを使います。

Delta Timeの基本構造

1//js
2
3const clock = new THREE.Clock();
4
5function animate() {
6
7  requestAnimationFrame(animate);
8
9  const deltaTime = clock.getDelta()
10
11  box.rotation.y += deltaTime * 1;
12
13  renderer.render(scene, camera);
14
15}
16
17animate();

`getDelta()`は、前回取得してからの経過時間を秒単位で取得します。

例えば、約60FPSで動作している場合は、約0.016秒になります。

1//js
2
3box.rotation.y += deltaTime * 1;

この場合、1秒あたり約1ラジアン回転するように制御できます。

Delta Timeを使うメリット

  • フレームレートの違いによる速度差を抑えられる
  • 動作環境が異なっても速度を調整しやすい
  • アニメーションの管理がしやすくなる

※フレーム落ちが発生した場合、Delta Timeが大きくなることがあります。必要に応じて最大値を制限する方法もあります。

7. Easingを使って滑らかな動きを作る

Webサイトのアニメーションでは、動き始めや停止時の速度変化も重要です。

例えば、ボタンを押したときに急に移動するのではなく、ゆっくり動き始めて滑らかに停止するような演出です。

このような速度変化をEasing(イージング)と呼びます。

LinearとEasingの違い

**Linear**

一定の速度で移動します。

1//js
2
3object.position.x += 0.01;

**Easing**

時間に合わせて速度を変化させます。

例えば、GSAPでは次のように記述できます。

1//js
2
3gsap.to(box.position, {
4
5  x: 2,
6
7  duration: 2,
8
9  ease: "power2.out"
10
11});

このコードでは、2秒かけてX座標を2まで移動させています。

`power2.out`によって、最初は速く、最後に向かってゆっくり停止します。

よく使うEasing

Easing 特徴
none 一定速度
power1.out 控えめな減速
power2.out 自然な減速
power3.out 強めの減速
back.out 少し行き過ぎて戻る
elastic.out 弾むような動き
bounce.out 跳ねるような動き

Easingを使い分けることで、Webサイトの印象を大きく変えられます。

8. 実践|複数のアニメーションを組み合わせる

ここまで学んだ内容を組み合わせて、3Dオブジェクトを動かしてみましょう。

完成イメージ

  • 中央に立方体を配置
  • Y軸を中心に回転
  • 上下に浮遊
  • 少しずつ拡大・縮小
  • X軸とZ軸を使って円を描くように移動

HTML

1<!--html-->
2
3
4<!DOCTYPE html>
5
6<html lang="ja">
7
8<head>
9
10  <meta charset="UTF-8">
11
12  <meta name="viewport" content="width=device-width, initial-scale=1.0">
13
14
15
16  <title>Three.js Practice 05</title>
17
18
19
20  <style>
21
22    body {
23
24      margin: 0;
25
26      overflow: hidden;
27
28      background: #111318;
29
30    }
31
32  </style>
33
34
35
36  <script type="importmap">
37
38  {
39
40    "imports": {
41
42      "three": "https://cdn.jsdelivr.net/npm/three@0.170.0/build/three.module.js"
43
44    }
45
46  }
47
48  </script>
49
50</head>
51
52
53
54<body>
55
56  <script type="module" src="./main.js"></script>
57
58</body>
59
60</html>

JavaScript(main.js)

1//js
2
3import * as THREE from "three";
4
5
6
7// Scene
8
9const scene = new THREE.Scene();
10
11
12
13scene.background = new THREE.Color(0x111318);
14
15
16
17// Camera
18
19const camera = new THREE.PerspectiveCamera(
20
21  45,
22
23  window.innerWidth / window.innerHeight,
24
25  0.1,
26
27  100
28
29);
30
31
32
33camera.position.set(0, 2, 8);
34
35
36
37camera.lookAt(0, 0, 0);
38
39
40
41// Renderer
42
43const renderer = new THREE.WebGLRenderer({
44
45  antialias: true
46
47});
48
49
50
51renderer.setSize(
52
53  window.innerWidth,
54
55  window.innerHeight
56
57);
58
59
60
61renderer.setPixelRatio(
62
63  Math.min(window.devicePixelRatio, 2)
64
65);
66
67
68
69document.body.appendChild(renderer.domElement);
70
71
72
73// Light
74
75const ambientLight = new THREE.AmbientLight(
76
77  0xffffff,
78
79  1.5
80
81);
82
83
84
85scene.add(ambientLight);
86
87
88
89const directionalLight = new THREE.DirectionalLight(
90
91  0xffffff,
92
93  3
94
95);
96
97
98
99directionalLight.position.set(3, 5, 5);
100
101
102
103scene.add(directionalLight);
104
105
106
107// Geometry
108
109const geometry = new THREE.BoxGeometry(
110
111  1.5,
112
113  1.5,
114
115  1.5
116
117);
118
119
120
121// Material
122
123const material = new THREE.MeshStandardMaterial({
124
125  color: 0xc5a779,
126
127  metalness: 0.6,
128
129  roughness: 0.25
130
131});
132
133
134
135// Mesh
136
137const box = new THREE.Mesh(
138
139  geometry,
140
141  material
142
143);
144
145
146
147scene.add(box);
148
149
150
151// Clock
152
153const clock = new THREE.Clock();
154
155
156
157// Animation
158
159function animate() {
160
161
162
163  requestAnimationFrame(animate);
164
165
166
167  // 経過時間
168
169  const elapsedTime = clock.getElapsedTime();
170
171
172
173  // 回転
174
175  box.rotation.y = elapsedTime * 0.5;
176
177  box.rotation.x = elapsedTime * 0.2;
178
179
180
181  // 上下移動
182
183  box.position.y = Math.sin(elapsedTime) * 0.5;
184
185
186
187  // 円を描くように移動
188
189  box.position.x = Math.cos(elapsedTime * 0.5) * 1.5;
190
191
192
193  // 拡大・縮小
194
195  const scale = 1 + Math.sin(elapsedTime * 2) * 0.1;
196
197
198
199  box.scale.set(scale, scale, scale);
200
201
202
203  renderer.render(scene, camera);
204
205
206
207}
208
209
210
211animate();
212
213
214
215// Window Resize
216
217window.addEventListener("resize", () => {
218
219
220
221  camera.aspect = window.innerWidth / window.innerHeight;
222
223
224
225  camera.updateProjectionMatrix();
226
227
228
229  renderer.setSize(
230
231    window.innerWidth,
232
233    window.innerHeight
234
235  );
236
237
238
239  renderer.setPixelRatio(
240
241    Math.min(window.devicePixelRatio, 2)
242
243  );
244
245
246
247});

コードの重要ポイント

**① 経過時間を取得する**

1//js
2
3const elapsedTime = clock.getElapsedTime();

アニメーションを開始してからの経過時間を取得します。

**② 回転させる**

1//js
2
3box.rotation.y = elapsedTime * 0.5;

時間の経過に合わせて、Y軸の回転角度を変更しています。

**③ 上下に移動させる**

1//js
2
3box.position.y = Math.sin(elapsedTime) * 0.5;

サイン波を利用して、自然な上下運動を作っています。

**④ 円を描くように移動させる**

1//js
2
3box.position.x = Math.cos(elapsedTime * 0.5) * 1.5;

X座標を時間に合わせて変化させています。

今回のコードではZ座標を固定しているため、厳密には円ではなく左右方向の往復運動です。

円を描くように移動させる場合は、Z座標も変化させます。

1//js
2
3box.position.x = Math.cos(elapsedTime * 0.5) * 1.5;
4
5box.position.z = Math.sin(elapsedTime * 0.5) * 1.5;

**⑤ 拡大・縮小させる**

1//js
2
3const scale = 1 + Math.sin(elapsedTime * 2) * 0.1;
4
5box.scale.set(scale, scale, scale);

サイン波を利用して、オブジェクトの大きさを滑らかに変化させています。

9. アニメーションを作るときの考え方

Three.jsでアニメーションを作る場合、次のように考えると整理しやすくなります。

作りたい動き 使用する機能
回転 rotation
移動 position
拡大・縮小 scale
上下の浮遊 Math.sin()
円運動 Math.sin()・Math.cos()
時間の管理 Clock
描画の繰り返し requestAnimationFrame()
滑らかな速度変化 Easing・GSAP

重要なのは、オブジェクトのどのプロパティを、どのタイミングで、どのように変化させるかという考え方です。

10. 今回のまとめ

今回学んだ内容を整理します。

  • requestAnimationFrame():次の画面描画タイミングで処理を繰り返す
  • Clock:経過時間を管理する
  • getElapsedTime():開始からの経過時間を取得する
  • getDelta():前回からの経過時間を取得する
  • Math.sin():周期的な動きを作る
  • Math.cos():周期的な動きを作る
  • Easing:アニメーションの速度変化を調整する

これらを組み合わせることで、自然で滑らかな3Dアニメーションを作れるようになります。

11. 練習課題

実際にコードを書き換えて、動きの違いを確認してみましょう。

**課題①:回転速度を変更する**

1//js
2
3box.rotation.y = elapsedTime * 2;

回転速度を変更して、動きの違いを確認してください。

**課題②:上下の移動幅を変更する**

1//js
2
3box.position.y = Math.sin(elapsedTime) * 1.5;

上下の移動幅を大きくしてみましょう。

**課題③:円運動を作る**

1//js
2
3box.position.x = Math.cos(elapsedTime) * 2;
4
5box.position.z = Math.sin(elapsedTime) * 2;

X軸とZ軸を組み合わせて、円を描くように移動させてください。

**課題④:複数のオブジェクトを動かす**

球体を追加して、立方体とは異なる速度で回転させてみましょう。

**課題⑤:動きに変化をつける**

Math.sin()の数値を変更して、ゆっくり浮遊する動きや、速く上下する動きを作ってみましょう。


**次回:Three.js 基礎学習⑥|GLB・GLTFモデルの読み込み**

次回は、Blenderなどの3Dソフトで作成したモデルをThree.jsに読み込む方法を学びます。

自分で作った3DモデルをWebサイトに表示できるようになるため、実践的な内容です。

MILMONA   MILMONA   MILMONA   MILMONA   MILMONA   
MILMONA   MILMONA   MILMONA   MILMONA   MILMONA