经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置：技术经验 » JS/JS库/框架 » three.js » 查看文章
Three.js 进阶之旅：新春特典-Rabbit craft go 🐇
来源：cnblogs　　作者：Dragonir　　时间：2023/1/28 8:45:34　　对本文有异议

声明：本文涉及图文和模型素材仅用于个人学习、研究和欣赏，请勿二次修改、非法传播、转载、出版、商用、及进行其他获利行为。

摘要

兔年到了，祝大家身体健，康万事顺利。本文内容作为兔年新春纪念页面，将使用 Three.js 及 其他前端开发知识，创建一个以兔子为主题的 3D 简单的趣味页面 Rabbit craft go。本文内容包括使用纯代码创建三维浮岛、小河、树木、兔子、胡萝卜以及兔子的运动交互、浮岛的动画效果等。本文包含的知识点相对比较简单，主要包括 使用 Three.js 网格立方体搭建三维卡通场景、键盘事件的监听与三维场景动画的结合等，如果仔细阅读并实践过本专栏《Three.js 进阶之旅》的话，非常容易掌握。

?? 兔子造型来源于 Three.js开源论坛，页面整体造型灵感来源于《我的世界》，页面名称灵感来源于游戏《Lara Craft Go》。

效果

我们先来看看实现效果，页面加载完成后是一个游戏操作提示界面，可以通过键盘 ? 空格键 及 W、 A、 S、 D 或方向键操作小兔子运动。点击开始按钮后，游戏提示界面消失，可以看到倒三角造型的天空浮岛及浮岛上方的树木 ??、河流 ?、桥 ??、胡萝卜 ??、兔子 ?? 等元素，接着摄像机镜头 ?? 自动拉近并聚焦到兔子上。

按照操作提示界面的按键，可以操作兔子进行前进、转向、跳跃等运动，当兔子的运动位置触碰到胡萝卜时，胡萝卜会消失同时兔子会进行跳跃运动。当兔子运动到小河或者超出浮岛范围时，兔子则会坠落到下方。

打开以下链接，在线预览效果，大屏访问效果更佳。

本专栏系列代码托管在 Github 仓库【threejs-odessey】，后续所有目录也都将在此仓库中更新。

?? 代码仓库地址：git@github.com:dragonir/threejs-odessey.git

实现

文章篇幅有限，因此删减了三维模型的位置信息等细节调整代码，只提供构建三维模型的整体思路逻辑，想了解该部分内容的详细介绍可以阅读本专栏前几篇文章及阅读本文配套源码。现在，我们来看看整个页面的实现详细步骤：

页面结构

Rabbit Craft Go 页面的整体结构如下，其中 canvas.webgl 是用于渲染场景的容器、剩余标签都是一些装饰元素或提示语。

  1. <canvas class="webgl"></canvas>
  2. <div class="mask" id="mask">
  3.   <div class="box">
  4.     <div class="keyboard">
  5.       <div class="row"><span class="key">W/↑</span></div>
  6.       <div class="row"><span class="key">A/←</span><span class="key">S/↓</span><span class="key">D/→</span></div>
  7.       <div class="row"><span class="key space">space</span></div>
  8.     </div>
  9.     <p class="tips"><b>W</b>: 行走&emsp;<b>S</b>: 停止&emsp;<b>A</b>: 向左转&emsp;<b>D</b>: 向右转&emsp;<b>空格键</b>: 跳跃</p>
  10.     <p class="start"><button class="button" id="start_button">开始</button></p>
  11.   </div>
  12. </div>
  13. <a class='github' href='https://github.com/dragonir/threejs-odessey' target='_blank' rel='noreferrer'>
  14.   <span class='author'>three.js odessey</span>
  15. </a>
  16. <h1 class="title">RABBIT CRAFT GO!</h1>
  17. <div class="banner"><i></i></div>

场景初始化

