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

Three.js 基礎学習⑦|マウス・スクロールとの連携

1. 今回の学習内容

これまでの学習では、Three.jsを使って3Dモデルを表示したり、時間経過に合わせて回転させたりする方法を学びました。

今回は、さらに一歩進んで、ユーザーの操作に合わせて3Dモデルを動かしていきます。

例えば、次のような表現が可能になります。

  • マウスを動かすと3Dモデルが追従する
  • マウスの位置によってモデルの向きが変わる
  • ページをスクロールすると3Dモデルが回転する
  • スクロールに合わせてモデルが上下に移動する
  • スクロールに合わせてカメラが近づいたり遠ざかったりする

こうした表現は、企業サイトやブランドサイト、採用サイトなどで使われています。

今回は、これまで使用してきたRobotExpressの3Dモデルを使いながら、実際に操作できるページを作成していきます。

2. マウス操作とThree.jsを連携させる

2-1. mousemoveイベントとは?

JavaScriptには、マウスが動いたときに処理を実行するイベントがあります。

それが`mousemove`です。

1//js
2
3window.addEventListener("mousemove", (event) => {
4
5  console.log(event.clientX);
6
7  console.log(event.clientY);
8
9});

このコードでは、マウスが動くたびに現在のマウス座標を取得しています。

それぞれの意味は次のとおりです。

プロパティ 意味
`event.clientX` 画面左端からのマウスの位置
`event.clientY` 画面上端からのマウスの位置

例えば、画面の左上にマウスがある場合は、XとYの値が小さくなります。

反対に、画面の右下にマウスがある場合は、それぞれの値が大きくなります。

2-2. マウス座標を-1〜1に変換する

Three.jsでは、マウスの位置をそのまま使用するよりも、画面の大きさに対して正規化した値を使うと便利です。

ここでいう正規化とは、画面上の座標を一定の範囲に変換することです。

例えば、横方向のマウス位置を次のように変換します。

マウスの位置 変換後の値
画面の左端 -1
画面の中央 0
画面の右端 1

実際のコードはこちらです。

1//js
2
3let mouseX = 0;
4
5let mouseY = 0;
6
7
8
9window.addEventListener("pointermove", (event) => {
10
11  mouseX = (event.clientX / window.innerWidth) * 2 - 1;
12
13
14
15  mouseY = -(event.clientY / window.innerHeight) * 2 + 1;
16
17});

`pointermove`は、マウスだけでなくタッチ操作やペン入力にも対応できるイベントです。

今回はこちらを使用します。

2-3. なぜ2倍して1を引くのか?

横方向の計算式を分解してみましょう。

1//js
2
3mouseX = (event.clientX / window.innerWidth) * 2 - 1;

例えば、画面の横幅が1000pxだった場合です。

**画面の左端にいる場合**

1//js
2
3(0 / 1000) * 2 - 1
4
5
6
7// -1

**画面の中央にいる場合**

1//js
2
3(500 / 1000) * 2 - 1
4
5
6
7// 0

**画面の右端にいる場合**

1//js
2
3(1000 / 1000) * 2 - 1
4
5
6
7// 1

このように、画面の座標を-1〜1の範囲に変換できます。

Y方向は上下の向きを合わせるため、計算式の符号を反転させています。

2-4. マウスの動きに合わせて3Dモデルを回転させる

取得したマウス座標を使って、3Dモデルの回転を変更してみましょう。

1//js
2
3window.addEventListener("pointermove", (event) => {
4
5  const mouseX = (event.clientX / window.innerWidth) * 2 - 1;
6
7
8
9  const mouseY = -(event.clientY / window.innerHeight) * 2 + 1;
10
11
12
13  model.rotation.y = mouseX * 0.5;
14
15  model.rotation.x = mouseY * 0.3;
16
17});

ここでは、マウスのX座標をY軸の回転に、Y座標をX軸の回転に使用しています。

