devbox
很楠不爱3
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Three.js--》探寻Cannon.js构建震撼的3D物理交互体验（一）

作者：很楠不爱3 | 2024-03-06 20:15:02

赞

踩

Three.js--》探寻Cannon.js构建震撼的3D物理交互体验（一）

我们用three.js可以绘制出各种酷炫的画面，但是当我们想要一个更加真实的物理效果的话，这个时候我们就需要一个物理的库，接下来我们就讲解一下今天要学习的canon，它可以给我们提供一个更加真实的物理效果，像物体的张力、摩擦力、拉伸、反弹等等各种真实的物理效果。该库都能够有一个非常好的模拟。

PS：目前博主在一家互联网公司工作，该公司的编码风格是vue+tsx，所以接下来的项目以该编码风格进行举例，详细了解参考我之前的文章：地址 。

目录

canon基本使用

基础碰撞使用

材质与摩擦系数设置

弹性与接触材质设置

碰撞与碰撞组

canon基本使用

Cannon 是一种轻量级的 JavaScript 3D 物理引擎，用于实现虚拟世界中的物理模拟和交互。它提供了一套强大的功能，能够处理刚体碰撞、力学模拟、约束系统等物理效果，使开发者能够在 Web 应用程序和游戏中实现逼真的物理行为。

Cannon的官网：地址 ，提供了一系列关于物理运动在three世界的实现，实现案例 的效果非常直观，展示了物理运动的魅力，如下：

接下来我们在three.js的vue项目中使用Cannon，终端执行如下命令安装，具体参考：官网

npm i cannon-es

接下来我们通过tsx风格语法撰写three基础项目实现：

  1. import { defineComponent } from "vue";
  2. import * as THREE from 'three'
  3. import { OrbitControls }  from 'three/examples/jsm/controls/OrbitControls.js'
  4. import * as CANNON from 'cannon-es'
  5. import './index.scss'
  6. import { div } from "three/examples/jsm/nodes/Nodes.js";
  7.  
  8. export default defineComponent({
  9.     setup() {
  10.         // 初始化物理世界
  11.         const world = new CANNON.World()
  12.         // 初始化物理世界的重力
  13.         world.gravity.set(0, -9.82, 0)
  14.         
  15.         // 初始化3D世界
  16.         const scene = new THREE.Scene()
  17.         // 初始化相机
  18.         const camera = new THREE.PerspectiveCamera(75, window.innerWidth / window.innerHeight, 0.1, 1000)
  19.         camera.position.z = 3
  20.         // 初始化渲染器
  21.         const renderer = new THREE.WebGLRenderer({ antialias: true })
  22.         renderer.setSize(window.innerWidth, window.innerHeight)
  23.         document.body.appendChild(renderer.domElement)
  24.         // 初始化控制器
  25.         const controls = new OrbitControls(camera, renderer.domElement)
  26.         controls.enableDamping = true
  27.  
  28.         // 渲染
  29.         let clock = new THREE.Clock()
  30.         const animate = () => {
  31.             let delta = clock.getDelta()
  32.             controls.update()
  33.             renderer.render(scene, camera)
  34.             requestAnimationFrame(animate)
  35.         }
  36.         animate()
  37.         return () => {
  38.             <div></div>
  39.         }
  40.     }
  41. })

接下来我们需要给场景添加一些物体，如下：

  1. // 创建一个物理球体，半径为0.5
  2. const sphereShape = new CANNON.Sphere(0.5)
  3. // 创建一个刚体
  4. const sphereBody = new CANNON.Body({
  5.     mass: 1,
  6.     shape: sphereShape,
  7.     position: new CANNON.Vec3(0, 5, 0)
  8. })
  9. // 将刚体添加到物理世界中
  10. world.addBody(sphereBody)
  11. // 物理世界创建的东西不显示，所以我们要再通过three.js再创建一个球
  12. const sphereGeometry = new THREE.SphereGeometry(0.5, 32, 32) // 创建一个几何体
  13. const sphereMaterial = new THREE.MeshBasicMaterial({ color: 0x00ff00 }) // 创建一个球体材质
  14. const shpereMesh = new THREE.Mesh(sphereGeometry, sphereMaterial) // 创建一个球体网格
  15. // 将网格添加到3D场景中
  16. scene.add(shpereMesh)

打开控制台，可以看到我们的球体已经显示出来了：

接下来我们要把物理世界的球体给到我们three渲染出来的球体，让两者开始关联起来。在每一帧中，根据物理引擎模拟的结果来更新 Three.js 场景中球体网格的位置和旋转状态，从而实现了基于物理引擎的球体模拟效果，如下：

得到的结果如下：

基础碰撞使用