场景初始化过程中，我们引入必需的开发资源，并初始化渲染场景、相机、控制器、光照、页面缩放适配等。其中外部资源的引入，其中 OrbitControls 用于页面镜头缩放及移动控制；TWEEN 和 Animations 用于生成镜头补间动画，也就是刚开始时浮岛由远及近的镜头切换动画中效果；Island、Carrot、Rabbit、Waterfall 等是用来构建三维世界的类。为了使场景更加卡通化，使用了 THREE.sRGBEncoding 渲染效果。场景中添加了两种光源，其中 THREE.DirectionalLight 用来生成阴影效果。

  1. import * as THREE from 'three';
  2. import { OrbitControls } from 'three/examples/jsm/controls/OrbitControls';
  3. import { TWEEN } from "three/examples/jsm/libs/tween.module.min.js";
  4. import Animations from './environment/animation';
  5. import Island from './environment/island';
  6. import Carrot from './environment/carrot';
  7. import Rabbit from './environment/rabbit';
  8. import Waterfall from './environment/waterfall';
  10. // 初始化渲染器
  11. const canvas = document.querySelector('canvas.webgl');
  12. const renderer = new THREE.WebGLRenderer({
  13.   canvas: canvas,
  14.   antialias: true,
  15.   alpha: true
  16. });
  17. renderer.setSize(sizes.width, sizes.height);
  18. renderer.setPixelRatio(Math.min(window.devicePixelRatio, 2));
  19. renderer.outputEncoding = THREE.sRGBEncoding;
  20. renderer.shadowMap.enabled = true;
  21. renderer.shadowMap.needsUpdate = true;
  23. // 初始化场景
  24. const scene = new THREE.Scene();
  26. // 初始化相机
  27. const camera = new THREE.PerspectiveCamera(60, sizes.width / sizes.height, 1, 5000)
  28. camera.position.set(-2000, -250, 2000);
  30. // 镜头控制器
  31. const controls = new OrbitControls(camera, renderer.domElement);
  32. controls.target.set(0, 0, 0);
  33. controls.enableDamping = true;
  34. controls.enablePan = false;
  35. controls.dampingFactor = 0.15;
  37. // 页面缩放事件监听
  38. window.addEventListener('resize', () => {
  39.   sizes.width = window.innerWidth;
  40.   sizes.height = window.innerHeight;
  41.   // 更新渲染
  42.   renderer.setSize(sizes.width, sizes.height);
  43.   renderer.setPixelRatio(Math.min(window.devicePixelRatio, 2))
  44.   // 更新相机
  45.   camera.aspect = sizes.width / sizes.height;
  46.   camera.updateProjectionMatrix();
  47. });
  49. // 光照
  50. const ambientLight = new THREE.AmbientLight(0xffffff, 1);
  51. scene.add(ambientLight);
  52. const directionalLight = new THREE.DirectionalLight(0xffffff, 1.5);
  53. scene.add(directionalLight);

创建浮岛

如以下 ?? 两幅图所示，整个浮岛造型是一个四棱椎，整体分为四部分，顶部是由地面和河流构成的四方体、底部三块是倒置的三角。生成这些三维模型的其实也并没有多少技巧，就像搭积木一样使用 Three.js 提供的立方体网格通过计算拼接到一起即可。类 Island 包含一个方法 generate 用于创建上述三维模型，并将所创建模型添加到三维分组 floorMesh 中用于外部调用，其中棱柱部分是通过 CylinderBufferGeometry 来实现的。

  1. export default class Island {
  2.   constructor() {
  3.     this.floorMesh = new THREE.Group();
  4.     this.generate();
  5.   }
  7.   generate() {
  8.     // 左侧地面
  9.     const leftFieldMat = new THREE.MeshToonMaterial({
  10.       color: 0x015521d,
  11.       side: THREE.DoubleSide,
  12.     });
  13.     const leftFieldGeom = new THREE.BoxBufferGeometry(800, 30, 1800);
  14.     this.leftFieldMesh = new THREE.Mesh(leftFieldGeom, leftFieldMat);
  15.     // 右侧地面
  16.     this.rightFieldMesh = this.leftFieldMesh.clone();
  17.     const mapCapMat = new THREE.MeshMatcapMaterial({
  18.       matcap: new THREE.TextureLoader().load('./images/matcap.png'),
  19.       side: THREE.DoubleSide
  20.     })
  21.     // 顶部棱柱
  22.     const topFieldGeom = new THREE.CylinderBufferGeometry(1200, 900, 200, 4, 4);
  23.     this.topFieldMesh = new THREE.Mesh(topFieldGeom, mapCapMat);
  24.     // 中间棱柱
  25.     const middleFieldGeom = new THREE.CylinderBufferGeometry(850, 600, 200, 4, 4);
  26.     this.middleFieldMesh = new THREE.Mesh(middleFieldGeom, mapCapMat);
  27.     // 底部棱锥
  28.     const bottomFieldGeom = new THREE.ConeBufferGeometry(550, 400, 4);
  29.     this.bottomFieldMesh = new THREE.Mesh(bottomFieldGeom, mapCapMat);
  30.     // 河面
  31.     const strGroundMat = new THREE.MeshLambertMaterial({
  32.       color: 0x75bd2d,
  33.       side: THREE.DoubleSide,
  34.     });
  35.     const strCroundGeom = new THREE.BoxBufferGeometry(205, 10, 1800);
  36.     this.strGroundMesh = new THREE.Mesh(strCroundGeom, strGroundMat);
  38.     // 小河
  39.     const streamMat = new THREE.MeshLambertMaterial({
  40.       color: 0x0941ba,
  41.       side: THREE.DoubleSide,
  42.     });
  43.     const streamGeom = new THREE.BoxBufferGeometry(200, 16, 1800);
  44.     this.streamMesh = new THREE.Mesh(streamGeom, streamMat);
  45.     // ...
  46.   }
  47. };