`0.5`や`0.3`は回転の強さを調整する数値です。

数値を大きくすると、マウスの動きに対してモデルが大きく回転します。

ただし、この方法ではマウスを動かした瞬間にモデルの向きが変わります。

より自然な動きを作るには、少しずつ目標の位置に近づける方法がおすすめです。

3. lerpを使って滑らかな動きを作る

3-1. lerpとは?

`lerp`とは、2つの数値の間を補間する処理です。

例えば、現在の値が0で、目標の値が10だった場合、少しずつ10に近づけていきます。

Three.jsには、`lerp()`という便利なメソッドがあります。

1//js
2
3const current = new THREE.Vector3(0, 0, 0);
4
5const target = new THREE.Vector3(10, 0, 0);
6
7
8
9current.lerp(target, 0.1);

この場合、`current`は目標の`target`に向かって少しずつ移動します。

第2引数の`0.1`は、どれくらいの割合で目標に近づけるかを表します。

  • `0.05`:ゆっくり近づく
  • `0.1`:自然な追従
  • `0.3`:素早く近づく
  • `1`:一度で目標値になる

3-2. 数値を補間する方法

回転などの数値を滑らかに変化させたい場合は、次のような書き方もできます。

1//js
2
3currentRotation += (targetRotation - currentRotation) * 0.1;

これは、現在の値と目標の値の差を計算し、その10%だけ現在の値に加算しています。

この処理をアニメーションループの中で繰り返すことで、自然な動きになります。

3-3. マウス追従を滑らかにする

実際にThree.jsで使用すると、次のようになります。

1//js
2
3let targetRotationX = 0;
4
5let targetRotationY = 0;
6
7
8
9let currentRotationX = 0;
10
11let currentRotationY = 0;
12
13
14
15window.addEventListener("pointermove", (event) => {
16
17  targetRotationY = (event.clientX / window.innerWidth) * 2 - 1;
18
19
20
21  targetRotationX = -(event.clientY / window.innerHeight) * 2 + 1;
22
23});
24
25
26
27function animate() {
28
29  requestAnimationFrame(animate);
30
31
32
33  currentRotationX += (targetRotationX * 0.3 - currentRotationX) * 0.05;
34
35
36
37  currentRotationY += (targetRotationY * 0.5 - currentRotationY) * 0.05;
38
39
40
41  model.rotation.x = currentRotationX;
42
43  model.rotation.y = currentRotationY;
44
45
46
47  renderer.render(scene, camera);
48
49}

マウスの位置を目標値として保存し、現在の回転角度を少しずつ近づけています。

これによって、モデルがマウスにゆっくり追従するような表現になります。

4. スクロールとThree.jsを連携させる

4-1. window.scrollYとは?

次は、ページのスクロールと3Dモデルを連携させてみましょう。

JavaScriptでは、現在のスクロール位置を`window.scrollY`で取得できます。

1//js
2
3window.addEventListener("scroll", () => {
4
5  console.log(window.scrollY);
6
7});

例えば、ページを下にスクロールすると数値が増えていきます。

この値を利用すれば、スクロール量に応じて3Dモデルを動かせます。

4-2. スクロール量を0〜1に変換する

スクロール量はページの長さによって変わるため、そのまま使うとページごとに動きの大きさが変わってしまいます。

そこで、スクロール量を0〜1の範囲に変換します。

1//js
2
3const maxScroll =
4
5  document.documentElement.scrollHeight - window.innerHeight;
6
7
8
9const scrollProgress = window.scrollY / maxScroll;

この場合、次のようになります。

スクロール位置 scrollProgress
ページの最上部 0
ページの中央付近 0.5
ページの最下部 1

このように変換することで、ページ全体のスクロール進行度を取得できます。

4-3. スクロールに合わせてモデルを回転させる

取得した`scrollProgress`を使って、モデルを回転させます。

1//js
2
3model.rotation.y = scrollProgress * Math.PI * 2;