上面我们实现了一个物体的自由下落，接下来我们实现物体与平面的碰撞效果。如下添加平面：

  1. // 创建一个物理世界的平面
  2. const planeShape = new CANNON.Plane()
  3. // 创建一个刚体
  4. const planeBody = new CANNON.Body({
  5.     mass: 0, // 设置质量为0，不受碰撞的影响
  6.     shape: planeShape,
  7.     position: new CANNON.Vec3(0, 0, 0)
  8. })
  9. // 设置刚体旋转（设置旋转X轴）
  10. planeBody.quaternion.setFromAxisAngle(new CANNON.Vec3(1, 0, 0), -Math.PI / 2)
  11. // 将刚体添加到物理世界当中
  12. world.addBody(planeBody)
  13. // 物理世界创建的东西不显示，所以我们要再通过three.js再创建一个平面
  14. const planeGeometry = new THREE.PlaneGeometry(10, 10) // 因为渲染的东西不是无限衍生，这里给10x10
  15. // 创建一个平面材质
  16. const planeMaterial = new THREE.MeshBasicMaterial({ color: 0xffff00 })
  17. // 创建一个平面网格
  18. const planeMesh = new THREE.Mesh(planeGeometry, planeMaterial)
  19. // 旋转平面90度让其平铺
  20. planeMesh.rotation.x = -Math.PI / 2
  21. // 将网格添加到3D场景当中
  22. scene.add(planeMesh)

当然除了我们设置平面质量为0之外，我们也可以设置平面为静态效果，也不受碰撞影响：

最终得到的效果如下:

那我们让物理世界和渲染世界的平面倾斜度加上0.1，小球是否会滑落而掉下去呢？测试一下：

得到的效果如下，可见小球是不会掉落下去的，因为物理世界的平面是无限衍生的，即使渲染世界的平面有限，小球仍然会走物理世界的规律，如下：

如果我们想在物理世界有一个有限大的平面的话， 我们可以通过构建一个立方体，然后把立方体压扁形成一个平面来使用，因为立方体已经有高度了，所以我们也不需要在旋转90度了，稍微给点倾斜度0.1即可，代码如下：

得到的效果如下，可见到我们的小球已经实现了掉落的效果：

上面两标题的案例代码如下：

  1. import { defineComponent } from "vue";
  2. import * as THREE from 'three'
  3. import { OrbitControls }  from 'three/examples/jsm/controls/OrbitControls.js'
  4. import * as CANNON from 'cannon-es'
  5. import './index.scss'
  6.  
  7. export default defineComponent({
  8.     setup() {
  9.         // 初始化物理世界
  10.         const world = new CANNON.World()
  11.         // 初始化物理世界的重力
  12.         world.gravity.set(0, -9.82, 0)
  13.         
  14.         // 初始化3D世界
  15.         const scene = new THREE.Scene()
  16.         // 初始化相机
  17.         const camera = new THREE.PerspectiveCamera(75, window.innerWidth / window.innerHeight, 0.1, 1000)
  18.         camera.position.z = 3
  19.         // 初始化渲染器
  20.         const renderer = new THREE.WebGLRenderer({ antialias: true })
  21.         renderer.setSize(window.innerWidth, window.innerHeight)
  22.         document.body.appendChild(renderer.domElement)
  23.         // 初始化控制器
  24.         const controls = new OrbitControls(camera, renderer.domElement)
  25.         controls.enableDamping = true
  26.  
  27.         // 创建一个物理球体，半径为0.5
  28.         const sphereShape = new CANNON.Sphere(0.5)
  29.         // 创建一个刚体
  30.         const sphereBody = new CANNON.Body({
  31.             mass: 1,
  32.             shape: sphereShape,
  33.             position: new CANNON.Vec3(0, 5, 0)
  34.         })
  35.         // 将刚体添加到物理世界中
  36.         world.addBody(sphereBody)
  37.         // 物理世界创建的东西不显示，所以我们要再通过three.js再创建一个球
  38.         const sphereGeometry = new THREE.SphereGeometry(0.5, 32, 32) // 创建一个几何体
  39.         const sphereMaterial = new THREE.MeshBasicMaterial({ color: 0x00ff00 }) // 创建一个球体材质
  40.         const shpereMesh = new THREE.Mesh(sphereGeometry, sphereMaterial) // 创建一个球体网格
  41.         // 将网格添加到3D场景中
  42.         scene.add(shpereMesh)
  43.  
  44.         // 创建一个物理世界的平面
  45.         // const planeShape = new CANNON.Plane()
  46.         const planeShape = new CANNON.Box(new CANNON.Vec3(5, 0.1, 5))
  47.         // 创建一个刚体
  48.         const planeBody = new CANNON.Body({
  49.             // mass: 0, // 设置质量为0，不受碰撞的影响
  50.             shape: planeShape,
  51.             position: new CANNON.Vec3(0, 0, 0),
  52.             type: CANNON.Body.STATIC // 设置物体为静态，不受碰撞的影响
  53.         })
  54.         // 设置刚体旋转（设置旋转X轴）
  55.         planeBody.quaternion.setFromAxisAngle(new CANNON.Vec3(1, 0, 0), 0.1)
  56.         // 将刚体添加到物理世界当中
  57.         world.addBody(planeBody)
  58.         // 物理世界创建的东西不显示，所以我们要再通过three.js再创建一个平面
  59.         // const planeGeometry = new THREE.PlaneGeometry(10, 10) // 因为渲染的东西不是无限衍生，这里给10x10
  60.         const planeGeometry = new THREE.BoxGeometry(10, 0.2, 10)
  61.         // 创建一个平面材质
  62.         const planeMaterial = new THREE.MeshBasicMaterial({ color: 0xffff00 })
  63.         // 创建一个平面网格
  64.         const planeMesh = new THREE.Mesh(planeGeometry, planeMaterial)
  65.         // 旋转平面90度让其平铺
  66.         planeMesh.rotation.x = 0.1
  67.         // 将网格添加到3D场景当中
  68.         scene.add(planeMesh)
  69.         
  70.         // 渲染
  71.         let clock = new THREE.Clock()
  72.         const animate = () => {
  73.             // 获取了两次渲染之间的时间差，通常用于控制动画和物理模拟。
  74.             let delta = clock.getDelta()
  75.             // 使用时间差来推进物理世界的模拟
  76.             world.step(delta)
  77.             // 更新球体网格的位置和旋转
  78.             // 将物理引擎中球体的位置赋值给 Three.js 中球体网格（shpereMesh）的位置，从而将物理模拟的结果更新到可视化场景中。
  79.             shpereMesh.position.copy(sphereBody.position)
  80.             // 将物理引擎中球体的旋转状态赋值给 Three.js 中球体网格（shpereMesh）的旋转状态，确保网格的旋转与物理模拟一致。
  81.             shpereMesh.quaternion.copy(sphereBody.quaternion)
  82.             controls.update()
  83.             renderer.render(scene, camera)
  84.             requestAnimationFrame(animate)
  85.         }
  86.         animate()
  87.  
  88.         return () => {
  89.             <div></div>
  90.         }
  91.     }
  92. })