浮岛俯视图是一个正方形。

浮岛侧视图是一个倒三角形。

创建水流

接下来，我们为河流添加一个小瀑布，使场景动起来。流动的瀑布三维水滴 ?? 滴落效果的是通过创建多个限定范围内随机位置的 THREE.BoxBufferGeometry 来实现水滴模型，然后通过水滴的显示隐藏动画实现视觉上的水滴坠落效果。Waterfall 类用于创建单个水滴，它为水滴初始化随机位置和速度，并提供一个 update 方法用来更新它们。

  1. export default class Waterfall {
  2.   constructor (scene) {
  3.     this.scene = scene;
  4.     this.drop = null;
  5.     this.generate();
  6.   }
  7.   generate () {
  8.     this.geometry = new THREE.BoxBufferGeometry(15, 50, 5);
  9.     this.material = new THREE.MeshLambertMaterial({ color: 0x0941ba });
  10.     this.drop = new THREE.Mesh(this.geometry, this.material);
  11.     this.drop.position.set((Math.random() - 0.5) * 200, -50, 900 + Math.random(1, 50) * 10);
  12.     this.scene.add(this.drop);
  13.     this.speed = 0;
  14.     this.lifespan = Math.random() * 50 + 50;
  15.     this.update = function() {
  16.       this.speed += 0.07;
  17.       this.lifespan--;
  18.       this.drop.position.x += (5 - this.drop.position.x) / 70;
  19.       this.drop.position.y -= this.speed;
  20.     };
  21.   }
  22. };

完成水滴创建后，不要忘了需要在页面重绘动画 tick 方法中像这样更新已创建的水滴数组 drops，使其看起来生成向下流动坠落的效果。

  1. for (var i = 0; i < drops.length; i++) {
  2.   drops[i].update();
  3.   if (drops[i].lifespan < 0) {
  4.     scene.remove(scene.getObjectById(drops[i].drop.id));
  5.     drops.splice(i, 1);
  6.   }
  7. }

创建桥

在河流上方添加一个小木桥 ??，这样小兔子就可以通过木桥在小河两边移动了。 类 Bridge 通过 generate 方法创建一个小木桥，并通过三维模型组 bridgeMesh 将其导出，我们可以在上面创建的 Island 类中使用它，将其添加到三维场景中。

  1. export default class Bridge {
  2.   constructor() {
  3.     this.bridgeMesh = new THREE.Group();
  4.     this.generate();
  5.   }
  6.   generate() {
  7.     var woodMat = new THREE.MeshLambertMaterial({
  8.       color: 0x543b14,
  9.       side: THREE.DoubleSide
  10.     });
  11.     // 木头
  12.     for (var i = 0; i < 15; i++) {
  13.       var blockGeom = new THREE.BoxBufferGeometry(10, 3, 70);
  14.       var block = new THREE.Mesh(blockGeom, woodMat);
  15.       this.bridgeMesh.add(block);
  16.     }
  17.     // 桥尾
  18.     var geometry_rail_v = new THREE.BoxBufferGeometry(3, 20, 3);
  19.     var rail_1 = new THREE.Mesh(geometry_rail_v, woodMat);
  20.     var rail_2 = new THREE.Mesh(geometry_rail_v, woodMat);
  21.     var rail_3 = new THREE.Mesh(geometry_rail_v, woodMat);
  22.     var rail_4 = new THREE.Mesh(geometry_rail_v, woodMat);
  23.     // ...
  24.   }
  25. }