`Math.PI * 2`は、360度の回転を表します。

そのため、ページの最上部から最下部までスクロールすると、モデルが1回転します。

回転量を変更したい場合は、次のように調整できます。

1//js
2
3// 180度回転
4
5model.rotation.y = scrollProgress * Math.PI;
6
7
8
9// 360度回転
10
11model.rotation.y = scrollProgress * Math.PI * 2;
12
13
14
15// 720度回転
16
17model.rotation.y = scrollProgress * Math.PI * 4;

4-4. スクロールに合わせてモデルを移動させる

回転だけでなく、位置も変更できます。

1//js
2
3model.position.y = scrollProgress * 2;

これで、スクロールに合わせてモデルが上方向に移動します。

反対方向に移動させたい場合は、数値をマイナスにします。

1//js
2
3model.position.y = -scrollProgress * 2;

4-5. カメラを動かす

Three.jsでは、カメラの位置を変更することでも演出を作れます。

1//js
2
3camera.position.z = 6 - scrollProgress * 3;

この場合、スクロールが進むにつれてカメラがZ方向に近づいていきます。

カメラの位置を変更した場合は、モデルが画面内に収まるように`lookAt()`も調整するとよいでしょう。

5. 実践|マウスとスクロールに連動する3Dサイトを作る

ここまで学んだ内容を組み合わせて、実際に動くWebページを作成してみましょう。

今回の完成イメージは次のとおりです。

  • 背景に3Dモデルを固定表示する
  • マウスを動かすとモデルが滑らかに追従する
  • スクロールするとモデルが回転する
  • スクロールするとモデルの位置とカメラも変化する
  • HTMLのテキストは通常どおりスクロールする

5-1. ファイル構成

今回はHTMLファイル1つで動作するようにします。

1//text
2
3three-scroll/
4
5└── index.html

5-2. HTML・CSS・JavaScript

以下を`index.html`にコピーしてください。