材质与摩擦系数设置

cannon的材质可以模拟我们现实生活当中的物理的效果，比如说我们可以设置它的摩擦系数，弹性系数来实现我们这个物体的滑动的有摩擦的效果。借助上面的案例，我们将球体换成立方体，因为要创建多个立方体，这里我们设置一个变量用于存储

  1. // 创建网格数组
  2. let phyMeshes: any[] = [] // 物理世界
  3. let meshes: any[] = [] // 渲染世界
  4.  
  5. // 创建物理立方体
  6. const boxShape = new CANNON.Box(new CANNON.Vec3(0.5, 0.5, 0.5))
  7. // 设置立方体的材质
  8. const boxMaterialCon = new CANNON.Material("boxMaterial")
  9. // 创建一个刚体
  10. const boxBody = new CANNON.Body({
  11.     shape: boxShape,
  12.     position: new CANNON.Vec3(0, 15, 0),
  13.     mass: 1,
  14.     material: boxMaterialCon
  15. })
  16. // 将刚体添加到物理世界当中
  17. world.addBody(boxBody)
  18. phyMeshes.push(boxBody)
  19. // 创建立方体几何体
  20. const boxGeometry = new THREE.BoxGeometry(1, 1, 1)
  21. // 创建立方体材质
  22. const boxMaterial = new THREE.MeshBasicMaterial({ color: 0x00ff00 })
  23. // 创建立方体网格
  24. const boxMesh = new THREE.Mesh(boxGeometry, boxMaterial)
  25. // 将网格添加到3D场景当中
  26. scene.add(boxMesh)
  27. meshes.push(boxMesh)

在渲染函数处，我们变量数组来推进物理世界模拟：

最终得到是效果如下：