创建树

从预览动图和页面可以看到，浮岛上共有两种树 ??，绿色的高树和粉红色的矮树，树的实现也非常简单，是使用了两个 BoxBufferGeometry 拼接到一起。类 Tree 和 LeafTree 分别用于生成这两种树木，接收参数 (x, y, z) 分别表示树木在场景中的位置信息。我们可以在 Island 辅导上添加一些树木，构成浮岛上的一片小森林。

  1. export default class Tree {
  2.   constructor(x, y, z) {
  3.     this.x = x;
  4.     this.y = y;
  5.     this.z = z;
  6.     this.treeMesh = new THREE.Group();
  7.     this.generate();
  8.   }
  9.   generate() {
  10.     // 树干
  11.     var trunkMat = new THREE.MeshLambertMaterial({
  12.       color: 0x543b14,
  13.       side: THREE.DoubleSide
  14.     });
  15.     var trunkGeom = new THREE.BoxBufferGeometry(20, 200, 20);
  16.     this.trunkMesh = new THREE.Mesh(trunkGeom, trunkMat);
  17.     // 树叶
  18.     var leavesMat = new THREE.MeshLambertMaterial({
  19.       color: 0x016316,
  20.       side: THREE.DoubleSide
  21.     });
  22.     var leavesGeom = new THREE.BoxBufferGeometry(80, 400, 80);
  23.     this.leavesMesh = new THREE.Mesh(leavesGeom, leavesMat);
  24.     this.treeMesh.add(this.trunkMesh);
  25.     this.treeMesh.add(this.leavesMesh);
  26.     this.treeMesh.position.set(this.x, this.y, this.z);
  27.     // ...
  28.   }
  29. }

矮树

  1. export default class LeafTree {
  2.   constructor(x, y, z) {
  3.     this.x = x;
  4.     this.y = y;
  5.     this.z = z;
  6.     this.treeMesh = new THREE.Group();
  7.     this.generate();
  8.   }
  9.   generate() {
  10.     // ...
  11.   }
  12. }

创建胡萝卜

接着，在地面上添加一些胡萝卜 ??。胡萝卜身体部分是通过四棱柱 CylinderBufferGeometry 实现的，然后通过 BoxBufferGeometry 立方体来实现胡萝卜的两片叶子。场景中可以通过 Carrot 类来添加胡萝卜，本页面示例中是通过循环调用添加了 20 个随机位置的胡萝卜。

  1. export default class Carrot {
  2.   constructor() {
  3.     this.carrotMesh = new THREE.Group();
  4.     this.generate();
  5.   }
  6.   generate() {
  7.     const carrotMat = new THREE.MeshLambertMaterial({
  8.       color: 0xd9721e
  9.     });
  10.     const leafMat = new THREE.MeshLambertMaterial({
  11.       color: 0x339e33
  12.     });
  13.     // 身体
  14.     const bodyGeom = new THREE.CylinderBufferGeometry(5, 3, 12, 4, 1);
  15.     this.body = new THREE.Mesh(bodyGeom, carrotMat);
  16.     // 叶子
  17.     const leafGeom = new THREE.BoxBufferGeometry(5, 10, 1, 1);
  18.     this.leaf1 = new THREE.Mesh(leafGeom, leafMat);
  19.     this.leaf2 = this.leaf1.clone();
  20.     // ...
  21.     this.carrotMesh.add(this.body);
  22.     this.carrotMesh.add(this.leaf1);
  23.     this.carrotMesh.add(this.leaf2);
  24.   }
  25. };
  1. for (let i = 0; i < 20; i++) {
  2.   carrot[i] = new Carrot();
  3.   scene.add(carrot[i].carrotMesh);
  4.   carrot[i].carrotMesh.position.set(-170 * Math.random() * 3 - 300, -12, 1400 * Math.random() * 1.2 - 900);
  5. }

