@react-three/rapier 1.5.0 → 2.0.0

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

@@ -144,7 +144,7 @@ const vectorToTuple = v => {
   return [v];
 };
 function useConst(initialValue) {
-  const ref = React.useRef();
+  const ref = React.useRef(undefined);
   if (ref.current === undefined) {
     ref.current = {
       value: typeof initialValue === "function" ? initialValue() : initialValue
@@ -208,7 +208,7 @@ function _objectWithoutPropertiesLoose(r, e) {
   if (null == r) return {};
   var t = {};
   for (var n in r) if ({}.hasOwnProperty.call(r, n)) {
-    if (e.includes(n)) continue;
+    if (-1 !== e.indexOf(n)) continue;
     t[n] = r[n];
   }
   return t;
@@ -220,13 +220,13 @@ function _objectWithoutProperties(e, t) {
     r,
     i = _objectWithoutPropertiesLoose(e, t);
   if (Object.getOwnPropertySymbols) {
-    var s = Object.getOwnPropertySymbols(e);
-    for (r = 0; r < s.length; r++) o = s[r], t.includes(o) || {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]);
+    var n = Object.getOwnPropertySymbols(e);
+    for (r = 0; r < n.length; r++) o = n[r], -1 === t.indexOf(o) && {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]);
   }
   return i;
 }
 
-const _excluded$2 = ["mass", "linearDamping", "angularDamping", "type", "onCollisionEnter", "onCollisionExit", "onIntersectionEnter", "onIntersectionExit", "onContactForce", "children", "canSleep", "ccd", "gravityScale", "softCcdPrediction"];
+const _excluded$2 = ["mass", "linearDamping", "angularDamping", "type", "onCollisionEnter", "onCollisionExit", "onIntersectionEnter", "onIntersectionExit", "onContactForce", "children", "canSleep", "ccd", "gravityScale", "softCcdPrediction", "ref"];
 const scaleColliderArgs = (shape, args, scale) => {
   const newArgs = args.slice();
 
@@ -1017,11 +1017,25 @@ function _extends() {
   }, _extends.apply(null, arguments);
 }
 
+// Need to catch the case where forwardedRef is a function... how to do that?
+const useForwardedRef = (forwardedRef, defaultValue = null) => {
+  const innerRef = React.useRef(defaultValue);
+
+  // Update the forwarded ref when the inner ref changes
+  if (forwardedRef && typeof forwardedRef !== "function") {
+    if (!forwardedRef.current) {
+      forwardedRef.current = innerRef.current;
+    }
+    return forwardedRef;
+  }
+  return innerRef;
+};
+
 /**
  * Initiate an instance and return a safe getter
  */
 const useImperativeInstance = (createFn, destroyFn, dependencyList) => {
-  const ref = React.useRef();
+  const ref = React.useRef(undefined);
   const getInstance = React.useCallback(() => {
     if (!ref.current) {
       ref.current = createFn();
@@ -1040,6 +1054,156 @@ const useImperativeInstance = (createFn, destroyFn, dependencyList) => {
   return getInstance;
 };
 
+const rigidBodyDescFromOptions = options => {
+  var _options$canSleep;
+  const type = rigidBodyTypeFromString((options === null || options === void 0 ? void 0 : options.type) || "dynamic");
+  const desc = new rapier3dCompat.RigidBodyDesc(type);
+
+  // Apply immutable options
+  desc.canSleep = (_options$canSleep = options === null || options === void 0 ? void 0 : options.canSleep) !== null && _options$canSleep !== void 0 ? _options$canSleep : true;
+  return desc;
+};
+const createRigidBodyState = ({
+  rigidBody,
+  object,
+  setMatrix,
+  getMatrix,
+  worldScale,
+  meshType: _meshType = "mesh"
+}) => {
+  object.updateWorldMatrix(true, false);
+  const invertedWorldMatrix = object.parent.matrixWorld.clone().invert();
+  return {
+    object,
+    rigidBody,
+    invertedWorldMatrix,
+    setMatrix: setMatrix ? setMatrix : matrix => {
+      object.matrix.copy(matrix);
+    },
+    getMatrix: getMatrix ? getMatrix : matrix => matrix.copy(object.matrix),
+    scale: worldScale || object.getWorldScale(_scale).clone(),
+    isSleeping: false,
+    meshType: _meshType
+  };
+};
+const immutableRigidBodyOptions = ["args", "colliders", "canSleep"];
+const mutableRigidBodyOptions = {
+  gravityScale: (rb, value) => {
+    rb.setGravityScale(value, true);
+  },
+  additionalSolverIterations(rb, value) {
+    rb.setAdditionalSolverIterations(value);
+  },
+  linearDamping: (rb, value) => {
+    rb.setLinearDamping(value);
+  },
+  angularDamping: (rb, value) => {
+    rb.setAngularDamping(value);
+  },
+  dominanceGroup: (rb, value) => {
+    rb.setDominanceGroup(value);
+  },
+  enabledRotations: (rb, [x, y, z]) => {
+    rb.setEnabledRotations(x, y, z, true);
+  },
+  enabledTranslations: (rb, [x, y, z]) => {
+    rb.setEnabledTranslations(x, y, z, true);
+  },
+  lockRotations: (rb, value) => {
+    rb.lockRotations(value, true);
+  },
+  lockTranslations: (rb, value) => {
+    rb.lockTranslations(value, true);
+  },
+  angularVelocity: (rb, [x, y, z]) => {
+    rb.setAngvel({
+      x,
+      y,
+      z
+    }, true);
+  },
+  linearVelocity: (rb, [x, y, z]) => {
+    rb.setLinvel({
+      x,
+      y,
+      z
+    }, true);
+  },
+  ccd: (rb, value) => {
+    rb.enableCcd(value);
+  },
+  softCcdPrediction: (rb, value) => {
+    rb.setSoftCcdPrediction(value);
+  },
+  userData: (rb, value) => {
+    rb.userData = value;
+  },
+  type(rb, value) {
+    rb.setBodyType(rigidBodyTypeFromString(value), true);
+  },
+  position: () => {},
+  rotation: () => {},
+  quaternion: () => {},
+  scale: () => {}
+};
+const mutableRigidBodyOptionKeys = Object.keys(mutableRigidBodyOptions);
+const setRigidBodyOptions = (rigidBody, options, states, updateTranslations = true) => {
+  if (!rigidBody) {
+    return;
+  }
+  const state = states.get(rigidBody.handle);
+  if (state) {
+    if (updateTranslations) {
+      state.object.updateWorldMatrix(true, false);
+      _matrix4.copy(state.object.matrixWorld).decompose(_position, _rotation, _scale);
+      rigidBody.setTranslation(_position, false);
+      rigidBody.setRotation(_rotation, false);
+    }
+    mutableRigidBodyOptionKeys.forEach(key => {
+      if (key in options) {
+        mutableRigidBodyOptions[key](rigidBody, options[key]);
+      }
+    });
+  }
+};
+const useUpdateRigidBodyOptions = (getRigidBody, 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(() => {
+    const rigidBody = getRigidBody();
+    setRigidBodyOptions(rigidBody, props, states, updateTranslations);
+  }, mutablePropsAsFlatArray);
+};
+const useRigidBodyEvents = (getRigidBody, props, events) => {
+  const {
+    onWake,
+    onSleep,
+    onCollisionEnter,
+    onCollisionExit,
+    onIntersectionEnter,
+    onIntersectionExit,
+    onContactForce
+  } = props;
+  const eventHandlers = {
+    onWake,
+    onSleep,
+    onCollisionEnter,
+    onCollisionExit,
+    onIntersectionEnter,
+    onIntersectionExit,
+    onContactForce
+  };
+  React.useEffect(() => {
+    const rigidBody = getRigidBody();
+    events.set(rigidBody.handle, eventHandlers);
+    return () => {
+      events.delete(rigidBody.handle);
+    };
+  }, [onWake, onSleep, onCollisionEnter, onCollisionExit, onIntersectionEnter, onIntersectionExit, onContactForce]);
+};
+
 /**
  * Takes an object resembling a Vector3 and returs a Three.Vector3
  * @category Math helpers
@@ -1090,25 +1254,11 @@ const euler = ({
   return new three.Euler(x, y, z);
 };
 
-// Need to catch the case where forwardedRef is a function... how to do that?
-const useForwardedRef = (forwardedRef, defaultValue = null) => {
-  const innerRef = React.useRef(defaultValue);
-
-  // Update the forwarded ref when the inner ref changes
-  if (forwardedRef && typeof forwardedRef !== "function") {
-    if (!forwardedRef.current) {
-      forwardedRef.current = innerRef.current;
-    }
-    return forwardedRef;
-  }
-  return innerRef;
-};
-
 /**
  * A collider is a shape that can be attached to a rigid body to define its physical properties.
  * @internal
  */
-const AnyCollider = /*#__PURE__*/React.memo(/*#__PURE__*/React.forwardRef((props, forwardedRef) => {
+const AnyCollider = /*#__PURE__*/React.memo(props => {
   const {
     children,
     position,
@@ -1123,16 +1273,18 @@ const AnyCollider = /*#__PURE__*/React.memo(/*#__PURE__*/React.forwardRef((props
     colliderStates
   } = useRapier();
   const rigidBodyContext = useRigidBodyContext();
-  const colliderRef = useForwardedRef(forwardedRef);
+  const colliderRef = useForwardedRef(props.ref);
   const objectRef = React.useRef(null);
 
   // We spread the props out here to make sure that the ref is updated when the props change.
-  const immutablePropArray = immutableColliderOptions.flatMap(key => Array.isArray(props[key]) ? [...props[key]] : props[key]);
+  const immutablePropArray = immutableColliderOptions.flatMap(key =>
+  // Array.isArray(props[key]) ? [...props[key]] : props[key]
+  Array.isArray(props[key]) ? props[key] : [props[key]]);
   const getInstance = useImperativeInstance(() => {
     const worldScale = objectRef.current.getWorldScale(vec3());
     const collider = createColliderFromOptions(props, world, worldScale, rigidBodyContext === null || rigidBodyContext === void 0 ? void 0 : rigidBodyContext.getRigidBody);
-    if (typeof forwardedRef == "function") {
-      forwardedRef(collider);
+    if (typeof props.ref == "function") {
+      props.ref(collider);
     }
     colliderRef.current = collider;
     return collider;
@@ -1161,7 +1313,7 @@ const AnyCollider = /*#__PURE__*/React.memo(/*#__PURE__*/React.forwardRef((props
     ref: objectRef,
     name: name
   }, children);
-}));
+});
 /**
  * A cuboid collider shape
  * @category Colliders
@@ -1264,165 +1416,16 @@ const ConvexHullCollider = /*#__PURE__*/React__default["default"].forwardRef((pr
 })));
 ConvexHullCollider.displayName = "ConvexHullCollider";
 
-const rigidBodyDescFromOptions = options => {
-  var _options$canSleep;
-  const type = rigidBodyTypeFromString((options === null || options === void 0 ? void 0 : options.type) || "dynamic");
-  const desc = new rapier3dCompat.RigidBodyDesc(type);
-
-  // Apply immutable options
-  desc.canSleep = (_options$canSleep = options === null || options === void 0 ? void 0 : options.canSleep) !== null && _options$canSleep !== void 0 ? _options$canSleep : true;
-  return desc;
-};
-const createRigidBodyState = ({
-  rigidBody,
-  object,
-  setMatrix,
-  getMatrix,
-  worldScale,
-  meshType: _meshType = "mesh"
-}) => {
-  object.updateWorldMatrix(true, false);
-  const invertedWorldMatrix = object.parent.matrixWorld.clone().invert();
-  return {
-    object,
-    rigidBody,
-    invertedWorldMatrix,
-    setMatrix: setMatrix ? setMatrix : matrix => {
-      object.matrix.copy(matrix);
-    },
-    getMatrix: getMatrix ? getMatrix : matrix => matrix.copy(object.matrix),
-    scale: worldScale || object.getWorldScale(_scale).clone(),
-    isSleeping: false,
-    meshType: _meshType
-  };
-};
-const immutableRigidBodyOptions = ["args", "colliders", "canSleep"];
-const mutableRigidBodyOptions = {
-  gravityScale: (rb, value) => {
-    rb.setGravityScale(value, true);
-  },
-  additionalSolverIterations(rb, value) {
-    rb.setAdditionalSolverIterations(value);
-  },
-  linearDamping: (rb, value) => {
-    rb.setLinearDamping(value);
-  },
-  angularDamping: (rb, value) => {
-    rb.setAngularDamping(value);
-  },
-  dominanceGroup: (rb, value) => {
-    rb.setDominanceGroup(value);
-  },
-  enabledRotations: (rb, [x, y, z]) => {
-    rb.setEnabledRotations(x, y, z, true);
-  },
-  enabledTranslations: (rb, [x, y, z]) => {
-    rb.setEnabledTranslations(x, y, z, true);
-  },
-  lockRotations: (rb, value) => {
-    rb.lockRotations(value, true);
-  },
-  lockTranslations: (rb, value) => {
-    rb.lockTranslations(value, true);
-  },
-  angularVelocity: (rb, [x, y, z]) => {
-    rb.setAngvel({
-      x,
-      y,
-      z
-    }, true);
-  },
-  linearVelocity: (rb, [x, y, z]) => {
-    rb.setLinvel({
-      x,
-      y,
-      z
-    }, true);
-  },
-  ccd: (rb, value) => {
-    rb.enableCcd(value);
-  },
-  softCcdPrediction: (rb, value) => {
-    rb.setSoftCcdPrediction(value);
-  },
-  userData: (rb, value) => {
-    rb.userData = value;
-  },
-  type(rb, value) {
-    rb.setBodyType(rigidBodyTypeFromString(value), true);
-  },
-  position: () => {},
-  rotation: () => {},
-  quaternion: () => {},
-  scale: () => {}
-};
-const mutableRigidBodyOptionKeys = Object.keys(mutableRigidBodyOptions);
-const setRigidBodyOptions = (rigidBody, options, states, updateTranslations = true) => {
-  if (!rigidBody) {
-    return;
-  }
-  const state = states.get(rigidBody.handle);
-  if (state) {
-    if (updateTranslations) {
-      state.object.updateWorldMatrix(true, false);
-      _matrix4.copy(state.object.matrixWorld).decompose(_position, _rotation, _scale);
-      rigidBody.setTranslation(_position, false);
-      rigidBody.setRotation(_rotation, false);
-    }
-    mutableRigidBodyOptionKeys.forEach(key => {
-      if (key in options) {
-        mutableRigidBodyOptions[key](rigidBody, options[key]);
-      }
-    });
-  }
-};
-const useUpdateRigidBodyOptions = (getRigidBody, 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(() => {
-    const rigidBody = getRigidBody();
-    setRigidBodyOptions(rigidBody, props, states, updateTranslations);
-  }, mutablePropsAsFlatArray);
-};
-const useRigidBodyEvents = (getRigidBody, props, events) => {
-  const {
-    onWake,
-    onSleep,
-    onCollisionEnter,
-    onCollisionExit,
-    onIntersectionEnter,
-    onIntersectionExit,
-    onContactForce
-  } = props;
-  const eventHandlers = {
-    onWake,
-    onSleep,
-    onCollisionEnter,
-    onCollisionExit,
-    onIntersectionEnter,
-    onIntersectionExit,
-    onContactForce
-  };
-  React.useEffect(() => {
-    const rigidBody = getRigidBody();
-    events.set(rigidBody.handle, eventHandlers);
-    return () => {
-      events.delete(rigidBody.handle);
-    };
-  }, [onWake, onSleep, onCollisionEnter, onCollisionExit, onIntersectionEnter, onIntersectionExit, onContactForce]);
-};
-
-const _excluded$1 = ["children", "type", "position", "rotation", "scale", "quaternion", "transformState"];
+const _excluded$1 = ["ref", "children", "type", "position", "rotation", "scale", "quaternion", "transformState"];
 const RigidBodyContext = /*#__PURE__*/React.createContext(undefined);
 const useRigidBodyContext = () => React.useContext(RigidBodyContext);
 /**
  * A rigid body is a physical object that can be simulated by the physics engine.
  * @category Components
  */
-const RigidBody = /*#__PURE__*/React.memo(/*#__PURE__*/React.forwardRef((props, forwardedRef) => {
+const RigidBody = /*#__PURE__*/React.memo(props => {
   const {
+      ref,
       children,
       type,
       position,
@@ -1433,7 +1436,7 @@ const RigidBody = /*#__PURE__*/React.memo(/*#__PURE__*/React.forwardRef((props,
     } = props,
     objectProps = _objectWithoutProperties(props, _excluded$1);
   const objectRef = React.useRef(null);
-  const rigidBodyRef = useForwardedRef(forwardedRef);
+  const rigidBodyRef = useForwardedRef(ref);
   const {
     world,
     rigidBodyStates,
@@ -1454,8 +1457,8 @@ const RigidBody = /*#__PURE__*/React.memo(/*#__PURE__*/React.forwardRef((props,
   const getRigidBody = useImperativeInstance(() => {
     const desc = rigidBodyDescFromOptions(mergedOptions);
     const rigidBody = world.createRigidBody(desc);
-    if (typeof forwardedRef === "function") {
-      forwardedRef(rigidBody);
+    if (typeof ref === "function") {
+      ref(rigidBody);
     }
     rigidBodyRef.current = rigidBody;
     return rigidBody;
@@ -1498,7 +1501,7 @@ const RigidBody = /*#__PURE__*/React.memo(/*#__PURE__*/React.forwardRef((props,
   }), children, childColliderProps.map((colliderProps, index) => /*#__PURE__*/React__default["default"].createElement(AnyCollider, _extends({
     key: index
   }, colliderProps)))));
-}));
+});
 RigidBody.displayName = "RigidBody";
 
 /**
@@ -1535,9 +1538,14 @@ const MeshCollider = /*#__PURE__*/React.memo(props => {
 });
 MeshCollider.displayName = "MeshCollider";
 
-const _excluded = ["children", "instances", "colliderNodes", "position", "rotation", "quaternion", "scale"];
-const InstancedRigidBodies = /*#__PURE__*/React.memo(/*#__PURE__*/React.forwardRef((props, forwardedRef) => {
-  const rigidBodiesRef = useForwardedRef(forwardedRef, []);
+const _excluded = ["ref"],
+  _excluded2 = ["children", "instances", "colliderNodes", "position", "rotation", "quaternion", "scale"];
+const InstancedRigidBodies = /*#__PURE__*/React.memo(_ref => {
+  let {
+      ref
+    } = _ref,
+    props = _objectWithoutProperties(_ref, _excluded);
+  const rigidBodiesRef = useForwardedRef(ref, []);
   const objectRef = React.useRef(null);
   const instanceWrapperRef = React.useRef(null);
   const {
@@ -1553,7 +1561,7 @@ const InstancedRigidBodies = /*#__PURE__*/React.memo(/*#__PURE__*/React.forwardR
 
       // rigid body specific props, and r3f-object props
     } = props,
-    rigidBodyProps = _objectWithoutProperties(props, _excluded);
+    rigidBodyProps = _objectWithoutProperties(props, _excluded2);
   const childColliderProps = useChildColliderProps(objectRef, _objectSpread2(_objectSpread2({}, props), {}, {
     children: undefined
   }));
@@ -1601,14 +1609,16 @@ const InstancedRigidBodies = /*#__PURE__*/React.memo(/*#__PURE__*/React.forwardR
   }), /*#__PURE__*/React__default["default"].createElement("object3D", {
     ref: instanceWrapperRef
   }, children), instances === null || instances === void 0 ? void 0 : instances.map((instance, index) => /*#__PURE__*/React__default["default"].createElement(RigidBody, _extends({}, rigidBodyProps, instance, {
-    ref: body => rigidBodiesRef.current[index] = body,
+    ref: body => {
+      rigidBodiesRef.current[index] = body;
+    },
     transformState: state => applyInstancedState(state, index)
   }), /*#__PURE__*/React__default["default"].createElement(React__default["default"].Fragment, null, colliderNodes.map((node, index) => /*#__PURE__*/React__default["default"].createElement(React.Fragment, {
     key: index
   }, node)), childColliderProps.map((colliderProps, colliderIndex) => /*#__PURE__*/React__default["default"].createElement(AnyCollider, _extends({
     key: colliderIndex
   }, colliderProps)))))));
-}));
+});
 InstancedRigidBodies.displayName = "InstancedRigidBodies";
 
 /**
@@ -1618,7 +1628,7 @@ const useImpulseJoint = (body1, body2, params) => {
   const {
     world
   } = useRapier();
-  const jointRef = React.useRef();
+  const jointRef = React.useRef(undefined);
   useImperativeInstance(() => {
     if (body1.current && body2.current) {
       const newJoint = world.createImpulseJoint(params, body1.current, body2.current, true);