接下来我们添加第二个物体，将第二个物体的摩擦系数设置为0，第一个物体和平面的摩擦系数设置为0.7，代码如下：

  1. // 创建网格数组
  2. let phyMeshes: any[] = [] // 物理世界
  3. let meshes: any[] = [] // 渲染世界
  4.  
  5. // 创建物理立方体
  6. const boxShape = new CANNON.Box(new CANNON.Vec3(0.5, 0.5, 0.5))
  7. // 设置立方体的材质
  8. const boxMaterialCon = new CANNON.Material("boxMaterial")
  9. boxMaterialCon.friction = 0.7
  10. // 创建一个刚体
  11. const boxBody = new CANNON.Body({
  12.     shape: boxShape,
  13.     position: new CANNON.Vec3(0, 15, 0),
  14.     mass: 1,
  15.     material: boxMaterialCon
  16. })
  17. // 将刚体添加到物理世界当中
  18. world.addBody(boxBody)
  19. phyMeshes.push(boxBody)
  20. // 创建立方体几何体
  21. const boxGeometry = new THREE.BoxGeometry(1, 1, 1)
  22. // 创建立方体材质
  23. const boxMaterial = new THREE.MeshBasicMaterial({ color: 0x00ff00 })
  24. // 创建立方体网格
  25. const boxMesh = new THREE.Mesh(boxGeometry, boxMaterial)
  26. // 将网格添加到3D场景当中
  27. scene.add(boxMesh)
  28. meshes.push(boxMesh)
  29.  
  30. // 创建第二个物理立方体（使用第一个物理立方体的内容，材质不同）
  31. const boxSlipperyMaterial = new CANNON.Material("boxSlipperyMaterial")
  32. boxSlipperyMaterial.friction = 0 // 摩擦系数为0
  33. // 创建刚体
  34. const boxBody2 = new CANNON.Body({
  35.     shape: boxShape,
  36.     position: new CANNON.Vec3(1, 5, 0), // 区别于第一个物体，位置改变一下
  37.     mass: 1,
  38.     material: boxSlipperyMaterial
  39. })
  40. // 将刚体添加到物理世界当中
  41. world.addBody(boxBody2)
  42. phyMeshes.push(boxBody2)
  43. // 创建立方体几何体（使用第一个物体的内容）
  44. const boxMesh2 = new THREE.Mesh(boxGeometry, boxMaterial)
  45. // 将网格添加到3D场景当中
  46. scene.add(boxMesh2)
  47. meshes.push(boxMesh2)
  48.  
  49. // 创建一个物理世界的平面
  50. // const planeShape = new CANNON.Plane()
  51. const planeShape = new CANNON.Box(new CANNON.Vec3(5, 0.1, 5))
  52. // 创建一个刚体
  53. const planeBody = new CANNON.Body({
  54.     // mass: 0, // 设置质量为0，不受碰撞的影响
  55.     shape: planeShape,
  56.     position: new CANNON.Vec3(0, 0, 0),
  57.     type: CANNON.Body.STATIC, // 设置物体为静态，不受碰撞的影响
  58.     material: boxMaterialCon
  59. })
  60. // 设置刚体旋转（设置旋转X轴）
  61. planeBody.quaternion.setFromAxisAngle(new CANNON.Vec3(1, 0, 0), 0.1)
  62. // 将刚体添加到物理世界当中
  63. world.addBody(planeBody)
  64. // 物理世界创建的东西不显示，所以我们要再通过three.js再创建一个平面
  65. // const planeGeometry = new THREE.PlaneGeometry(10, 10) // 因为渲染的东西不是无限衍生，这里给10x10
  66. const planeGeometry = new THREE.BoxGeometry(10, 0.2, 10)
  67. // 创建一个平面材质
  68. const planeMaterial = new THREE.MeshBasicMaterial({ color: 0xffff00 })
  69. // 创建一个平面网格
  70. const planeMesh = new THREE.Mesh(planeGeometry, planeMaterial)
  71. // 旋转平面90度让其平铺
  72. planeMesh.rotation.x = 0.1
  73. // 将网格添加到3D场景当中
  74. scene.add(planeMesh)

最终得到的效果如下，可以看到我们设置的第二个物体因为很光滑，所以很容易就滑落下去：

弹性与接触材质设置

上文我们介绍了摩擦效果的操作，接下来我们继续开始讲解物体的弹性操作，我们根据上文的代码，再创建第三个立方体，然后给该立方体添加弹性系数

  1. // 创建第三个物理立方体（使用第一个物理立方体的内容，材质不同）
  2. const boxBouncyMaterial = new CANNON.Material("boxBouncyMaterial")
  3. boxBouncyMaterial.friction = 0.1
  4. boxBouncyMaterial.restitution = 1 // 设置弹性系数为1
  5. // 创建刚体
  6. const boxBody3 = new CANNON.Body({
  7.     shape: boxShape,
  8.     mass: 1,
  9.     position: new CANNON.Vec3(2, 5, 3),
  10.     material: boxBouncyMaterial
  11. })
  12. // 将刚体添加到物理世界当中
  13. world.addBody(boxBody3)
  14. phyMeshes.push(boxBody3)
  15. // 创建几何体（使用第一个立方体的内容以及材质）
  16. const boxMesh3 = new THREE.Mesh(boxGeometry, boxMaterial) // 添加网格
  17. // 将网格添加到3D场景当中
  18. scene.add(boxMesh3)
  19. meshes.push(boxMesh3)

给立方体设置弹性系数之后，如果我们想让弹性效果奏效的话，我们也需要给平面网格设置相同的弹性系数，因为平面网格使用的材质是第一个立方体的材质，所以我们只要给第一个立方体设置弹性系数即可，如下：