创建兔子

最后，来创建页面的主角兔子 ??。兔子全部都是由立方体 BoxBufferGeometry 搭建而成的，整体可以分解为头、眼睛、耳朵、鼻子、嘴、胡须、身体、尾巴、四肢等构成，构建兔子时的核心要素就是各个立方体位置和缩放比例的调整，需要具备一定的审美能力，当然本例中使用的兔子是在 Three.js 社区开源代码的基础上改造的 ??。

完成兔子的整体外形之后，我们通过 gsap 给兔子添加一些运动动画效果和方法以供外部调用，其中 blink() 方法用于眨眼、jump() 方法用于原地跳跃、nod() 方法用于点头、run() 方法用于奔跑、fall() 方法用于边界检测时检测到超出运动范围时使兔子坠落效果等。完成 Rabbit 类后，我们就可以在场景中初始化小兔子。

  1. import { TweenMax, Power0, Power1, Power4, Elastic, Back } from 'gsap';
  3. export default class Rabbit {
  4.   constructor() {
  5.     this.bodyInitPositions = [];
  6.     this.runningCycle = 0;
  7.     this.rabbitMesh = new THREE.Group();
  8.     this.bodyMesh = new THREE.Group();
  9.     this.headMesh = new THREE.Group();
  10.     this.generate();
  11.   }
  12.   generate() {
  13.     var bodyMat = new THREE.MeshLambertMaterial({
  14.       color: 0x5c6363
  15.     });
  16.     var tailMat = new THREE.MeshLambertMaterial({
  17.       color: 0xc2bebe
  18.     });
  19.     var nouseMat = new THREE.MeshLambertMaterial({
  20.       color: 0xed716d
  21.     });
  22.     // ...
  23.     var pawMat = new THREE.MeshLambertMaterial({
  24.       color: 0xbf6970
  25.     });
  26.     var bodyGeom = new THREE.BoxBufferGeometry(50, 50, 42, 1);
  27.     var headGeom = new THREE.BoxBufferGeometry(44, 44, 54, 1);
  28.     var earGeom = new THREE.BoxBufferGeometry(5, 60, 10, 1);
  29.     var eyeGeom = new THREE.BoxBufferGeometry(20, 20, 8, 1);
  30.     var irisGeom = new THREE.BoxBufferGeometry(8, 8, 8, 1);
  31.     var mouthGeom = new THREE.BoxBufferGeometry(8, 16, 4, 1);
  32.     var mustacheGeom = new THREE.BoxBufferGeometry(0.5, 1, 22, 1);
  33.     var spotGeom = new THREE.BoxBufferGeometry(1, 1, 1, 1);
  34.     var legGeom = new THREE.BoxBufferGeometry(33, 33, 10, 1);
  35.     var pawGeom = new THREE.BoxBufferGeometry(45, 10, 10, 1);
  36.     var pawFGeom = new THREE.BoxBufferGeometry(20, 20, 20, 1);
  37.     var tailGeom = new THREE.BoxBufferGeometry(20, 20, 20, 1);
  38.     var nouseGeom = new THREE.BoxBufferGeometry(20, 20, 15, 1);
  39.     var tailGeom = new THREE.BoxBufferGeometry(23, 23, 23, 1);
  40.     this.body = new THREE.Mesh(bodyGeom, bodyMat);
  41.     this.bodyMesh.add(this.body);
  42.     this.head = new THREE.Mesh(headGeom, bodyMat);
  43.     this.bodyMesh.add(this.legL);
  44.     this.headMesh.add(this.earR);
  45.     this.rabbitMesh.add(this.bodyMesh);
  46.     this.rabbitMesh.add(this.headMesh);
  47.     // ...
  48.   }
  49.   blink() {
  50.     var sp = 0.5 + Math.random();
  51.     if (Math.random() > 0.2)
  52.       TweenMax.to([this.eyeR.scale, this.eyeL.scale], sp / 8, {
  53.         y: 0,
  54.         ease: Power1.easeInOut,
  55.         yoyo: true,
  56.         repeat: 3
  57.       });
  58.   }
  59.   // 跳跃
  60.   jump() {
  61.     var speed = 10;
  62.     var totalSpeed = 10 / speed;
  63.     var jumpHeight = 150;
  64.     TweenMax.to(this.earL.rotation, totalSpeed / 2, {
  65.       z: "+=.3",
  66.       ease: Back.easeOut,
  67.       yoyo: true,
  68.       repeat: 1
  69.     });
  70.     TweenMax.to(this.earR.rotation, totalSpeed / 2, {
  71.       z: "-=.3",
  72.       ease: Back.easeOut,
  73.       yoyo: true,
  74.       repeat: 1
  75.     });
  76.     // ...
  77.   }
  78.   // 点头
  79.   nod() {}
  80.   // 奔跑
  81.   run() {}
  82.   // 移动
  83.   move() {}
  84.   // 坠落
  85.   fall() {}
  86.   // 动作销毁
  87.   killNod() {}
  88.   killJump() {}
  89.   killMove() {}
  90. }