1<!--html-->
2
3<!DOCTYPE html>
4
5<html lang="ja">
6
7<head>
8
9  <meta charset="UTF-8">
10
11  <meta name="viewport" content="width=device-width, initial-scale=1.0">
12
13
14
15  <title>Three.js Scroll Interaction</title>
16
17
18
19  <style>
20
21    * {
22
23      margin: 0;
24
25      padding: 0;
26
27      box-sizing: border-box;
28
29    }
30
31
32
33    body {
34
35      background: #111318;
36
37      color: #ffffff;
38
39      font-family: sans-serif;
40
41    }
42
43
44
45    /* Three.jsの表示領域 */
46
47    #webgl {
48
49      position: fixed;
50
51      inset: 0;
52
53      z-index: 0;
54
55      pointer-events: none;
56
57    }
58
59
60
61    /* HTMLコンテンツ */
62
63    .section {
64
65      position: relative;
66
67      z-index: 1;
68
69
70
71      min-height: 100vh;
72
73
74
75      display: flex;
76
77      flex-direction: column;
78
79      justify-content: center;
80
81
82
83      padding: 10%;
84
85      pointer-events: none;
86
87    }
88
89
90
91    .section h1 {
92
93      font-size: clamp(40px, 7vw, 90px);
94
95      margin-bottom: 20px;
96
97    }
98
99
100
101    .section p {
102
103      font-size: 16px;
104
105      line-height: 2;
106
107      color: #c7c7c7;
108
109    }
110
111
112
113    .section2 {
114
115      align-items: flex-end;
116
117      text-align: right;
118
119    }
120
121
122
123    .section3 {
124
125      align-items: center;
126
127      text-align: center;
128
129    }
130
131
132
133    .number {
134
135      font-size: 14px;
136
137      color: #c5a779;
138
139      margin-bottom: 20px;
140
141    }
142
143  </style>
144
145</head>
146
147
148
149<body>
150
151
152
153  <div id="webgl"></div>
154
155
156
157  <section class="section section1">
158
159    <div class="number">01 / INTRODUCTION</div>
160
161    <h1>THE FUTURE</h1>
162
163    <p>
164
165      A new dimension of digital experience.
166
167      <br>
168
169      Scroll to explore the world.
170
171    </p>
172
173  </section>
174
175
176
177  <section class="section section2">
178
179    <div class="number">02 / MOVEMENT</div>
180
181    <h1>INTERACTION</h1>
182
183    <p>
184
185      Move your mouse and scroll the page.
186
187      <br>
188
189      The 3D world responds to your movement.
190
191    </p>
192
193  </section>
194
195
196
197  <section class="section section3">
198
199    <div class="number">03 / EXPERIENCE</div>
200
201    <h1>EXPLORE</h1>
202
203    <p>
204
205      Three-dimensional elements
206
207      <br>
208
209      create a new web experience.
210
211    </p>
212
213  </section>
214
215
216
217  <script type="importmap">
218
219  {
220
221    "imports": {
222
223      "three": "https://cdn.jsdelivr.net/npm/three@0.170.0/build/three.module.js"
224
225    }
226
227  }
228
229  </script>
230
231
232
233  <script type="module">
234
235
236
237    import * as THREE from "three";
238
239
240
241    import { GLTFLoader } from
242
243      "https://cdn.jsdelivr.net/npm/three@0.170.0/examples/jsm/loaders/GLTFLoader.js";
244
245
246
247
248
249    // Scene
250
251    const scene = new THREE.Scene();
252
253
254
255    scene.background = new THREE.Color("#111318");
256
257
258
259
260
261    // Camera
262
263    const camera = new THREE.PerspectiveCamera(
264
265      45,
266
267      window.innerWidth / window.innerHeight,
268
269      0.1,
270
271      100
272
273    );
274
275
276
277    camera.position.set(0, 1.5, 6);
278
279    camera.lookAt(0, 1, 0);
280
281
282
283
284
285    // Renderer
286
287    const renderer = new THREE.WebGLRenderer({
288
289      antialias: true,
290
291      alpha: true
292
293    });
294
295
296
297    renderer.setSize(
298
299      window.innerWidth,
300
301      window.innerHeight
302
303    );
304
305
306
307    renderer.setPixelRatio(
308
309      Math.min(window.devicePixelRatio, 2)
310
311    );
312
313
314
315    document
316
317      .getElementById("webgl")
318
319      .appendChild(renderer.domElement);
320
321
322
323
324
325    // Light
326
327    const ambientLight = new THREE.AmbientLight(
328
329      0xffffff,
330
331      2
332
333    );
334
335
336
337    scene.add(ambientLight);
338
339
340
341
342
343    const directionalLight = new THREE.DirectionalLight(
344
345      0xffffff,
346
347      3
348
349    );
350
351
352
353    directionalLight.position.set(3, 5, 5);
354
355
356
357    scene.add(directionalLight);
358
359
360
361
362
363    // GLB Model
364
365    const loader = new GLTFLoader();
366
367
368
369    let model = null;
370
371
372
373    loader.load(
374
375      "https://threejs.org/examples/models/gltf/RobotExpressive/RobotExpressive.glb",
376
377
378
379      (gltf) => {
380
381
382
383        model = gltf.scene;
384
385
386
387        model.scale.set(1.2, 1.2, 1.2);
388
389
390
391        model.position.set(0, -1, 0);
392
393
394
395        scene.add(model);
396
397
398
399      },
400
401
402
403      undefined,
404
405
406
407      (error) => {
408
409        console.error("モデルの読み込みに失敗しました", error);
410
411      }
412
413    );
414
415
416
417
418
419    // Mouse Interaction
420
421    let targetMouseX = 0;
422
423    let targetMouseY = 0;
424
425
426
427    let currentMouseX = 0;
428
429    let currentMouseY = 0;
430
431
432
433    window.addEventListener("pointermove", (event) => {
434
435
436
437      targetMouseX =
438
439        (event.clientX / window.innerWidth) * 2 - 1;
440
441
442
443      targetMouseY =
444
445        -(event.clientY / window.innerHeight) * 2 + 1;
446
447
448
449    });
450
451
452
453
454
455    // Scroll Progress
456
457    let scrollProgress = 0;
458
459
460
461    function updateScroll() {
462
463
464
465      const maxScroll =
466
467        document.documentElement.scrollHeight -
468
469        window.innerHeight;
470
471
472
473      if (maxScroll <= 0) {
474
475        scrollProgress = 0;
476
477        return;
478
479      }
480
481
482
483      scrollProgress = THREE.MathUtils.clamp(
484
485        window.scrollY / maxScroll,
486
487        0,
488
489        1
490
491      );
492
493
494
495    }
496
497
498
499
500
501    window.addEventListener("scroll", updateScroll);
502
503
504
505    updateScroll();
506
507
508
509
510
511    // Animation
512
513    function animate() {
514
515
516
517      requestAnimationFrame(animate);
518
519
520
521      if (model) {
522
523
524
525        // Mouse smoothing
526
527        currentMouseX +=
528
529          (targetMouseX - currentMouseX) * 0.05;
530
531
532
533        currentMouseY +=
534
535          (targetMouseY - currentMouseY) * 0.05;
536
537
538
539
540
541        // Mouse rotation
542
543        model.rotation.x = currentMouseY * 0.2;
544
545
546
547        model.rotation.y =
548
549          scrollProgress * Math.PI * 2 +
550
551          currentMouseX * 0.4;
552
553
554
555
556
557        // Scroll movement
558
559        model.position.y =
560
561          -1 + scrollProgress * 0.5;
562
563
564
565
566
567        // Camera movement
568
569        camera.position.z =
570
571          6 - scrollProgress * 1.5;
572
573
574
575        camera.lookAt(0, 0, 0);
576
577
578
579      }
580
581
582
583      renderer.render(scene, camera);
584
585
586
587    }
588
589
590
591    animate();
592
593
594
595
596
597    // Resize
598
599    window.addEventListener("resize", () => {
600
601
602
603      camera.aspect =
604
605        window.innerWidth / window.innerHeight;
606
607
608
609      camera.updateProjectionMatrix();
610
611
612
613      renderer.setSize(
614
615        window.innerWidth,
616
617        window.innerHeight
618
619      );
620
621
622
623      renderer.setPixelRatio(
624
625        Math.min(window.devicePixelRatio, 2)
626
627      );
628
629
630
631      updateScroll();
632
633
634
635    });
636
637
638
639  </script>
640
641
642
643</body>
644
645</html>