最终得到的效果如下，可以看到设置高度高的物体，从高处下落反弹的效果是很直观的：

当然我们也没有必要单独设置一下立方体和平面的弹性和摩擦系数，我们也可以通过接触材质的系数设置两个材质之间的一个弹性和摩擦系数，来实现相应的效果，如下：

  1. // 创建第三个物理立方体（使用第一个物理立方体的内容，材质不同）
  2. const boxBouncyMaterial = new CANNON.Material("boxBouncyMaterial")
  3. // boxBouncyMaterial.friction = 0.1
  4. // boxBouncyMaterial.restitution = 1 // 设置弹性系数为1
  5. // 创建刚体
  6. const boxBody3 = new CANNON.Body({
  7.     shape: boxShape,
  8.     mass: 1,
  9.     position: new CANNON.Vec3(2, 5, 3),
  10.     material: boxBouncyMaterial
  11. })
  12. // 将刚体添加到物理世界当中
  13. world.addBody(boxBody3)
  14. phyMeshes.push(boxBody3)
  15. // 创建几何体（使用第一个立方体的内容以及材质）
  16. const boxMesh3 = new THREE.Mesh(boxGeometry, boxMaterial) // 添加网格
  17. // 将网格添加到3D场景当中
  18. scene.add(boxMesh3)
  19. meshes.push(boxMesh3)
  20. // 定义接触材质
  21. const material3toplane = new CANNON.ContactMaterial(
  22.     boxMaterialCon,
  23.     boxBouncyMaterial,
  24.     {
  25.         friction: 0,
  26.         restitution:  1
  27.     }
  28. )
  29. // 将接触材质添加到物理世界当中
  30. world.addContactMaterial(material3toplane)

最终呈现的效果依然很明显：

碰撞与碰撞组

Cannon中的碰撞指的是游戏开发中物体之间的相互作用，通常包括物体之间的碰撞检测和碰撞响应两个部分。碰撞检测用于判断物体是否发生了碰撞，而碰撞响应则是在发生碰撞时对物体进行相应的处理，比如改变物体的速度、方向等。如下我们设置代码来实现：

依次创建立方体、球体、圆柱体到场景当中，举例代码如下：

接下来我们给创建到场景的立方体添加一个初速度使其运动来碰撞另外两个物体，如下：