将兔子添加到场景中。

添加动画和操作

为了使兔子可以运动和可交互，我们通过监听键盘按键的方式来调用兔子类内置的对应动画方法，兔子的方向转动可以通过修改兔子的旋转属性 rotation 来实现。

  1. // 兔子控制
  2. const rabbitControl = {
  3.   tureLeft: () => {
  4.     rabbit && (rabbit.rabbitMesh.rotation.y -= Math.PI / 2);
  5.   },
  6.   turnRight: () => {
  7.     rabbit && (rabbit.rabbitMesh.rotation.y += Math.PI / 2);
  8.   },
  9.   stopMove: () => {
  10.     rabbitMoving = false;
  11.     rabbit.killMove();
  12.     rabbit.nod();
  13.   },
  14. }
  16. // 键盘监听
  17. document.addEventListener('keydown', e => {
  18.   if (e && e.keyCode) {
  19.     switch(e.keyCode) {
  20.       // 左
  21.       case 65:
  22.       case 37:
  23.         rabbitControl.tureLeft();
  24.         break;
  25.       // 右
  26.       case 68:
  27.       case 39:
  28.         rabbitControl.turnRight();
  29.         break;
  30.       // 前
  31.       case 87:
  32.       case 38:
  33.         rabbitMoving = true;
  34.         break;
  35.       // 空格键
  36.       case 32:
  37.         !rabbitJumping && rabbit.jump() && (rabbitJumping = true);
  38.         break;
  39.       default:
  40.         break;
  41.     }
  42.   }
  43. });
  45. document.addEventListener('keyup', e => {
  46.   if (e && e.keyCode) {
  47.     switch(e.keyCode) {
  48.       case 83:
  49.       case 40:
  50.       case 87:
  51.       case 38:
  52.         rabbitMoving = false;
  53.         rabbit.killMove();
  54.         rabbit.nod();
  55.         break;
  56.       case 32:
  57.         setTimeout(() => {
  58.           rabbitJumping = false;
  59.         }, 800);
  60.         break;
  61.     }
  62.   }
  63. });

为了使场景更加真实和趣味，我们可以添加一些边界检测方法，当兔子位置处于非可运动区域如小河、浮岛之外等区域时，可以调用兔子的 fall()，方法使其坠落。当检测到兔子的位置和胡萝卜的位置重叠时，给兔子添加了一个 jump() 跳跃动作并使检测到的这个胡萝卜从场景中移除。

  1. const checkCollision = () => {
  2.   for (let i = 0; i < 20; i++) {
  3.     let rabbCarr = rabbit.rabbitMesh.position.clone().sub(carrot[i].carrotMesh.position.clone());
  4.     if (rabbCarr.length() <= 20) {
  5.       rabbit.jump();
  6.       scene.remove(carrot[i].carrotMesh);
  7.       rabbCarr = null;
  8.     }
  9.   }
  10.   // 检查是否是地面的边界
  11.   var rabbFloor = island.floorMesh.position.clone().sub(rabbit.rabbitMesh.position.clone());
  12.   if (
  13.     rabbFloor.x <= -900 ||
  14.     rabbFloor.x >= 900 ||
  15.     rabbFloor.z <= -900 ||
  16.     rabbFloor.z >= 900
  17.   ) {
  18.     rabbit.fall();
  19.   }
  20.   // 小河检测
  21.   var rabbStream = rabbit.rabbitMesh.position.clone().sub(island.streamMesh.position.clone());
  22.   if (
  23.     (rabbStream.x >= -97 &&
  24.       rabbStream.x <= 97 &&
  25.       rabbStream.z >= -900 &&
  26.       rabbStream.z <= 688) ||
  27.     (rabbStream.x >= -97 && rabbStream.x <= 97 && rabbStream.z >= 712)
  28.   ) {
  29.     rabbit.fall();
  30.   }
  31. }

