@react-three/rapier 1.4.0 → 2.0.0-canary.0

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

@@ -31,45 +31,51 @@ function _interopNamespace(e) {
 
 var React__default = /*#__PURE__*/_interopDefault(React);
 
-function _defineProperty(obj, key, value) {
-  if (key in obj) {
-    Object.defineProperty(obj, key, {
-      value: value,
-      enumerable: true,
-      configurable: true,
-      writable: true
-    });
-  } else {
-    obj[key] = value;
+function _toPrimitive(t, r) {
+  if ("object" != typeof t || !t) return t;
+  var e = t[Symbol.toPrimitive];
+  if (void 0 !== e) {
+    var i = e.call(t, r || "default");
+    if ("object" != typeof i) return i;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
   }
+  return ("string" === r ? String : Number)(t);
+}
 
-  return obj;
+function _toPropertyKey(t) {
+  var i = _toPrimitive(t, "string");
+  return "symbol" == typeof i ? i : i + "";
 }
 
-function ownKeys(object, enumerableOnly) {
-  var keys = Object.keys(object);
+function _defineProperty(e, r, t) {
+  return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+    value: t,
+    enumerable: !0,
+    configurable: !0,
+    writable: !0
+  }) : e[r] = t, e;
+}
 
+function ownKeys(e, r) {
+  var t = Object.keys(e);
   if (Object.getOwnPropertySymbols) {
-    var symbols = Object.getOwnPropertySymbols(object);
-    enumerableOnly && (symbols = symbols.filter(function (sym) {
-      return Object.getOwnPropertyDescriptor(object, sym).enumerable;
-    })), keys.push.apply(keys, symbols);
+    var o = Object.getOwnPropertySymbols(e);
+    r && (o = o.filter(function (r) {
+      return Object.getOwnPropertyDescriptor(e, r).enumerable;
+    })), t.push.apply(t, o);
   }
-
-  return keys;
+  return t;
 }
-
-function _objectSpread2(target) {
-  for (var i = 1; i < arguments.length; i++) {
-    var source = null != arguments[i] ? arguments[i] : {};
-    i % 2 ? ownKeys(Object(source), !0).forEach(function (key) {
-      _defineProperty(target, key, source[key]);
-    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) {
-      Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+function _objectSpread2(e) {
+  for (var r = 1; r < arguments.length; r++) {
+    var t = null != arguments[r] ? arguments[r] : {};
+    r % 2 ? ownKeys(Object(t), !0).forEach(function (r) {
+      _defineProperty(e, r, t[r]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) {
+      Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
     });
   }
-
-  return target;
+  return e;
 }
 
 const _quaternion = new three.Quaternion();
@@ -117,41 +123,33 @@ const rigidBodyTypeMap = {
 const rigidBodyTypeFromString = type => rigidBodyTypeMap[type];
 const scaleVertices = (vertices, scale) => {
   const scaledVerts = Array.from(vertices);
-
   for (let i = 0; i < vertices.length / 3; i++) {
     scaledVerts[i * 3] *= scale.x;
     scaledVerts[i * 3 + 1] *= scale.y;
     scaledVerts[i * 3 + 2] *= scale.z;
   }
-
   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];
 };
 function useConst(initialValue) {
-  const ref = React.useRef();
-
+  const ref = React.useRef(undefined);
   if (ref.current === undefined) {
     ref.current = {
       value: typeof initialValue === "function" ? initialValue() : initialValue
     };
   }
-
   return ref.current.value;
 }
 
@@ -170,7 +168,6 @@ const useRaf = callback => {
       cb.current(delta / 1000);
       lastFrame.current = now;
     };
-
     raf.current = requestAnimationFrame(loop);
     return () => cancelAnimationFrame(raf.current);
   }, []);
@@ -185,7 +182,6 @@ const UseFrameStepper = ({
   }, updatePriority);
   return null;
 };
-
 const RafStepper = ({
   onStep
 }) => {
@@ -194,7 +190,6 @@ const RafStepper = ({
   });
   return null;
 };
-
 const FrameStepper = ({
   onStep,
   type,
@@ -207,98 +202,80 @@ const FrameStepper = ({
     updatePriority: updatePriority
   });
 };
-
 var FrameStepper$1 = /*#__PURE__*/React.memo(FrameStepper);
 
-function _objectWithoutPropertiesLoose(source, excluded) {
-  if (source == null) return {};
-  var target = {};
-  var sourceKeys = Object.keys(source);
-  var key, i;
-
-  for (i = 0; i < sourceKeys.length; i++) {
-    key = sourceKeys[i];
-    if (excluded.indexOf(key) >= 0) continue;
-    target[key] = source[key];
+function _objectWithoutPropertiesLoose(r, e) {
+  if (null == r) return {};
+  var t = {};
+  for (var n in r) if ({}.hasOwnProperty.call(r, n)) {
+    if (-1 !== e.indexOf(n)) continue;
+    t[n] = r[n];
   }
-
-  return target;
+  return t;
 }
 
-function _objectWithoutProperties(source, excluded) {
-  if (source == null) return {};
-  var target = _objectWithoutPropertiesLoose(source, excluded);
-  var key, i;
-
+function _objectWithoutProperties(e, t) {
+  if (null == e) return {};
+  var o,
+    r,
+    i = _objectWithoutPropertiesLoose(e, t);
   if (Object.getOwnPropertySymbols) {
-    var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
-
-    for (i = 0; i < sourceSymbolKeys.length; i++) {
-      key = sourceSymbolKeys[i];
-      if (excluded.indexOf(key) >= 0) continue;
-      if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
-      target[key] = source[key];
-    }
+    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 target;
+  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(); // Heightfield uses a vector
+  const newArgs = args.slice();
 
+  // Heightfield uses a vector
   if (shape === "heightfield") {
     const s = newArgs[3];
     s.x *= scale.x;
     s.x *= scale.y;
     s.x *= scale.z;
     return newArgs;
-  } // Trimesh and convex scale the vertices
-
+  }
 
+  // Trimesh and convex scale the vertices
   if (shape === "trimesh" || shape === "convexHull") {
     newArgs[0] = scaleVertices(newArgs[0], scale);
     return newArgs;
-  } // Prepfill with some extra
-
+  }
 
+  // Prepfill with some extra
   const scaleArray = [scale.x, scale.y, scale.z, scale.x, scale.x];
   return newArgs.map((arg, index) => scaleArray[index] * arg);
 };
 const createColliderFromOptions = (options, world, scale, getRigidBody) => {
-  const scaledArgs = scaleColliderArgs(options.shape, options.args, scale); // @ts-ignore
-
+  const scaledArgs = scaleColliderArgs(options.shape, options.args, scale);
+  // @ts-ignore
   const desc = rapier3dCompat.ColliderDesc[options.shape](...scaledArgs);
   return world.createCollider(desc, getRigidBody === null || getRigidBody === void 0 ? void 0 : getRigidBody());
 };
 const immutableColliderOptions = ["shape", "args"];
 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);
@@ -336,23 +313,17 @@ const mutableColliderOptions = {
 const mutableColliderOptionKeys = Object.keys(mutableColliderOptions);
 const setColliderOptions = (collider, options, states) => {
   const state = states.get(collider.handle);
-
   if (state) {
     var _state$worldParent;
-
     // Update collider position based on the object's position
     const parentWorldScale = state.object.parent.getWorldScale(_vector3);
     const parentInvertedWorldMatrix = (_state$worldParent = state.worldParent) === null || _state$worldParent === void 0 ? void 0 : _state$worldParent.matrixWorld.clone().invert();
     state.object.updateWorldMatrix(true, false);
-
     _matrix4.copy(state.object.matrixWorld);
-
     if (parentInvertedWorldMatrix) {
       _matrix4.premultiply(parentInvertedWorldMatrix);
     }
-
     _matrix4.decompose(_position, _rotation, _scale);
-
     if (collider.parent()) {
       collider.setTranslationWrtParent({
         x: _position.x * parentWorldScale.x,
@@ -368,16 +339,17 @@ const setColliderOptions = (collider, options, states) => {
       });
       collider.setRotation(_rotation);
     }
-
     mutableColliderOptionKeys.forEach(key => {
       if (key in options) {
         const option = options[key];
-        mutableColliderOptions[key](collider, // @ts-ignore Option does not want to fit into the function, but it will
+        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.
+    });
 
+    // handle mass separately, because the assignments
+    // are exclusive.
     setColliderMassOptions(collider, options);
   }
 };
@@ -391,7 +363,6 @@ const useUpdateColliderOptions = (getCollider, props, states) => {
     setColliderOptions(collider, props, states);
   }, [...mutablePropsAsFlatArray, getCollider]);
 };
-
 const isChildOfMeshCollider = child => {
   let flag = false;
   child.traverseAncestors(a => {
@@ -399,7 +370,6 @@ const isChildOfMeshCollider = child => {
   });
   return flag;
 };
-
 const createColliderState = (collider, object, rigidBodyObject) => {
   return {
     collider,
@@ -421,16 +391,13 @@ const createColliderPropsFromChildren = ({
   const childColliderProps = [];
   object.updateWorldMatrix(true, false);
   const invertedParentMatrixWorld = object.matrixWorld.clone().invert();
-
   const colliderFromChild = child => {
     if ("isMesh" in child) {
       if (_ignoreMeshColliders && isChildOfMeshCollider(child)) return;
       const worldScale = child.getWorldScale(_scale);
       const shape = autoColliderMap[options.colliders || "cuboid"];
       child.updateWorldMatrix(true, false);
-
       _matrix4.copy(child.matrixWorld).premultiply(invertedParentMatrixWorld).decompose(_position, _rotation, _scale);
-
       const rotationEuler = new three.Euler().setFromQuaternion(_rotation, "XYZ");
       const {
         geometry
@@ -439,7 +406,6 @@ const createColliderPropsFromChildren = ({
         args,
         offset
       } = getColliderArgsFromGeometry(geometry, options.colliders || "cuboid");
-
       const colliderProps = _objectSpread2(_objectSpread2({}, cleanRigidBodyPropsForCollider(options)), {}, {
         args: args,
         shape: shape,
@@ -447,17 +413,14 @@ const createColliderPropsFromChildren = ({
         position: [_position.x + offset.x * worldScale.x, _position.y + offset.y * worldScale.y, _position.z + offset.z * worldScale.z],
         scale: [worldScale.x, worldScale.y, worldScale.z]
       });
-
       childColliderProps.push(colliderProps);
     }
   };
-
   if (options.includeInvisible) {
     object.traverse(colliderFromChild);
   } else {
     object.traverseVisible(colliderFromChild);
   }
-
   return childColliderProps;
 };
 const getColliderArgsFromGeometry = (geometry, colliders) => {
@@ -474,7 +437,6 @@ const getColliderArgsFromGeometry = (geometry, colliders) => {
           offset: boundingBox.getCenter(new three.Vector3())
         };
       }
-
     case "ball":
       {
         geometry.computeBoundingSphere();
@@ -487,18 +449,15 @@ const getColliderArgsFromGeometry = (geometry, colliders) => {
           offset: boundingSphere.center
         };
       }
-
     case "trimesh":
       {
         var _clonedGeometry$index;
-
         const clonedGeometry = geometry.index ? geometry.clone() : threeStdlib.mergeVertices(geometry);
         return {
           args: [clonedGeometry.attributes.position.array, (_clonedGeometry$index = clonedGeometry.index) === null || _clonedGeometry$index === void 0 ? void 0 : _clonedGeometry$index.array],
           offset: new three.Vector3()
         };
       }
-
     case "hull":
       {
         const g = geometry.clone();
@@ -508,7 +467,6 @@ const getColliderArgsFromGeometry = (geometry, colliders) => {
         };
       }
   }
-
   return {
     args: [],
     offset: new three.Vector3()
@@ -534,7 +492,6 @@ activeEvents = {}) => {
   } = props;
   React.useEffect(() => {
     const collider = getCollider();
-
     if (collider) {
       const {
         collision: collisionEventsActive,
@@ -542,7 +499,6 @@ activeEvents = {}) => {
       } = getActiveCollisionEventsFromProps(props);
       const hasCollisionEvent = collisionEventsActive || activeEvents.collision;
       const hasContactForceEvent = contactForceEventsActive || activeEvents.contactForce;
-
       if (hasCollisionEvent && hasContactForceEvent) {
         collider.setActiveEvents(rapier3dCompat.ActiveEvents.COLLISION_EVENTS | rapier3dCompat.ActiveEvents.CONTACT_FORCE_EVENTS);
       } else if (hasCollisionEvent) {
@@ -550,7 +506,6 @@ activeEvents = {}) => {
       } else if (hasContactForceEvent) {
         collider.setActiveEvents(rapier3dCompat.ActiveEvents.CONTACT_FORCE_EVENTS);
       }
-
       events.set(collider.handle, {
         onCollisionEnter,
         onCollisionExit,
@@ -559,7 +514,6 @@ activeEvents = {}) => {
         onContactForce
       });
     }
-
     return () => {
       if (collider) {
         events.delete(collider.handle);
@@ -569,34 +523,33 @@ activeEvents = {}) => {
 };
 const cleanRigidBodyPropsForCollider = (props = {}) => {
   const rest = _objectWithoutProperties(props, _excluded$2);
-
   return rest;
 };
 
+// Utils
 const useMutableCallback = fn => {
   const ref = React.useRef(fn);
   React.useEffect(() => {
     ref.current = fn;
   }, [fn]);
   return ref;
-}; // External hooks
+};
 
+// External hooks
 /**
  * Exposes the Rapier context, and world
  * @category Hooks
  */
-
-
 const useRapier = () => {
   const rapier = React.useContext(rapierContext);
   if (!rapier) throw new Error("react-three-rapier: useRapier must be used within <Physics />!");
   return rapier;
 };
+
 /**
  * Registers a callback to be called before the physics step
  * @category Hooks
  */
-
 const useBeforePhysicsStep = callback => {
   const {
     beforeStepCallbacks
@@ -609,11 +562,11 @@ const useBeforePhysicsStep = callback => {
     };
   }, []);
 };
+
 /**
  * Registers a callback to be called after the physics step
  * @category Hooks
  */
-
 const useAfterPhysicsStep = callback => {
   const {
     afterStepCallbacks
@@ -625,17 +578,16 @@ const useAfterPhysicsStep = callback => {
       afterStepCallbacks.delete(ref);
     };
   }, []);
-}; // Internal hooks
+};
 
+// Internal hooks
 /**
  * @internal
  */
-
 const useChildColliderProps = (ref, options, ignoreMeshColliders = true) => {
   const [colliderProps, setColliderProps] = React.useState([]);
   React.useEffect(() => {
     const object = ref.current;
-
     if (object && options.colliders !== false) {
       setColliderProps(createColliderPropsFromChildren({
         object: ref.current,
@@ -681,33 +633,26 @@ const createSingletonProxy = createInstance => {
       if (!instance) {
         instance = createInstance();
       }
-
       return Reflect.get(instance, prop);
     },
-
     set(target, prop, value) {
       if (!instance) {
         instance = createInstance();
       }
-
       return Reflect.set(instance, prop, value);
     }
-
   };
   const proxy = new Proxy({}, handler);
-
   const reset = () => {
     instance = undefined;
   };
-
   const set = newInstance => {
     instance = newInstance;
   };
+
   /**
    * Return the proxy and a reset function
    */
-
-
   return {
     proxy,
     reset,
@@ -716,10 +661,8 @@ const createSingletonProxy = createInstance => {
 };
 
 const rapierContext = /*#__PURE__*/React.createContext(undefined);
-
 const getCollisionPayloadFromSource = (target, other) => {
   var _target$collider$stat, _target$rigidBody$sta, _other$collider$state, _other$rigidBody$stat, _other$collider$state2, _other$rigidBody$stat2;
-
   return {
     target: {
       rigidBody: target.rigidBody.object,
@@ -739,13 +682,11 @@ const getCollisionPayloadFromSource = (target, other) => {
     rigidBodyObject: (_other$rigidBody$stat2 = other.rigidBody.state) === null || _other$rigidBody$stat2 === void 0 ? void 0 : _other$rigidBody$stat2.object
   };
 };
-
 const importRapier = async () => {
   let r = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('@dimforge/rapier3d-compat')); });
   await r.init();
   return r;
 };
-
 /**
  * The main physics component used to create a physics world.
  * @category Components
@@ -768,7 +709,7 @@ const Physics = props => {
     numInternalPgsIterations = 1,
     minIslandSize = 128,
     maxCcdSubsteps = 1,
-    erp = 0.8,
+    contactNaturalFrequency = 30,
     lengthUnit = 1
   } = props;
   const rapier = suspendReact.suspend(importRapier, ["@react-thee/rapier", importRapier]);
@@ -782,12 +723,12 @@ const Physics = props => {
   const eventQueue = useConst(() => new rapier3dCompat.EventQueue(false));
   const beforeStepCallbacks = useConst(() => new Set());
   const afterStepCallbacks = useConst(() => new Set());
+
   /**
    * Initiate the world
    * This creates a singleton proxy, so that the world is only created when
    * something within it is accessed.
    */
-
   const {
     proxy: worldProxy,
     reset: resetWorldProxy,
@@ -798,8 +739,9 @@ const Physics = props => {
       worldProxy.free();
       resetWorldProxy();
     };
-  }, []); // Update mutable props
+  }, []);
 
+  // Update mutable props
   React.useEffect(() => {
     worldProxy.gravity = vector3ToRapierVector(gravity);
     worldProxy.integrationParameters.numSolverIterations = numSolverIterations;
@@ -809,12 +751,11 @@ const Physics = props => {
     worldProxy.integrationParameters.minIslandSize = minIslandSize;
     worldProxy.integrationParameters.maxCcdSubsteps = maxCcdSubsteps;
     worldProxy.integrationParameters.normalizedPredictionDistance = predictionDistance;
-    worldProxy.integrationParameters.erp = erp;
     worldProxy.lengthUnit = lengthUnit;
-  }, [worldProxy, ...gravity, numSolverIterations, numAdditionalFrictionIterations, numInternalPgsIterations, allowedLinearError, minIslandSize, maxCcdSubsteps, predictionDistance, erp, lengthUnit]);
+    worldProxy.integrationParameters.contact_natural_frequency = contactNaturalFrequency;
+  }, [worldProxy, ...gravity, numSolverIterations, numAdditionalFrictionIterations, numInternalPgsIterations, allowedLinearError, minIslandSize, maxCcdSubsteps, predictionDistance, lengthUnit, contactNaturalFrequency]);
   const getSourceFromColliderHandle = React.useCallback(handle => {
     var _collider$parent;
-
     const collider = worldProxy.getCollider(handle);
     const colEvents = colliderEvents.get(handle);
     const colliderState = colliderStates.get(handle);
@@ -842,37 +783,36 @@ const Physics = props => {
   });
   const step = React.useCallback(dt => {
     const world = worldProxy;
+
     /* Check if the timestep is supposed to be variable. We'll do this here
       once so we don't have to string-check every frame. */
-
     const timeStepVariable = timeStep === "vary";
+
     /**
      * Fixed timeStep simulation progression
      * @see https://gafferongames.com/post/fix_your_timestep/
      */
 
     const clampedDelta = three.MathUtils.clamp(dt, 0, 0.5);
-
     const stepWorld = delta => {
       // Trigger beforeStep callbacks
       beforeStepCallbacks.forEach(callback => {
         callback.current(world);
       });
       world.timestep = delta;
-      world.step(eventQueue); // Trigger afterStep callbacks
+      world.step(eventQueue);
 
+      // Trigger afterStep callbacks
       afterStepCallbacks.forEach(callback => {
         callback.current(world);
       });
     };
-
     if (timeStepVariable) {
       stepWorld(clampedDelta);
     } else {
       // don't step time forwards if paused
       // Increase accumulator
       steppingState.accumulator += clampedDelta;
-
       while (steppingState.accumulator >= timeStep) {
         // Set up previous state
         // needed for accurate interpolations if the world steps more than once
@@ -885,57 +825,48 @@ const Physics = props => {
             };
           });
         }
-
         stepWorld(timeStep);
         steppingState.accumulator -= timeStep;
       }
     }
+    const interpolationAlpha = timeStepVariable || !interpolate || paused ? 1 : steppingState.accumulator / timeStep;
 
-    const interpolationAlpha = timeStepVariable || !interpolate || paused ? 1 : steppingState.accumulator / timeStep; // Update meshes
-
+    // Update meshes
     rigidBodyStates.forEach((state, handle) => {
       const rigidBody = world.getRigidBody(handle);
       const events = rigidBodyEvents.get(handle);
-
       if (events !== null && events !== void 0 && events.onSleep || events !== null && events !== void 0 && events.onWake) {
         if (rigidBody.isSleeping() && !state.isSleeping) {
           var _events$onSleep;
-
           events === null || events === void 0 ? void 0 : (_events$onSleep = events.onSleep) === null || _events$onSleep === void 0 ? void 0 : _events$onSleep.call(events);
         }
-
         if (!rigidBody.isSleeping() && state.isSleeping) {
           var _events$onWake;
-
           events === null || events === void 0 ? void 0 : (_events$onWake = events.onWake) === null || _events$onWake === void 0 ? void 0 : _events$onWake.call(events);
         }
-
         state.isSleeping = rigidBody.isSleeping();
       }
-
       if (!rigidBody || rigidBody.isSleeping() && !("isInstancedMesh" in state.object) || !state.setMatrix) {
         return;
-      } // New states
-
+      }
 
+      // New states
       let t = rigidBody.translation();
       let r = rigidBody.rotation();
       let previousState = steppingState.previousState[handle];
-
       if (previousState) {
         // Get previous simulated world position
-        _matrix4.compose(previousState.position, rapierQuaternionToQuaternion(previousState.rotation), state.scale).premultiply(state.invertedWorldMatrix).decompose(_position, _rotation, _scale); // Apply previous tick position
-
+        _matrix4.compose(previousState.position, rapierQuaternionToQuaternion(previousState.rotation), state.scale).premultiply(state.invertedWorldMatrix).decompose(_position, _rotation, _scale);
 
+        // Apply previous tick position
         if (state.meshType == "mesh") {
           state.object.position.copy(_position);
           state.object.quaternion.copy(_rotation);
         }
-      } // Get new position
-
+      }
 
+      // Get new position
       _matrix4.compose(t, rapierQuaternionToQuaternion(r), state.scale).premultiply(state.invertedWorldMatrix).decompose(_position, _rotation, _scale);
-
       if (state.meshType == "instancedMesh") {
         state.setMatrix(_matrix4);
       } else {
@@ -946,19 +877,17 @@ const Physics = props => {
     });
     eventQueue.drainCollisionEvents((handle1, handle2, started) => {
       const source1 = getSourceFromColliderHandle(handle1);
-      const source2 = getSourceFromColliderHandle(handle2); // Collision Events
+      const source2 = getSourceFromColliderHandle(handle2);
 
+      // Collision Events
       if (!(source1 !== null && source1 !== void 0 && source1.collider.object) || !(source2 !== null && source2 !== void 0 && source2.collider.object)) {
         return;
       }
-
       const collisionPayload1 = getCollisionPayloadFromSource(source1, source2);
       const collisionPayload2 = getCollisionPayloadFromSource(source2, source1);
-
       if (started) {
         world.contactPair(source1.collider.object, source2.collider.object, (manifold, flipped) => {
           var _source1$rigidBody$ev, _source1$rigidBody$ev2, _source2$rigidBody$ev, _source2$rigidBody$ev2, _source1$collider$eve, _source1$collider$eve2, _source2$collider$eve, _source2$collider$eve2;
-
           /* RigidBody events */
           (_source1$rigidBody$ev = source1.rigidBody.events) === null || _source1$rigidBody$ev === void 0 ? void 0 : (_source1$rigidBody$ev2 = _source1$rigidBody$ev.onCollisionEnter) === null || _source1$rigidBody$ev2 === void 0 ? void 0 : _source1$rigidBody$ev2.call(_source1$rigidBody$ev, _objectSpread2(_objectSpread2({}, collisionPayload1), {}, {
             manifold,
@@ -968,8 +897,8 @@ const Physics = props => {
             manifold,
             flipped
           }));
-          /* Collider events */
 
+          /* Collider events */
           (_source1$collider$eve = source1.collider.events) === null || _source1$collider$eve === void 0 ? void 0 : (_source1$collider$eve2 = _source1$collider$eve.onCollisionEnter) === null || _source1$collider$eve2 === void 0 ? void 0 : _source1$collider$eve2.call(_source1$collider$eve, _objectSpread2(_objectSpread2({}, collisionPayload1), {}, {
             manifold,
             flipped
@@ -981,18 +910,16 @@ const Physics = props => {
         });
       } else {
         var _source1$rigidBody$ev3, _source1$rigidBody$ev4, _source2$rigidBody$ev3, _source2$rigidBody$ev4, _source1$collider$eve3, _source1$collider$eve4, _source2$collider$eve3, _source2$collider$eve4;
-
         (_source1$rigidBody$ev3 = source1.rigidBody.events) === null || _source1$rigidBody$ev3 === void 0 ? void 0 : (_source1$rigidBody$ev4 = _source1$rigidBody$ev3.onCollisionExit) === null || _source1$rigidBody$ev4 === void 0 ? void 0 : _source1$rigidBody$ev4.call(_source1$rigidBody$ev3, collisionPayload1);
         (_source2$rigidBody$ev3 = source2.rigidBody.events) === null || _source2$rigidBody$ev3 === void 0 ? void 0 : (_source2$rigidBody$ev4 = _source2$rigidBody$ev3.onCollisionExit) === null || _source2$rigidBody$ev4 === void 0 ? void 0 : _source2$rigidBody$ev4.call(_source2$rigidBody$ev3, collisionPayload2);
         (_source1$collider$eve3 = source1.collider.events) === null || _source1$collider$eve3 === void 0 ? void 0 : (_source1$collider$eve4 = _source1$collider$eve3.onCollisionExit) === null || _source1$collider$eve4 === void 0 ? void 0 : _source1$collider$eve4.call(_source1$collider$eve3, collisionPayload1);
         (_source2$collider$eve3 = source2.collider.events) === null || _source2$collider$eve3 === void 0 ? void 0 : (_source2$collider$eve4 = _source2$collider$eve3.onCollisionExit) === null || _source2$collider$eve4 === void 0 ? void 0 : _source2$collider$eve4.call(_source2$collider$eve3, collisionPayload2);
-      } // Sensor Intersections
-
+      }
 
+      // Sensor Intersections
       if (started) {
         if (world.intersectionPair(source1.collider.object, source2.collider.object)) {
           var _source1$rigidBody$ev5, _source1$rigidBody$ev6, _source2$rigidBody$ev5, _source2$rigidBody$ev6, _source1$collider$eve5, _source1$collider$eve6, _source2$collider$eve5, _source2$collider$eve6;
-
           (_source1$rigidBody$ev5 = source1.rigidBody.events) === null || _source1$rigidBody$ev5 === void 0 ? void 0 : (_source1$rigidBody$ev6 = _source1$rigidBody$ev5.onIntersectionEnter) === null || _source1$rigidBody$ev6 === void 0 ? void 0 : _source1$rigidBody$ev6.call(_source1$rigidBody$ev5, collisionPayload1);
           (_source2$rigidBody$ev5 = source2.rigidBody.events) === null || _source2$rigidBody$ev5 === void 0 ? void 0 : (_source2$rigidBody$ev6 = _source2$rigidBody$ev5.onIntersectionEnter) === null || _source2$rigidBody$ev6 === void 0 ? void 0 : _source2$rigidBody$ev6.call(_source2$rigidBody$ev5, collisionPayload2);
           (_source1$collider$eve5 = source1.collider.events) === null || _source1$collider$eve5 === void 0 ? void 0 : (_source1$collider$eve6 = _source1$collider$eve5.onIntersectionEnter) === null || _source1$collider$eve6 === void 0 ? void 0 : _source1$collider$eve6.call(_source1$collider$eve5, collisionPayload1);
@@ -1000,7 +927,6 @@ const Physics = props => {
         }
       } else {
         var _source1$rigidBody$ev7, _source1$rigidBody$ev8, _source2$rigidBody$ev7, _source2$rigidBody$ev8, _source1$collider$eve7, _source1$collider$eve8, _source2$collider$eve7, _source2$collider$eve8;
-
         (_source1$rigidBody$ev7 = source1.rigidBody.events) === null || _source1$rigidBody$ev7 === void 0 ? void 0 : (_source1$rigidBody$ev8 = _source1$rigidBody$ev7.onIntersectionExit) === null || _source1$rigidBody$ev8 === void 0 ? void 0 : _source1$rigidBody$ev8.call(_source1$rigidBody$ev7, collisionPayload1);
         (_source2$rigidBody$ev7 = source2.rigidBody.events) === null || _source2$rigidBody$ev7 === void 0 ? void 0 : (_source2$rigidBody$ev8 = _source2$rigidBody$ev7.onIntersectionExit) === null || _source2$rigidBody$ev8 === void 0 ? void 0 : _source2$rigidBody$ev8.call(_source2$rigidBody$ev7, collisionPayload2);
         (_source1$collider$eve7 = source1.collider.events) === null || _source1$collider$eve7 === void 0 ? void 0 : (_source1$collider$eve8 = _source1$collider$eve7.onIntersectionExit) === null || _source1$collider$eve8 === void 0 ? void 0 : _source1$collider$eve8.call(_source1$collider$eve7, collisionPayload1);
@@ -1009,14 +935,13 @@ const Physics = props => {
     });
     eventQueue.drainContactForceEvents(event => {
       var _source1$rigidBody$ev9, _source1$rigidBody$ev10, _source2$rigidBody$ev9, _source2$rigidBody$ev10, _source1$collider$eve9, _source1$collider$eve10, _source2$collider$eve9, _source2$collider$eve10;
-
       const source1 = getSourceFromColliderHandle(event.collider1());
-      const source2 = getSourceFromColliderHandle(event.collider2()); // Collision Events
+      const source2 = getSourceFromColliderHandle(event.collider2());
 
+      // Collision Events
       if (!(source1 !== null && source1 !== void 0 && source1.collider.object) || !(source2 !== null && source2 !== void 0 && source2.collider.object)) {
         return;
       }
-
       const collisionPayload1 = getCollisionPayloadFromSource(source1, source2);
       const collisionPayload2 = getCollisionPayloadFromSource(source2, source1);
       (_source1$rigidBody$ev9 = source1.rigidBody.events) === null || _source1$rigidBody$ev9 === void 0 ? void 0 : (_source1$rigidBody$ev10 = _source1$rigidBody$ev9.onContactForce) === null || _source1$rigidBody$ev10 === void 0 ? void 0 : _source1$rigidBody$ev10.call(_source1$rigidBody$ev9, _objectSpread2(_objectSpread2({}, collisionPayload1), {}, {
@@ -1083,41 +1008,44 @@ const Physics = props => {
 };
 
 function _extends() {
-  _extends = Object.assign ? Object.assign.bind() : function (target) {
-    for (var i = 1; i < arguments.length; i++) {
-      var source = arguments[i];
-
-      for (var key in source) {
-        if (Object.prototype.hasOwnProperty.call(source, key)) {
-          target[key] = source[key];
-        }
-      }
+  return _extends = Object.assign ? Object.assign.bind() : function (n) {
+    for (var e = 1; e < arguments.length; e++) {
+      var t = arguments[e];
+      for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);
     }
-
-    return target;
-  };
-  return _extends.apply(this, arguments);
+    return n;
+  }, _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();
     }
-
     return ref.current;
   }, dependencyList);
   React.useEffect(() => {
     // Save the destroy function and instance
     const instance = getInstance();
-
     const destroy = () => destroyFn(instance);
-
     return () => {
       destroy();
       ref.current = undefined;
@@ -1126,102 +1054,238 @@ const useImperativeInstance = (createFn, destroyFn, dependencyList) => {
   return getInstance;
 };
 
-/**
- * Takes an object resembling a Vector3 and returs a Three.Vector3
- * @category Math helpers
- */
-
-const vec3 = ({
-  x,
-  y,
-  z
-} = {
-  x: 0,
-  y: 0,
-  z: 0
-}) => {
-  return new three.Vector3(x, y, z);
-};
-/**
- * Takes an object resembling a Quaternion and returs a Three.Quaternion
- * @category Math helpers
- */
+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);
 
-const quat = ({
-  x,
-  y,
-  z,
-  w
-} = {
-  x: 0,
-  y: 0,
-  z: 0,
-  w: 1
-}) => {
-  return new three.Quaternion(x, y, z, w);
+  // 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;
 };
-/**
- * Takes an object resembling an Euler and returs a Three.Euler
- * @category Math helpers
- */
-
-const euler = ({
-  x,
-  y,
-  z
-} = {
-  x: 0,
-  y: 0,
-  z: 0
+const createRigidBodyState = ({
+  rigidBody,
+  object,
+  setMatrix,
+  getMatrix,
+  worldScale,
+  meshType: _meshType = "mesh"
 }) => {
-  return new three.Euler(x, y, z);
-};
-
-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;
+  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
+  };
 };
-
-/**
- * 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 {
-    children,
-    position,
-    rotation,
-    quaternion,
-    scale,
-    name
-  } = props;
-  const {
-    world,
-    colliderEvents,
-    colliderStates
-  } = useRapier();
-  const rigidBodyContext = useRigidBodyContext();
-  const colliderRef = useForwardedRef(forwardedRef);
-  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 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);
-    }
-
+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
+ */
+const vec3 = ({
+  x,
+  y,
+  z
+} = {
+  x: 0,
+  y: 0,
+  z: 0
+}) => {
+  return new three.Vector3(x, y, z);
+};
+
+/**
+ * Takes an object resembling a Quaternion and returs a Three.Quaternion
+ * @category Math helpers
+ */
+const quat = ({
+  x,
+  y,
+  z,
+  w
+} = {
+  x: 0,
+  y: 0,
+  z: 0,
+  w: 1
+}) => {
+  return new three.Quaternion(x, y, z, w);
+};
+
+/**
+ * Takes an object resembling an Euler and returs a Three.Euler
+ * @category Math helpers
+ */
+const euler = ({
+  x,
+  y,
+  z
+} = {
+  x: 0,
+  y: 0,
+  z: 0
+}) => {
+  return new three.Euler(x, y, z);
+};
+
+/**
+ * A collider is a shape that can be attached to a rigid body to define its physical properties.
+ * @internal
+ */
+const AnyCollider = /*#__PURE__*/React.memo(props => {
+  const {
+    children,
+    position,
+    rotation,
+    quaternion,
+    scale,
+    name
+  } = props;
+  const {
+    world,
+    colliderEvents,
+    colliderStates
+  } = useRapier();
+  const rigidBodyContext = useRigidBodyContext();
+  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]
+  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 props.ref == "function") {
+      props.ref(collider);
+    }
     colliderRef.current = collider;
     return collider;
   }, collider => {
@@ -1249,8 +1313,7 @@ const AnyCollider = /*#__PURE__*/React.memo( /*#__PURE__*/React.forwardRef((prop
     ref: objectRef,
     name: name
   }, children);
-}));
-
+});
 /**
  * A cuboid collider shape
  * @category Colliders
@@ -1262,7 +1325,6 @@ const CuboidCollider = /*#__PURE__*/React__default["default"].forwardRef((props,
   }));
 });
 CuboidCollider.displayName = "CuboidCollider";
-
 /**
  * A round cuboid collider shape
  * @category Colliders
@@ -1272,7 +1334,6 @@ const RoundCuboidCollider = /*#__PURE__*/React__default["default"].forwardRef((p
   ref: ref
 })));
 RoundCuboidCollider.displayName = "RoundCuboidCollider";
-
 /**
  * A ball collider shape
  * @category Colliders
@@ -1282,7 +1343,6 @@ const BallCollider = /*#__PURE__*/React__default["default"].forwardRef((props, r
   ref: ref
 })));
 BallCollider.displayName = "BallCollider";
-
 /**
  * A capsule collider shape
  * @category Colliders
@@ -1292,7 +1352,6 @@ const CapsuleCollider = /*#__PURE__*/React__default["default"].forwardRef((props
   ref: ref
 })));
 CapsuleCollider.displayName = "CapsuleCollider";
-
 /**
  * A heightfield collider shape
  * @category Colliders
@@ -1302,7 +1361,6 @@ const HeightfieldCollider = /*#__PURE__*/React__default["default"].forwardRef((p
   ref: ref
 })));
 HeightfieldCollider.displayName = "HeightfieldCollider";
-
 /**
  * A trimesh collider shape
  * @category Colliders
@@ -1312,7 +1370,6 @@ const TrimeshCollider = /*#__PURE__*/React__default["default"].forwardRef((props
   ref: ref
 })));
 TrimeshCollider.displayName = "TrimeshCollider";
-
 /**
  * A cone collider shape
  * @category Colliders
@@ -1322,7 +1379,6 @@ const ConeCollider = /*#__PURE__*/React__default["default"].forwardRef((props, r
   ref: ref
 })));
 ConeCollider.displayName = "ConeCollider";
-
 /**
  * A round cylinder collider shape
  * @category Colliders
@@ -1332,7 +1388,6 @@ const RoundConeCollider = /*#__PURE__*/React__default["default"].forwardRef((pro
   ref: ref
 })));
 RoundConeCollider.displayName = "RoundConeCollider";
-
 /**
  * A cylinder collider shape
  * @category Colliders
@@ -1342,7 +1397,6 @@ const CylinderCollider = /*#__PURE__*/React__default["default"].forwardRef((prop
   ref: ref
 })));
 CylinderCollider.displayName = "CylinderCollider";
-
 /**
  * A round cylinder collider shape
  * @category Colliders
@@ -1352,7 +1406,6 @@ const RoundCylinderCollider = /*#__PURE__*/React__default["default"].forwardRef(
   ref: ref
 })));
 CylinderCollider.displayName = "RoundCylinderCollider";
-
 /**
  * A convex hull collider shape
  * @category Colliders
@@ -1363,187 +1416,27 @@ 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 {
-    children,
-    type,
-    position,
-    rotation,
-    scale,
-    quaternion,
-    transformState
-  } = props,
-        objectProps = _objectWithoutProperties(props, _excluded$1);
-
+      ref,
+      children,
+      type,
+      position,
+      rotation,
+      scale,
+      quaternion,
+      transformState
+    } = props,
+    objectProps = _objectWithoutProperties(props, _excluded$1);
   const objectRef = React.useRef(null);
-  const rigidBodyRef = useForwardedRef(forwardedRef);
+  const rigidBodyRef = useForwardedRef(ref);
   const {
     world,
     rigidBodyStates,
@@ -1558,24 +1451,24 @@ const RigidBody = /*#__PURE__*/React.memo( /*#__PURE__*/React.forwardRef((props,
   const immutablePropArray = immutableRigidBodyOptions.flatMap(key => {
     return Array.isArray(mergedOptions[key]) ? [...mergedOptions[key]] : mergedOptions[key];
   });
-  const childColliderProps = useChildColliderProps(objectRef, mergedOptions); // Provide a way to eagerly create rigidbody
+  const childColliderProps = useChildColliderProps(objectRef, mergedOptions);
 
+  // Provide a way to eagerly create rigidbody
   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;
   }, rigidBody => {
     if (world.getRigidBody(rigidBody.handle)) {
       world.removeRigidBody(rigidBody);
     }
-  }, immutablePropArray); // Only provide a object state after the ref has been set
+  }, immutablePropArray);
 
+  // Only provide a object state after the ref has been set
   React.useEffect(() => {
     const rigidBody = getRigidBody();
     const state = createRigidBodyState({
@@ -1608,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";
 
 /**
@@ -1645,52 +1538,52 @@ 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 {
-    // instanced props
-    children,
-    instances,
-    colliderNodes = [],
-    // wrapper object props
-    position,
-    rotation,
-    quaternion,
-    scale
-  } = props,
-        rigidBodyProps = _objectWithoutProperties(props, _excluded);
-
+      // instanced props
+      children,
+      instances,
+      colliderNodes = [],
+      // wrapper object props
+      position,
+      rotation,
+      quaternion,
+      scale
+
+      // rigid body specific props, and r3f-object props
+    } = props,
+    rigidBodyProps = _objectWithoutProperties(props, _excluded2);
   const childColliderProps = useChildColliderProps(objectRef, _objectSpread2(_objectSpread2({}, props), {}, {
     children: undefined
   }));
-
   const getInstancedMesh = () => {
     const firstChild = instanceWrapperRef.current.children[0];
-
     if (firstChild && "isInstancedMesh" in firstChild) {
       return firstChild;
     }
-
     return undefined;
   };
-
   React.useEffect(() => {
     const instancedMesh = getInstancedMesh();
-
     if (instancedMesh) {
       instancedMesh.instanceMatrix.setUsage(three.DynamicDrawUsage);
     } else {
       console.warn("InstancedRigidBodies expects exactly one child, which must be an InstancedMesh");
     }
-  }, []); // Update the RigidBodyStates whenever the instances change
+  }, []);
 
+  // Update the RigidBodyStates whenever the instances change
   const applyInstancedState = (state, index) => {
     const instancedMesh = getInstancedMesh();
-
     if (instancedMesh) {
       return _objectSpread2(_objectSpread2({}, state), {}, {
         getMatrix: matrix => {
@@ -1704,10 +1597,8 @@ const InstancedRigidBodies = /*#__PURE__*/React.memo( /*#__PURE__*/React.forward
         meshType: "instancedMesh"
       });
     }
-
     return state;
   };
-
   return /*#__PURE__*/React__default["default"].createElement("object3D", _extends({
     ref: objectRef
   }, rigidBodyProps, {
@@ -1718,25 +1609,26 @@ const InstancedRigidBodies = /*#__PURE__*/React.memo( /*#__PURE__*/React.forward
   }), /*#__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";
 
 /**
  * @internal
  */
-
 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);
@@ -1746,7 +1638,6 @@ const useImpulseJoint = (body1, body2, params) => {
   }, joint => {
     if (joint) {
       jointRef.current = undefined;
-
       if (world.getImpulseJoint(joint.handle)) {
         world.removeImpulseJoint(joint, true);
       }
@@ -1754,6 +1645,7 @@ const useImpulseJoint = (body1, body2, params) => {
   }, []);
   return jointRef;
 };
+
 /**
  * A fixed joint ensures that two rigid-bodies don't move relative to each other.
  * Fixed joints are characterized by one local frame (represented by an isometry) on each rigid-body.
@@ -1761,13 +1653,13 @@ const useImpulseJoint = (body1, body2, params) => {
  *
  * @category Hooks - Joints
  */
-
 const useFixedJoint = (body1, body2, [body1Anchor, body1LocalFrame, body2Anchor, body2LocalFrame]) => {
   const {
     rapier
   } = useRapier();
   return useImpulseJoint(body1, body2, rapier.JointData.fixed(vector3ToRapierVector(body1Anchor), quaternionToRapierQuaternion(body1LocalFrame), vector3ToRapierVector(body2Anchor), quaternionToRapierQuaternion(body2LocalFrame)));
 };
+
 /**
  * The spherical joint ensures that two points on the local-spaces of two rigid-bodies always coincide (it prevents any relative
  * translational motion at this points). This is typically used to simulate ragdolls arms, pendulums, etc.
@@ -1776,13 +1668,13 @@ const useFixedJoint = (body1, body2, [body1Anchor, body1LocalFrame, body2Anchor,
  *
  * @category Hooks - Joints
  */
-
 const useSphericalJoint = (body1, body2, [body1Anchor, body2Anchor]) => {
   const {
     rapier
   } = useRapier();
   return useImpulseJoint(body1, body2, rapier.JointData.spherical(vector3ToRapierVector(body1Anchor), vector3ToRapierVector(body2Anchor)));
 };
+
 /**
  * The revolute joint prevents any relative movement between two rigid-bodies, except for relative
  * rotations along one axis. This is typically used to simulate wheels, fans, etc.
@@ -1790,20 +1682,18 @@ const useSphericalJoint = (body1, body2, [body1Anchor, body2Anchor]) => {
  *
  * @category Hooks - Joints
  */
-
 const useRevoluteJoint = (body1, body2, [body1Anchor, body2Anchor, axis, limits]) => {
   const {
     rapier
   } = useRapier();
   const params = rapier.JointData.revolute(vector3ToRapierVector(body1Anchor), vector3ToRapierVector(body2Anchor), vector3ToRapierVector(axis));
-
   if (limits) {
     params.limitsEnabled = true;
     params.limits = limits;
   }
-
   return useImpulseJoint(body1, body2, params);
 };
+
 /**
  * The prismatic joint prevents any relative movement between two rigid-bodies, except for relative translations along one axis.
  * It is characterized by one local anchor as well as one local axis on each rigid-body. In 3D, an optional
@@ -1811,25 +1701,22 @@ const useRevoluteJoint = (body1, body2, [body1Anchor, body2Anchor, axis, limits]
  *
  * @category Hooks - Joints
  */
-
 const usePrismaticJoint = (body1, body2, [body1Anchor, body2Anchor, axis, limits]) => {
   const {
     rapier
   } = useRapier();
   const params = rapier.JointData.prismatic(vector3ToRapierVector(body1Anchor), vector3ToRapierVector(body2Anchor), vector3ToRapierVector(axis));
-
   if (limits) {
     params.limitsEnabled = true;
     params.limits = limits;
   }
-
   return useImpulseJoint(body1, body2, params);
 };
+
 /**
  * The rope joint limits the max distance between two bodies.
  * @category Hooks - Joints
  */
-
 const useRopeJoint = (body1, body2, [body1Anchor, body2Anchor, length]) => {
   const {
     rapier
@@ -1839,11 +1726,11 @@ const useRopeJoint = (body1, body2, [body1Anchor, body2Anchor, length]) => {
   const params = rapier.JointData.rope(length, vBody1Anchor, vBody2Anchor);
   return useImpulseJoint(body1, body2, params);
 };
+
 /**
  * The spring joint applies a force proportional to the distance between two objects.
  * @category Hooks - Joints
  */
-
 const useSpringJoint = (body1, body2, [body1Anchor, body2Anchor, restLength, stiffness, damping]) => {
   const {
     rapier
@@ -1887,7 +1774,6 @@ const useSpringJoint = (body1, body2, [body1Anchor, body2Anchor, restLength, sti
  * @returns An InteractionGroup bitmask.
  */
 const interactionGroups = (memberships, filters) => (bitmask(memberships) << 16) + (filters !== undefined ? bitmask(filters) : 0b1111111111111111);
-
 const bitmask = groups => [groups].flat().reduce((acc, layer) => acc | 1 << layer, 0);
 
 Object.defineProperty(exports, 'CoefficientCombineRule', {