这里给出完整的代码来给大家进行学习：

  1. import { defineComponent } from "vue";
  2. import * as THREE from 'three'
  3. import { OrbitControls }  from 'three/examples/jsm/controls/OrbitControls.js'
  4. import * as CANNON from 'cannon-es'
  5. import './index.scss'
  6.  
  7. export default defineComponent({
  8.     setup() {
  9.         // 初始化物理世界
  10.         const world = new CANNON.World()
  11.         // 初始化物理世界的重力
  12.         world.gravity.set(0, -9.82, 0)
  13.         
  14.         // 初始化3D世界
  15.         const scene = new THREE.Scene()
  16.         // 初始化相机
  17.         const camera = new THREE.PerspectiveCamera(75, window.innerWidth / window.innerHeight, 0.1, 1000)
  18.         camera.position.z = 8
  19.         camera.position.y = 5
  20.         camera.position.x = 2
  21.         // 初始化渲染器
  22.         const renderer = new THREE.WebGLRenderer({ antialias: true })
  23.         renderer.setSize(window.innerWidth, window.innerHeight)
  24.         document.body.appendChild(renderer.domElement)
  25.         // 初始化控制器
  26.         const controls = new OrbitControls(camera, renderer.domElement)
  27.         controls.enableDamping = true
  28.  
  29.         // 创建网格数组
  30.         let phyMeshes: any[] = [] // 物理世界
  31.         let meshes: any[] = [] // 渲染世界
  32.  
  33.         // 创建物理立方体
  34.         const boxShape = new CANNON.Box(new CANNON.Vec3(0.5, 0.5, 0.5))
  35.         // 设置立方体的材质
  36.         const boxMaterialCon = new CANNON.Material("boxMaterial")
  37.         boxMaterialCon.friction = 0
  38.         // 创建一个刚体
  39.         const boxBody = new CANNON.Body({
  40.             shape: boxShape,
  41.             position: new CANNON.Vec3(2, 0.8, 0),
  42.             mass: 1,
  43.             material: boxMaterialCon
  44.         })
  45.         // 将刚体添加到物理世界当中
  46.         world.addBody(boxBody)
  47.         phyMeshes.push(boxBody)
  48.         // 创建立方体几何体
  49.         const boxGeometry = new THREE.BoxGeometry(1, 1, 1)
  50.         // 创建立方体材质
  51.         const boxMaterial = new THREE.MeshBasicMaterial({ color: 0x00ff00 })
  52.         // 创建立方体网格
  53.         const boxMesh = new THREE.Mesh(boxGeometry, boxMaterial)
  54.         // 将网格添加到3D场景当中
  55.         scene.add(boxMesh)
  56.         meshes.push(boxMesh)
  57.  
  58.         // 创建物理球
  59.         const spereShape = new CANNON.Sphere(0.5)
  60.         // 创建一个刚体
  61.         const sphereBody = new CANNON.Body({
  62.             shape: spereShape,
  63.             position: new CANNON.Vec3(0, 0.8, 0),
  64.             mass: 1,
  65.             material: boxMaterialCon
  66.         })
  67.         // 将刚体添加到物理世界当中
  68.         world.addBody(sphereBody)
  69.         phyMeshes.push(sphereBody)
  70.         // 创建球的几何体
  71.         const sphereGeometry = new THREE.SphereGeometry(0.5, 32, 32)
  72.         // 创建球的材质
  73.         const sphereMaterial = new THREE.MeshBasicMaterial({ color: 0x0000ff })
  74.         // 创建球网格
  75.         const sphereMesh = new THREE.Mesh(sphereGeometry, sphereMaterial)
  76.         // 将网格添加到3D场景当中
  77.         scene.add(sphereMesh)
  78.         meshes.push(sphereMesh)
  79.  
  80.         // 创建物理圆柱体
  81.         const cylinderShape = new CANNON.Cylinder(0.5, 0.5, 1, 32)
  82.         // 创建一个刚体
  83.         const cylinderBody = new CANNON.Body({
  84.             shape: cylinderShape,
  85.             position: new CANNON.Vec3(-2, 0.8, 0),
  86.             mass: 1,
  87.             material: boxMaterialCon
  88.         })
  89.         // 将刚体添加到物理世界当中
  90.         world.addBody(cylinderBody)
  91.         phyMeshes.push(cylinderBody)
  92.         // 创建圆柱体几何体
  93.         const cylinderGeometry = new THREE.CylinderGeometry(0.5 ,0.5, 1, 32)
  94.         // 创建圆柱体材质
  95.         const cylinderMaterial = new THREE.MeshBasicMaterial({ color: 0xff0000 })
  96.         // 创建圆柱体网格
  97.         const cylinderMesh = new THREE.Mesh(cylinderGeometry, cylinderMaterial)
  98.         // 将网格添加到3D场景当中
  99.         scene.add(cylinderMesh)
  100.         meshes.push(cylinderMesh)
  101.  
  102.         // 创建一个物理世界的平面
  103.         // const planeShape = new CANNON.Plane()
  104.         const planeShape = new CANNON.Box(new CANNON.Vec3(5, 0.1, 5))
  105.         // 创建一个刚体
  106.         const planeBody = new CANNON.Body({
  107.             // mass: 0, // 设置质量为0，不受碰撞的影响
  108.             shape: planeShape,
  109.             position: new CANNON.Vec3(0, 0, 0),
  110.             type: CANNON.Body.STATIC, // 设置物体为静态，不受碰撞的影响
  111.             material: boxMaterialCon
  112.         })
  113.         // 设置刚体旋转（设置旋转X轴）
  114.         // planeBody.quaternion.setFromAxisAngle(new CANNON.Vec3(1, 0, 0), 0.1)
  115.         // 将刚体添加到物理世界当中
  116.         world.addBody(planeBody)
  117.         // 物理世界创建的东西不显示，所以我们要再通过three.js再创建一个平面
  118.         // const planeGeometry = new THREE.PlaneGeometry(10, 10) // 因为渲染的东西不是无限衍生，这里给10x10
  119.         const planeGeometry = new THREE.BoxGeometry(10, 0.2, 10)
  120.         // 创建一个平面材质
  121.         const planeMaterial = new THREE.MeshBasicMaterial({ color: 0xffff00 })
  122.         // 创建一个平面网格
  123.         const planeMesh = new THREE.Mesh(planeGeometry, planeMaterial)
  124.         // 旋转平面90度让其平铺
  125.         // planeMesh.rotation.x = 0.1
  126.         // 将网格添加到3D场景当中
  127.         scene.add(planeMesh)
  128.  
  129.         // 设置立方体的初始速度
  130.         boxBody.velocity.set(-2, 0, 0)
  131.         
  132.         // 渲染
  133.         let clock = new THREE.Clock()
  134.         const animate = () => {
  135.             // 获取了两次渲染之间的时间差，通常用于控制动画和物理模拟。
  136.             let delta = clock.getDelta()
  137.             world.step(delta)
  138.             // 使用时间差来推进物理世界的模拟
  139.             for(let i = 0; i < phyMeshes.length; i++) {
  140.                 meshes[i].position.copy(phyMeshes[i].position)
  141.                 meshes[i].quaternion.copy(phyMeshes[i].quaternion)
  142.             }
  143.             controls.update()
  144.             renderer.render(scene, camera)
  145.             requestAnimationFrame(animate)
  146.         }
  147.         animate()
  148.  
  149.         return () => {
  150.             <div></div>
  151.         }
  152.     }
  153. })