页面装饰

最后，我们来制作一个其实页面，中间部分是键盘操作说明，底部是一些装饰文案图片，操作提示下方是一个开始按钮，我们给这个按钮添加一个通过 TWEEN.js 实现的镜头补间动画效果，当点击按钮时，页面首先显示的是倒置三角造型的浮岛，然后镜头慢慢方法拉近，显示出兔子运动的区域。本页面为了使其看起来更加符合游戏主题，标题文案使用了一种像素化的字体 ?。

  1. const startButton = document.getElementById('start_button');
  2. const mask = document.getElementById('mask');
  3. startButton.addEventListener('click', () => {
  4.   mask.style.display = 'none';
  5.   Animations.animateCamera(camera, controls, { x: 50, y: 120, z: 1000 }, { x: 0, y: 0, z: 0 }, 3600, () => {});
  6. });

?? 源码地址：https://github.com/dragonir/threejs-odessey

总结

本文中主要包含的知识点包括：

  • 使用 Three.js 网格立方体搭建三维卡通场景
  • 键盘事件的监听与三维场景动画的结合

想了解其他前端知识或其他未在本文中详细描述的Web 3D开发技术相关知识，可阅读我往期的文章。如果有疑问可以在评论中留言，如果觉得文章对你有帮助，不要忘了一键三连哦 ??。

附录

参考

本文作者：dragonir 本文地址：https://www.cnblogs.com/dragonir/p/17064580.html

原文链接：https://www.cnblogs.com/dragonir/p/17064580.html

 友情链接：直通硅谷 　点职佳 　北美留学生论坛

three.js热门文章

  • Three.js 进阶之旅：全景漫游-初阶移动相机版
  • threeJs实现波纹扩散及光标浮动效果详解
  • Three.js 进阶之旅：滚动控制模型动画和相机动画 &#129442;
  • three.js镜头追踪的移动效果实例
  • Three.js 进阶之旅：物理效果-3D乒乓球小游戏 &#127955;
  • Three.js 进阶之旅：物理效果-碰撞和声音 &#128165;
  • Three.js 进阶之旅：新春特典-Rabbit craft go &#128007;
  • Three.js 进阶之旅：全景漫游-高阶版在线看房 &#127969;
  • 如何使用webgl(three.js)实现煤矿隧道、井下人员定位、掘进面、纵采面可视化解决方案——第十九课（一）
  • three.js 汽车行驶动画效果

    • three.js推荐文章

  • 如何基于three.js(webgl)引擎架构，实现3D密集架库房,3D档案室（3d机器人取档、机器人盘点、人工查档、设备巡检）
  • three.js 汽车行驶动画效果
  • 如何使用webgl(three.js)实现煤矿隧道、井下人员定位、掘进面、纵采面可视化解决方案——第十九课（一）
  • Three.js 进阶之旅：滚动控制模型动画和相机动画 &#129442;
  • Three.js 进阶之旅：全景漫游-高阶版在线看房 &#127969;
  • Three.js 进阶之旅：全景漫游-初阶移动相机版
  • Three.js 进阶之旅：物理效果-3D乒乓球小游戏 &#127955;
  • threeJs实现波纹扩散及光标浮动效果详解
  • Three.js 进阶之旅：物理效果-碰撞和声音 &#128165;
  • Three.js 进阶之旅：新春特典-Rabbit craft go &#128007;

    • 本站QQ群：前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

    W3xue 的所有内容仅供测试，对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
    关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接（目前9元/月）请联系QQ：27243702 沸活量
    皖ICP备17017327号-2　皖公网安备34020702000426号