5-3. 実装コードの重要ポイント

**① Three.jsのCanvasを固定する**

1//css
2
3#webgl {
4
5  position: fixed;
6
7  inset: 0;
8
9  z-index: 0;
10
11  pointer-events: none;
12
13}

`position: fixed`によって、Three.jsの表示領域を画面に固定しています。

`inset: 0`は、上下左右をすべて0にする指定です。

そのため、画面全体にCanvasが表示されます。

`pointer-events: none`は、Canvasがマウス操作を妨げないようにする指定です。

**② HTMLコンテンツをCanvasより前面に配置する**

1//css
2
3.section {
4
5  position: relative;
6
7  z-index: 1;
8
9}

Canvasの`z-index`が0、HTMLコンテンツの`z-index`が1なので、テキストが3Dモデルの前面に表示されます。

**③ スクロール進行度を取得する**

1//js
2
3const maxScroll =
4
5  document.documentElement.scrollHeight -
6
7  window.innerHeight;
8
9
10
11scrollProgress = THREE.MathUtils.clamp(
12
13  window.scrollY / maxScroll,
14
15  0,
16
17  1
18
19);

`scrollHeight`はページ全体の高さ、`innerHeight`は画面の高さです。

この2つの差から、実際にスクロールできる最大距離を計算しています。