接下来实现碰撞组，碰撞组是为了更高效地管理和处理碰撞而引入的概念。通过将具有相似碰撞特性的物体分组，可以在碰撞检测和碰撞响应时只考虑同一组内的物体之间的碰撞，从而减少不必要的计算量，提高游戏的性能和效率。代码如下：

我们设置立方体为组1，然后碰撞掩码就是能够和谁发生碰撞，我们设置立方体可以和所有物体碰撞：

在球体的分组当中，我们设置碰撞掩码如下，可以看到我们的球不能碰撞圆柱体：

最终呈现的效果如下：

给出案例的完整代码供大家学习：

  1. import { defineComponent } from "vue";
  2. import * as THREE from 'three'
  3. import { OrbitControls }  from 'three/examples/jsm/controls/OrbitControls.js'
  4. import * as CANNON from 'cannon-es'
  5. import './index.scss'
  6.  
  7. export default defineComponent({
  8.     setup() {
  9.         // 初始化物理世界
  10.         const world = new CANNON.World()
  11.         // 初始化物理世界的重力
  12.         world.gravity.set(0, -9.82, 0)
  13.         
  14.         // 初始化3D世界
  15.         const scene = new THREE.Scene()
  16.         // 初始化相机
  17.         const camera = new THREE.PerspectiveCamera(75, window.innerWidth / window.innerHeight, 0.1, 1000)
  18.         camera.position.z = 8
  19.         camera.position.y = 5
  20.         camera.position.x = 2
  21.         // 初始化渲染器
  22.         const renderer = new THREE.WebGLRenderer({ antialias: true })
  23.         renderer.setSize(window.innerWidth, window.innerHeight)
  24.         document.body.appendChild(renderer.domElement)
  25.         // 初始化控制器
  26.         const controls = new OrbitControls(camera, renderer.domElement)
  27.         controls.enableDamping = true
  28.  
  29.         // 创建网格数组
  30.         let phyMeshes: any[] = [] // 物理世界
  31.         let meshes: any[] = [] // 渲染世界
  32.  
  33.         // 设置碰撞组，数值要用2的幂
  34.         const GROUP1 = 1 // 分组立方体
  35.         const GROUP2 = 2 // 分组球体
  36.         const GROUP3 = 4 // 分组圆柱体
  37.         const GROUP4 = 8 // 分组平面
  38.  
  39.         // 创建物理立方体
  40.         const boxShape = new CANNON.Box(new CANNON.Vec3(0.5, 0.5, 0.5))
  41.         // 设置立方体的材质
  42.         const boxMaterialCon = new CANNON.Material("boxMaterial")
  43.         boxMaterialCon.friction = 0
  44.         // 创建一个刚体
  45.         const boxBody = new CANNON.Body({
  46.             shape: boxShape,
  47.             position: new CANNON.Vec3(2, 0.8, 0),
  48.             mass: 1,
  49.             material: boxMaterialCon,
  50.             collisionFilterGroup: GROUP1, // 设置碰撞组
  51.             collisionFilterMask: GROUP2 | GROUP3 | GROUP4, // 碰撞掩码，可以和二组和三、四组碰撞
  52.         })
  53.         // 将刚体添加到物理世界当中
  54.         world.addBody(boxBody)
  55.         phyMeshes.push(boxBody)
  56.         // 创建立方体几何体
  57.         const boxGeometry = new THREE.BoxGeometry(1, 1, 1)
  58.         // 创建立方体材质
  59.         const boxMaterial = new THREE.MeshBasicMaterial({ color: 0x00ff00 })
  60.         // 创建立方体网格
  61.         const boxMesh = new THREE.Mesh(boxGeometry, boxMaterial)
  62.         // 将网格添加到3D场景当中
  63.         scene.add(boxMesh)
  64.         meshes.push(boxMesh)
  65.  
  66.         // 创建物理球
  67.         const spereShape = new CANNON.Sphere(0.5)
  68.         // 创建一个刚体
  69.         const sphereBody = new CANNON.Body({
  70.             shape: spereShape,
  71.             position: new CANNON.Vec3(0, 0.8, 0),
  72.             mass: 1,
  73.             material: boxMaterialCon,
  74.             collisionFilterGroup: GROUP2, // 设置碰撞组
  75.             collisionFilterMask: GROUP1 | GROUP4, // 碰撞掩码，可以和一、四组碰撞
  76.         })
  77.         // 将刚体添加到物理世界当中
  78.         world.addBody(sphereBody)
  79.         phyMeshes.push(sphereBody)
  80.         // 创建球的几何体
  81.         const sphereGeometry = new THREE.SphereGeometry(0.5, 32, 32)
  82.         // 创建球的材质
  83.         const sphereMaterial = new THREE.MeshBasicMaterial({ color: 0x0000ff })
  84.         // 创建球网格
  85.         const sphereMesh = new THREE.Mesh(sphereGeometry, sphereMaterial)
  86.         // 将网格添加到3D场景当中
  87.         scene.add(sphereMesh)
  88.         meshes.push(sphereMesh)
  89.  
  90.         // 创建物理圆柱体
  91.         const cylinderShape = new CANNON.Cylinder(0.5, 0.5, 1, 32)
  92.         // 创建一个刚体
  93.         const cylinderBody = new CANNON.Body({
  94.             shape: cylinderShape,
  95.             position: new CANNON.Vec3(-2, 0.8, 0),
  96.             mass: 1,
  97.             material: boxMaterialCon,
  98.             collisionFilterGroup: GROUP3, // 设置碰撞组
  99.             collisionFilterMask: GROUP1 | GROUP4, // 碰撞掩码，可以和一、四组碰撞
  100.         })
  101.         // 将刚体添加到物理世界当中
  102.         world.addBody(cylinderBody)
  103.         phyMeshes.push(cylinderBody)
  104.         // 创建圆柱体几何体
  105.         const cylinderGeometry = new THREE.CylinderGeometry(0.5 ,0.5, 1, 32)
  106.         // 创建圆柱体材质
  107.         const cylinderMaterial = new THREE.MeshBasicMaterial({ color: 0xff0000 })
  108.         // 创建圆柱体网格
  109.         const cylinderMesh = new THREE.Mesh(cylinderGeometry, cylinderMaterial)
  110.         // 将网格添加到3D场景当中
  111.         scene.add(cylinderMesh)
  112.         meshes.push(cylinderMesh)
  113.  
  114.         // 创建一个物理世界的平面
  115.         // const planeShape = new CANNON.Plane()
  116.         const planeShape = new CANNON.Box(new CANNON.Vec3(5, 0.1, 5))
  117.         // 创建一个刚体
  118.         const planeBody = new CANNON.Body({
  119.             // mass: 0, // 设置质量为0，不受碰撞的影响
  120.             shape: planeShape,
  121.             position: new CANNON.Vec3(0, 0.1, 0),
  122.             type: CANNON.Body.STATIC, // 设置物体为静态，不受碰撞的影响
  123.             material: boxMaterialCon,
  124.             collisionFilterGroup: GROUP4, // 设置碰撞组
  125.             collisionFilterMask: GROUP1 | GROUP2 | GROUP3, // 碰撞掩码，可以和一组、二组和三组碰撞
  126.         })
  127.         // 设置刚体旋转（设置旋转X轴）
  128.         // planeBody.quaternion.setFromAxisAngle(new CANNON.Vec3(1, 0, 0), 0.1)
  129.         // 将刚体添加到物理世界当中
  130.         world.addBody(planeBody)
  131.         // 物理世界创建的东西不显示，所以我们要再通过three.js再创建一个平面
  132.         // const planeGeometry = new THREE.PlaneGeometry(10, 10) // 因为渲染的东西不是无限衍生，这里给10x10
  133.         const planeGeometry = new THREE.BoxGeometry(10, 0.2, 10)
  134.         // 创建一个平面材质
  135.         const planeMaterial = new THREE.MeshBasicMaterial({ color: 0xffff00 })
  136.         // 创建一个平面网格
  137.         const planeMesh = new THREE.Mesh(planeGeometry, planeMaterial)
  138.         // 旋转平面90度让其平铺
  139.         // planeMesh.rotation.x = 0.1
  140.         // 将网格添加到3D场景当中
  141.         scene.add(planeMesh)
  142.  
  143.         // 设置立方体的初始速度
  144.         boxBody.velocity.set(-2, 0, 0)
  145.  
  146.         
  147.         // 渲染
  148.         let clock = new THREE.Clock()
  149.         const animate = () => {
  150.             // 获取了两次渲染之间的时间差，通常用于控制动画和物理模拟。
  151.             let delta = clock.getDelta()
  152.             world.step(delta)
  153.             // 使用时间差来推进物理世界的模拟
  154.             for(let i = 0; i < phyMeshes.length; i++) {
  155.                 meshes[i].position.copy(phyMeshes[i].position)
  156.                 meshes[i].quaternion.copy(phyMeshes[i].quaternion)
  157.             }
  158.             controls.update()
  159.             renderer.render(scene, camera)
  160.             requestAnimationFrame(animate)
  161.         }
  162.         animate()
  163.  
  164.         return () => {
  165.             <div></div>
  166.         }
  167.     }
  168. })

本篇文章对canon的学习暂时结束，下篇文章将对canon更加深入讲解！！！

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/很楠不爱3/article/detail/201290?site
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号