@react-three/rapier 0.7.4 → 0.7.6

package/dist/react-three-rapier.cjs.prod.js

@@ -73,6 +73,23 @@ const scaleVertices = (vertices, scale) => {
 
   return scaledVerts;
 };
+const vectorToTuple = v => {
+  if (!v) return [0];
+
+  if (v instanceof three.Quaternion) {
+    return [v.x, v.y, v.z, v.w];
+  }
+
+  if (v instanceof three.Vector3 || v instanceof three.Euler) {
+    return [v.x, v.y, v.z];
+  }
+
+  if (Array.isArray(v)) {
+    return v;
+  }
+
+  return [v];
+};
 
 const createRigidBodyApi = ref => {
   return {
@@ -84,24 +101,24 @@ const createRigidBodyApi = ref => {
 
     mass: () => ref.current().mass(),
 
-    applyImpulse(impulseVector) {
-      ref.current().applyImpulse(impulseVector, true);
+    applyImpulse(impulseVector, wakeUp = true) {
+      ref.current().applyImpulse(impulseVector, wakeUp);
     },
 
-    applyTorqueImpulse(torqueVector) {
-      ref.current().applyTorqueImpulse(torqueVector, true);
+    applyTorqueImpulse(torqueVector, wakeUp = true) {
+      ref.current().applyTorqueImpulse(torqueVector, wakeUp);
     },
 
-    applyImpulseAtPoint: (impulseVector, impulsePoint) => ref.current().applyImpulseAtPoint(impulseVector, impulsePoint, true),
-    addForce: force => ref.current().addForce(force, true),
-    addForceAtPoint: (force, point) => ref.current().addForceAtPoint(force, point, true),
-    addTorque: torque => ref.current().addTorque(torque, true),
+    applyImpulseAtPoint: (impulseVector, impulsePoint, wakeUp = true) => ref.current().applyImpulseAtPoint(impulseVector, impulsePoint, wakeUp),
+    addForce: (force, wakeUp = true) => ref.current().addForce(force, wakeUp),
+    addForceAtPoint: (force, point, wakeUp = true) => ref.current().addForceAtPoint(force, point, wakeUp),
+    addTorque: (torque, wakeUp = true) => ref.current().addTorque(torque, wakeUp),
 
     translation() {
       return rapierVector3ToVector3(ref.current().translation());
     },
 
-    setTranslation: translation => ref.current().setTranslation(translation, true),
+    setTranslation: (translation, wakeUp = true) => ref.current().setTranslation(translation, wakeUp),
 
     rotation() {
       const {
@@ -113,8 +130,8 @@ const createRigidBodyApi = ref => {
       return new three.Quaternion(x, y, z, w);
     },
 
-    setRotation: rotation => {
-      ref.current().setRotation(rotation, true);
+    setRotation: (rotation, wakeUp = true) => {
+      ref.current().setRotation(rotation, wakeUp);
     },
 
     linvel() {
@@ -126,7 +143,7 @@ const createRigidBodyApi = ref => {
       return new three.Vector3(x, y, z);
     },
 
-    setLinvel: velocity => ref.current().setLinvel(velocity, true),
+    setLinvel: (velocity, wakeUp = true) => ref.current().setLinvel(velocity, wakeUp),
 
     angvel() {
       const {
@@ -137,7 +154,7 @@ const createRigidBodyApi = ref => {
       return new three.Vector3(x, y, z);
     },
 
-    setAngvel: velocity => ref.current().setAngvel(velocity, true),
+    setAngvel: (velocity, wakeUp = true) => ref.current().setAngvel(velocity, wakeUp),
 
     linearDamping() {
       return ref.current().linearDamping();
@@ -154,12 +171,12 @@ const createRigidBodyApi = ref => {
       ref.current().setNextKinematicRotation(rotation);
     },
     setNextKinematicTranslation: translation => ref.current().setNextKinematicTranslation(translation),
-    resetForces: () => ref.current().resetForces(true),
-    resetTorques: () => ref.current().resetTorques(true),
-    lockRotations: locked => ref.current().lockRotations(locked, true),
-    lockTranslations: locked => ref.current().lockTranslations(locked, true),
-    setEnabledRotations: (x, y, z) => ref.current().setEnabledRotations(x, y, z, true),
-    setEnabledTranslations: (x, y, z) => ref.current().setEnabledTranslations(x, y, z, true)
+    resetForces: (wakeUp = true) => ref.current().resetForces(wakeUp),
+    resetTorques: (wakeUp = true) => ref.current().resetTorques(wakeUp),
+    lockRotations: (locked, wakeUp = true) => ref.current().lockRotations(locked, wakeUp),
+    lockTranslations: (locked, wakeUp = true) => ref.current().lockTranslations(locked, wakeUp),
+    setEnabledRotations: (x, y, z, wakeUp = true) => ref.current().setEnabledRotations(x, y, z, wakeUp),
+    setEnabledTranslations: (x, y, z, wakeUp = true) => ref.current().setEnabledTranslations(x, y, z, wakeUp)
   };
 };
 const createInstancedRigidBodiesApi = bodiesGetter => ({
@@ -182,9 +199,9 @@ const createWorldApi = ref => {
     createRigidBody: desc => ref.current().createRigidBody(desc),
     createCollider: (desc, rigidBody) => ref.current().createCollider(desc, rigidBody),
     removeRigidBody: rigidBody => ref.current().removeRigidBody(rigidBody),
-    removeCollider: collider => ref.current().removeCollider(collider, true),
-    createImpulseJoint: (params, rigidBodyA, rigidBodyB) => ref.current().createImpulseJoint(params, rigidBodyA, rigidBodyB, true),
-    removeImpulseJoint: joint => ref.current().removeImpulseJoint(joint, true),
+    removeCollider: (collider, wakeUp = true) => ref.current().removeCollider(collider, wakeUp),
+    createImpulseJoint: (params, rigidBodyA, rigidBodyB, wakeUp = true) => ref.current().createImpulseJoint(params, rigidBodyA, rigidBodyB, wakeUp),
+    removeImpulseJoint: (joint, wakeUp = true) => ref.current().removeImpulseJoint(joint, wakeUp),
     forEachCollider: callback => ref.current().forEachCollider(callback),
     setGravity: ({
       x,
@@ -643,7 +660,11 @@ const mutableRigidBodyOptions = {
   },
   ccd: (rb, value) => {
     rb.enableCcd(value);
-  }
+  },
+  position: () => {},
+  rotation: () => {},
+  quaternion: () => {},
+  scale: () => {}
 };
 const mutableRigidBodyOptionKeys = Object.keys(mutableRigidBodyOptions);
 const setRigidBodyOptions = (rigidBody, options, states, updateTranslations = true) => {
@@ -671,6 +692,10 @@ const setRigidBodyOptions = (rigidBody, options, states, updateTranslations = tr
   }
 };
 const useUpdateRigidBodyOptions = (rigidBodyRef, props, states, updateTranslations = true) => {
+  // TODO: Improve this, split each prop into its own effect
+  const mutablePropsAsFlatArray = React.useMemo(() => mutableRigidBodyOptionKeys.flatMap(key => {
+    return vectorToTuple(props[key]);
+  }), [props]);
   React.useEffect(() => {
     if ("length" in rigidBodyRef.current) {
       rigidBodyRef.current.forEach(rigidBody => {
@@ -679,7 +704,7 @@ const useUpdateRigidBodyOptions = (rigidBodyRef, props, states, updateTranslatio
     } else {
       setRigidBodyOptions(rigidBodyRef.current, props, states, updateTranslations);
     }
-  }, [props]);
+  }, mutablePropsAsFlatArray);
 };
 const useRigidBodyEvents = (rigidBodyRef, props, events) => {
   const {
@@ -716,7 +741,7 @@ const useRigidBodyEvents = (rigidBodyRef, props, events) => {
         events.delete(rigidBodyRef.current.handle);
       }
     };
-  }, [onWake, onSleep, onCollisionEnter, onCollisionExit]);
+  }, [onWake, onSleep, onCollisionEnter, onCollisionExit, onIntersectionEnter, onIntersectionExit]);
 };
 
 const scaleColliderArgs = (shape, args, scale) => {
@@ -746,6 +771,32 @@ const createColliderFromOptions = (options, world, scale, rigidBody) => {
   const desc = rapier3dCompat.ColliderDesc[options.shape](...scaledArgs);
   return world.createCollider(desc, rigidBody);
 };
+const massPropertiesConflictError = "Please pick ONLY ONE of the `density`, `mass` and `massProperties` options.";
+
+const setColliderMassOptions = (collider, options) => {
+  if (options.density !== undefined) {
+    if (options.mass !== undefined || options.massProperties !== undefined) {
+      throw new Error(massPropertiesConflictError);
+    }
+
+    collider.setDensity(options.density);
+    return;
+  }
+
+  if (options.mass !== undefined) {
+    if (options.massProperties !== undefined) {
+      throw new Error(massPropertiesConflictError);
+    }
+
+    collider.setMass(options.mass);
+    return;
+  }
+
+  if (options.massProperties !== undefined) {
+    collider.setMassProperties(options.massProperties.mass, options.massProperties.centerOfMass, options.massProperties.principalAngularInertia, options.massProperties.angularInertiaLocalFrame);
+  }
+};
+
 const mutableColliderOptions = {
   sensor: (collider, value) => {
     collider.setSensor(value);
@@ -759,15 +810,20 @@ const mutableColliderOptions = {
   friction: (collider, value) => {
     collider.setFriction(value);
   },
+  frictionCombineRule: (collider, value) => {
+    collider.setFrictionCombineRule(value);
+  },
   restitution: (collider, value) => {
     collider.setRestitution(value);
   },
-  density: (collider, value) => {
-    collider.setDensity(value);
+  restitutionCombineRule: (collider, value) => {
+    collider.setRestitutionCombineRule(value);
   },
-  mass: (collider, value) => {
-    collider.setMass(value);
-  }
+  // To make sure the options all mutalbe options are listed
+  quaternion: () => {},
+  position: () => {},
+  rotation: () => {},
+  scale: () => {}
 };
 const mutableColliderOptionKeys = Object.keys(mutableColliderOptions);
 const setColliderOptions = (collider, options, states) => {
@@ -798,17 +854,26 @@ const setColliderOptions = (collider, options, states) => {
 
     mutableColliderOptionKeys.forEach(key => {
       if (key in options) {
-        mutableColliderOptions[key](collider, options[key]);
+        const option = options[key];
+        mutableColliderOptions[key](collider, // @ts-ignore Option does not want to fit into the function, but it will
+        option, options);
       }
-    });
+    }); // handle mass separately, because the assignments
+    // are exclusive.
+
+    setColliderMassOptions(collider, options);
   }
 };
 const useUpdateColliderOptions = (collidersRef, props, states) => {
+  // TODO: Improve this, split each prop into its own effect
+  const mutablePropsAsFlatArray = React.useMemo(() => mutableColliderOptionKeys.flatMap(key => {
+    return vectorToTuple(props[key]);
+  }), [props]);
   React.useEffect(() => {
     collidersRef.current.forEach(collider => {
       setColliderOptions(collider, props, states);
     });
-  }, [props]);
+  }, mutablePropsAsFlatArray);
 };
 
 const isChildOfMeshCollider = child => {
@@ -949,7 +1014,7 @@ const useColliderEvents = (collidersRef, props, events) => {
 
       (_collidersRef$current2 = collidersRef.current) === null || _collidersRef$current2 === void 0 ? void 0 : _collidersRef$current2.forEach(collider => events.delete(collider.handle));
     };
-  }, [onCollisionEnter, onCollisionExit]);
+  }, [onCollisionEnter, onCollisionExit, onIntersectionEnter, onIntersectionExit]);
 };
 
 const useRapier = () => {
@@ -1109,7 +1174,7 @@ const usePrismaticJoint = (body1, body2, [body1Anchor, body2Anchor, axis]) => {
 };
 
 // Colliders
-const AnyCollider = /*#__PURE__*/React.memo(props => {
+const AnyCollider = /*#__PURE__*/React.memo( /*#__PURE__*/React__default["default"].forwardRef((props, forwardedRef) => {
   const {
     children,
     position,
@@ -1124,7 +1189,15 @@ const AnyCollider = /*#__PURE__*/React.memo(props => {
   } = useRapier();
   const rigidBodyContext = useRigidBodyContext();
   const ref = React.useRef(null);
-  const collidersRef = React.useRef([]);
+  const collidersRef = React.useMemo(() => {
+    if (forwardedRef !== null) {
+      return forwardedRef;
+    }
+
+    const result = /*#__PURE__*/React__default["default"].createRef();
+    result.current = [];
+    return result;
+  }, []);
   React.useEffect(() => {
     const object = ref.current;
     const worldScale = object.getWorldScale(new three.Vector3());
@@ -1169,57 +1242,66 @@ const AnyCollider = /*#__PURE__*/React.memo(props => {
     scale: scale,
     ref: ref
   }, children);
-});
-const CuboidCollider = props => {
+}));
+const CuboidCollider = /*#__PURE__*/React__default["default"].forwardRef((props, ref) => {
   return /*#__PURE__*/React__default["default"].createElement(AnyCollider, _extends({}, props, {
-    shape: "cuboid"
+    shape: "cuboid",
+    ref: ref
   }));
-};
-const RoundCuboidCollider = props => {
+});
+const RoundCuboidCollider = /*#__PURE__*/React__default["default"].forwardRef((props, ref) => {
   return /*#__PURE__*/React__default["default"].createElement(AnyCollider, _extends({}, props, {
-    shape: "roundCuboid"
+    shape: "roundCuboid",
+    ref: ref
   }));
-};
-const BallCollider = props => {
+});
+const BallCollider = /*#__PURE__*/React__default["default"].forwardRef((props, ref) => {
   return /*#__PURE__*/React__default["default"].createElement(AnyCollider, _extends({}, props, {
-    shape: "ball"
+    shape: "ball",
+    ref: ref
   }));
-};
-const CapsuleCollider = props => {
+});
+const CapsuleCollider = /*#__PURE__*/React__default["default"].forwardRef((props, ref) => {
   return /*#__PURE__*/React__default["default"].createElement(AnyCollider, _extends({}, props, {
-    shape: "capsule"
+    shape: "capsule",
+    ref: ref
   }));
-};
-const HeightfieldCollider = props => {
+});
+const HeightfieldCollider = /*#__PURE__*/React__default["default"].forwardRef((props, ref) => {
   return /*#__PURE__*/React__default["default"].createElement(AnyCollider, _extends({}, props, {
-    shape: "heightfield"
+    shape: "heightfield",
+    ref: ref
   }));
-};
-const TrimeshCollider = props => {
+});
+const TrimeshCollider = /*#__PURE__*/React__default["default"].forwardRef((props, ref) => {
   return /*#__PURE__*/React__default["default"].createElement(AnyCollider, _extends({}, props, {
-    shape: "trimesh"
+    shape: "trimesh",
+    ref: ref
   }));
-};
-const ConeCollider = props => {
+});
+const ConeCollider = /*#__PURE__*/React__default["default"].forwardRef((props, ref) => {
   return /*#__PURE__*/React__default["default"].createElement(AnyCollider, _extends({}, props, {
-    shape: "cone"
+    shape: "cone",
+    ref: ref
   }));
-};
-const CylinderCollider = props => {
+});
+const CylinderCollider = /*#__PURE__*/React__default["default"].forwardRef((props, ref) => {
   return /*#__PURE__*/React__default["default"].createElement(AnyCollider, _extends({}, props, {
-    shape: "cylinder"
+    shape: "cylinder",
+    ref: ref
   }));
-};
-const ConvexHullCollider = props => {
+});
+const ConvexHullCollider = /*#__PURE__*/React__default["default"].forwardRef((props, ref) => {
   return /*#__PURE__*/React__default["default"].createElement(AnyCollider, _extends({}, props, {
-    shape: "convexHull"
+    shape: "convexHull",
+    ref: ref
   }));
-};
+});
 
 const _excluded$1 = ["children", "type", "position", "rotation", "scale", "quaternion"];
 const RigidBodyContext = /*#__PURE__*/React.createContext(undefined);
 const useRigidBodyContext = () => React.useContext(RigidBodyContext);
-const RigidBody = /*#__PURE__*/React.forwardRef((props, ref) => {
+const RigidBody = /*#__PURE__*/React.memo( /*#__PURE__*/React.forwardRef((props, ref) => {
   const {
     children,
     type,
@@ -1249,7 +1331,7 @@ const RigidBody = /*#__PURE__*/React.forwardRef((props, ref) => {
   }), children, childColliderProps.map((colliderProps, index) => /*#__PURE__*/React__default["default"].createElement(AnyCollider, _extends({
     key: index
   }, colliderProps)))));
-});
+}));
 
 const MeshCollider = props => {
   const {
@@ -1290,7 +1372,7 @@ const geometryFromCollider = collider => {
           y,
           z
         } = collider.shape.halfExtents;
-        return new three.BoxBufferGeometry(x * 2 + 0.01, y * 2 + 0.01, z * 2 + 0.01);
+        return new three.BoxGeometry(x * 2 + 0.01, y * 2 + 0.01, z * 2 + 0.01);
       }
 
     case rapier3dCompat.ShapeType.RoundCuboid:
@@ -1307,7 +1389,7 @@ const geometryFromCollider = collider => {
     case rapier3dCompat.ShapeType.Ball:
       {
         const r = collider.shape.radius;
-        return new three.SphereBufferGeometry(r + +0.01, 8, 8);
+        return new three.SphereGeometry(r + +0.01, 8, 8);
       }
 
     case rapier3dCompat.ShapeType.TriMesh:
@@ -1339,7 +1421,7 @@ const geometryFromCollider = collider => {
       {
         const r = collider.shape.radius;
         const h = collider.shape.halfHeight;
-        const g = new three.CylinderBufferGeometry(r, r, h * 2);
+        const g = new three.CylinderGeometry(r, r, h * 2);
         return g;
       }
 
@@ -1347,7 +1429,7 @@ const geometryFromCollider = collider => {
       {
         const r = collider.shape.radius;
         const h = collider.shape.halfHeight;
-        const g = new three.CapsuleBufferGeometry(r, h * 2, 4, 8);
+        const g = new three.CapsuleGeometry(r, h * 2, 4, 8);
         return g;
       }
 
@@ -1355,7 +1437,7 @@ const geometryFromCollider = collider => {
       {
         const r = collider.shape.radius;
         const h = collider.shape.halfHeight;
-        const g = new three.ConeBufferGeometry(r, h * 2, 16);
+        const g = new three.ConeGeometry(r, h * 2, 16);
         return g;
       }
 
@@ -1375,7 +1457,7 @@ const geometryFromCollider = collider => {
       }
   }
 
-  return new three.BoxBufferGeometry(1, 1, 1);
+  return new three.BoxGeometry(1, 1, 1);
 };
 
 const DebugShape = /*#__PURE__*/React.memo(({