また、`THREE.MathUtils.clamp()`を使用することで、値が0未満や1を超えないように制限しています。

**④ マウスの動きを滑らかにする**

1//js
2
3currentMouseX +=
4
5  (targetMouseX - currentMouseX) * 0.05;

マウスの目標位置と現在の位置の差を計算し、少しずつ目標に近づけています。

これがモデルの自然な追従につながっています。

**⑤ スクロールに合わせて回転させる**

1//js
2
3model.rotation.y =
4
5  scrollProgress * Math.PI * 2 +
6
7  currentMouseX * 0.4;

ここでは、2つの動きを組み合わせています。

  • `scrollProgress * Math.PI * 2`:スクロールによる回転
  • `currentMouseX * 0.4`:マウスによる回転

つまり、スクロールとマウスの両方がモデルの回転に影響しています。

6. 今回覚えておきたいJavaScript・Three.jsの知識

プロパティ・メソッド 役割
`pointermove` ポインターが動いたときのイベント
`event.clientX` 横方向のポインター座標
`event.clientY` 縦方向のポインター座標
`window.scrollY` 現在のスクロール量
`scrollHeight` ページ全体の高さ
`innerHeight` ブラウザ画面の高さ
`MathUtils.clamp()` 数値を指定範囲に制限する
`lerp()` 2つの値の間を補間する
`requestAnimationFrame()` 次の描画タイミングで処理を実行する

今回の内容で特に重要なのは、**ユーザーの操作から数値を取得し、その数値を3Dモデルの位置・回転・大きさに反映させる**という考え方です。

この仕組みを理解すると、Three.jsで実装できる表現の幅が大きく広がります。

7. 応用課題

今回のコードをベースに、次のような変更にも挑戦してみましょう。

課題①:マウスの追従速度を変更する

1//js
2
3currentMouseX +=
4
5  (targetMouseX - currentMouseX) * 0.05;

`0.05`を`0.1`や`0.02`に変更して、動きの違いを確認してみましょう。

課題②:スクロールによる回転量を変更する

1//js
2
3model.rotation.y =
4
5  scrollProgress * Math.PI * 4;

ページの最上部から最下部までスクロールすると、モデルが2回転するようになります。

課題③:スクロールに合わせてモデルを拡大する

1//js
2
3const scale = 1 + scrollProgress * 0.5;
4
5model.scale.set(scale, scale, scale);

スクロールが進むにつれて、モデルが大きくなります。

課題④:スクロールに合わせてモデルを左右に移動させる

1//js
2
3model.position.x = scrollProgress * 3;

スクロールに合わせて、モデルが右方向に移動します。

反対方向に移動させる場合は、`-3`に変更します。

8. まとめ

今回は、マウスとスクロールをThree.jsに連携させる方法を学びました。

重要なポイントは次の4つです。

  • 1. `pointermove`でマウスの座標を取得する
  • 2. 座標を-1〜1の範囲に正規化する
  • 3. `window.scrollY`でスクロール量を取得する
  • 4. 取得した数値をモデルの位置・回転・大きさに反映させる

Three.jsは単に3Dモデルを表示するだけの技術ではありません。

JavaScriptと組み合わせることで、ユーザーの操作に反応するインタラクティブなWebサイトを制作できます。

次回は、さらに表現の幅を広げるために、GSAPとScrollTriggerを組み合わせたアニメーションを学びます。

**次回:Three.js 基礎学習⑧|Three.jsとGSAP・ScrollTriggerの連携**

スクロールに合わせた3Dモデルの回転、カメラ移動、テキストアニメーションなどを組み合わせ、より本格的なWebサイトの演出に挑戦していきます。

MILMONA   MILMONA   MILMONA   MILMONA   MILMONA   
MILMONA   MILMONA   MILMONA   MILMONA   MILMONA