@react-three/rapier 0.8.2 → 0.10.0

package/dist/react-three-rapier.esm.js

@@ -1,10 +1,51 @@
-import { EventQueue, RigidBodyDesc, ColliderDesc, ActiveEvents } from '@dimforge/rapier3d-compat';
+import { ColliderDesc, ActiveEvents, RigidBodyDesc, EventQueue } from '@dimforge/rapier3d-compat';
 export { CoefficientCombineRule, Collider as RapierCollider, RigidBody as RapierRigidBody } from '@dimforge/rapier3d-compat';
-import React, { useRef, useState, useEffect, useMemo, createContext, useContext, memo, forwardRef, useImperativeHandle, useLayoutEffect } from 'react';
-import { useAsset } from 'use-asset';
-import { useFrame } from '@react-three/fiber';
+import { useFrame, useThree } from '@react-three/fiber';
+import React, { useMemo, useEffect, useContext, useState, useRef, memo, createContext, useCallback, forwardRef, useImperativeHandle, useLayoutEffect } from 'react';
 import { Quaternion, Euler, Vector3, Object3D, Matrix4, MathUtils, InstancedMesh, BufferAttribute, DynamicDrawUsage } from 'three';
-import { mergeVertices } from 'three-stdlib';
+import { useAsset } from 'use-asset';
+import { mergeVertices, VertexNormalsHelper } from 'three-stdlib';
+
+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;
+  }
+
+  return obj;
+}
+
+function ownKeys(object, enumerableOnly) {
+  var keys = Object.keys(object);
+
+  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);
+  }
+
+  return keys;
+}
+
+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));
+    });
+  }
+
+  return target;
+}
 
 const _quaternion = new Quaternion();
 new Euler();
@@ -213,375 +254,304 @@ const createJointApi = ref => {
   };
 };
 
-const RapierContext = /*#__PURE__*/createContext(undefined);
-
-const importRapier = async () => {
-  let r = await import('@dimforge/rapier3d-compat');
-  await r.init();
-  return r;
-};
-
-const Physics = ({
-  colliders: _colliders = "cuboid",
-  gravity: _gravity = [0, -9.81, 0],
-  children,
-  timeStep: _timeStep = 1 / 60,
-  paused: _paused = false,
-  updatePriority
-}) => {
-  const rapier = useAsset(importRapier);
-  const worldRef = useRef();
-  const getWorldRef = useRef(() => {
-    if (!worldRef.current) {
-      const world = new rapier.World(vectorArrayToVector3(_gravity));
-      worldRef.current = world;
-    }
-
-    return worldRef.current;
-  });
-  const [rigidBodyStates] = useState(() => new Map());
-  const [colliderStates] = useState(() => new Map());
-  const [rigidBodyEvents] = useState(() => new Map());
-  const [colliderEvents] = useState(() => new Map());
-  const [eventQueue] = useState(() => new EventQueue(false)); // Init world
-
-  useEffect(() => {
-    const world = getWorldRef.current();
-    return () => {
-      if (world) {
-        world.free();
-        worldRef.current = undefined;
-      }
-    };
-  }, []); // Update gravity
+const scaleColliderArgs = (shape, args, scale) => {
+  const newArgs = args.slice(); // Heightfield uses a vector
 
-  useEffect(() => {
-    const world = worldRef.current;
+  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
 
-    if (world) {
-      world.gravity = vectorArrayToVector3(_gravity);
-    }
-  }, [_gravity]);
-  const [steppingState] = useState({
-    accumulator: 0
-  });
-  /* 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";
-  useFrame((_, dt) => {
-    const world = worldRef.current;
-    if (!world) return;
-    /**
-     * Fixed timeStep simulation progression
-     * @see https://gafferongames.com/post/fix_your_timestep/
-     */
+  if (shape === "trimesh" || shape === "convexHull") {
+    newArgs[0] = scaleVertices(newArgs[0], scale);
+    return newArgs;
+  } // Prepfill with some extra
 
-    const clampedDelta = MathUtils.clamp(dt, 0, 0.2);
 
-    if (timeStepVariable) {
-      world.timestep = clampedDelta;
-      if (!_paused) world.step(eventQueue);
-    } else {
-      world.timestep = _timeStep; // don't step time forwards if paused
-      // Increase accumulator
+  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, rigidBody) => {
+  const scaledArgs = scaleColliderArgs(options.shape, options.args, scale); // @ts-ignore
 
-      steppingState.accumulator += _paused ? 0 : clampedDelta;
+  const desc = ColliderDesc[options.shape](...scaledArgs);
+  return world.createCollider(desc, rigidBody);
+};
+const massPropertiesConflictError = "Please pick ONLY ONE of the `density`, `mass` and `massProperties` options.";
 
-      if (!_paused) {
-        while (steppingState.accumulator >= _timeStep) {
-          world.step(eventQueue);
-          steppingState.accumulator -= _timeStep;
-        }
-      }
+const setColliderMassOptions = (collider, options) => {
+  if (options.density !== undefined) {
+    if (options.mass !== undefined || options.massProperties !== undefined) {
+      throw new Error(massPropertiesConflictError);
     }
 
-    const interpolationAlpha = timeStepVariable ? 1 : steppingState.accumulator % _timeStep / _timeStep; // Update meshes
-
-    rigidBodyStates.forEach((state, handle) => {
-      const rigidBody = world.getRigidBody(handle);
-      const events = rigidBodyEvents.get(handle);
+    collider.setDensity(options.density);
+    return;
+  }
 
-      if (events !== null && events !== void 0 && events.onSleep || events !== null && events !== void 0 && events.onWake) {
-        if (rigidBody.isSleeping() && !state.isSleeping) {
-          var _events$onSleep;
+  if (options.mass !== undefined) {
+    if (options.massProperties !== undefined) {
+      throw new Error(massPropertiesConflictError);
+    }
 
-          events === null || events === void 0 ? void 0 : (_events$onSleep = events.onSleep) === null || _events$onSleep === void 0 ? void 0 : _events$onSleep.call(events);
-        }
+    collider.setMass(options.mass);
+    return;
+  }
 
-        if (!rigidBody.isSleeping() && state.isSleeping) {
-          var _events$onWake;
+  if (options.massProperties !== undefined) {
+    collider.setMassProperties(options.massProperties.mass, options.massProperties.centerOfMass, options.massProperties.principalAngularInertia, options.massProperties.angularInertiaLocalFrame);
+  }
+};
 
-          events === null || events === void 0 ? void 0 : (_events$onWake = events.onWake) === null || _events$onWake === void 0 ? void 0 : _events$onWake.call(events);
-        }
+const mutableColliderOptions = {
+  sensor: (collider, value) => {
+    collider.setSensor(value);
+  },
+  collisionGroups: (collider, value) => {
+    collider.setCollisionGroups(value);
+  },
+  solverGroups: (collider, value) => {
+    collider.setSolverGroups(value);
+  },
+  friction: (collider, value) => {
+    collider.setFriction(value);
+  },
+  frictionCombineRule: (collider, value) => {
+    collider.setFrictionCombineRule(value);
+  },
+  restitution: (collider, value) => {
+    collider.setRestitution(value);
+  },
+  restitutionCombineRule: (collider, value) => {
+    collider.setRestitutionCombineRule(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) => {
+  const state = states.get(collider.handle);
 
-        state.isSleeping = rigidBody.isSleeping();
-      }
+  if (state) {
+    var _state$worldParent;
 
-      if (!rigidBody || rigidBody.isSleeping() || !state.setMatrix) {
-        return;
-      }
+    // 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);
 
-      let t = rigidBody.translation();
-      let r = rigidBody.rotation(); // Get new position
+    _matrix4.copy(state.object.matrixWorld);
 
-      _matrix4.compose(t, rapierQuaternionToQuaternion(r), state.scale).premultiply(state.invertedWorldMatrix).decompose(_position, _rotation, _scale);
+    if (parentInvertedWorldMatrix) {
+      _matrix4.premultiply(parentInvertedWorldMatrix);
+    }
 
-      if (state.object instanceof InstancedMesh) {
-        state.setMatrix(_matrix4);
-        state.object.instanceMatrix.needsUpdate = true;
-      } else {
-        // Interpolate from last position
-        state.object.position.lerp(_position, interpolationAlpha);
-        state.object.quaternion.slerp(_rotation, interpolationAlpha);
-      }
-    });
-    eventQueue.drainCollisionEvents((handle1, handle2, started) => {
-      var _collider1$parent, _collider2$parent;
+    _matrix4.decompose(_position, _rotation, _scale);
 
-      const collider1 = world.getCollider(handle1);
-      const collider2 = world.getCollider(handle2);
-      const rigidBodyHandle1 = (_collider1$parent = collider1.parent()) === null || _collider1$parent === void 0 ? void 0 : _collider1$parent.handle;
-      const rigidBodyHandle2 = (_collider2$parent = collider2.parent()) === null || _collider2$parent === void 0 ? void 0 : _collider2$parent.handle; // Collision Events
+    if (collider.parent()) {
+      collider.setTranslationWrtParent({
+        x: _position.x * parentWorldScale.x,
+        y: _position.y * parentWorldScale.y,
+        z: _position.z * parentWorldScale.z
+      });
+      collider.setRotationWrtParent(_rotation);
+    } else {
+      collider.setTranslation({
+        x: _position.x * parentWorldScale.x,
+        y: _position.y * parentWorldScale.y,
+        z: _position.z * parentWorldScale.z
+      });
+      collider.setRotation(_rotation);
+    }
 
-      if (!collider1 || !collider2) {
-        return;
+    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
+        option, options);
       }
+    }); // handle mass separately, because the assignments
+    // are exclusive.
 
-      const collider1Events = colliderEvents.get(collider1.handle);
-      const collider2Events = colliderEvents.get(collider2.handle);
-      const rigidBody1 = rigidBodyHandle1 ? world.getRigidBody(rigidBodyHandle1) : undefined;
-      const rigidBody2 = rigidBodyHandle2 ? world.getRigidBody(rigidBodyHandle2) : undefined;
-      const rigidBody1Events = rigidBodyHandle1 ? rigidBodyEvents.get(rigidBodyHandle1) : undefined;
-      const rigidBody2Events = rigidBodyHandle2 ? rigidBodyEvents.get(rigidBodyHandle2) : undefined;
-      const collider1State = colliderStates.get(collider1.handle);
-      const collider2State = colliderStates.get(collider2.handle);
-      const rigidBody1State = rigidBodyHandle1 ? rigidBodyStates.get(rigidBodyHandle1) : undefined;
-      const rigidBody2State = rigidBodyHandle2 ? rigidBodyStates.get(rigidBodyHandle2) : undefined;
+    setColliderMassOptions(collider, options);
+  }
+};
+const useUpdateColliderOptions = (collidersRef, props, states) => {
+  // TODO: Improve this, split each prop into its own effect
+  const mutablePropsAsFlatArray = useMemo(() => mutableColliderOptionKeys.flatMap(key => {
+    return vectorToTuple(props[key]);
+  }), [props]);
+  useEffect(() => {
+    collidersRef.current.forEach(collider => {
+      setColliderOptions(collider, props, states);
+    });
+  }, mutablePropsAsFlatArray);
+};
 
-      if (started) {
-        world.contactPair(collider1, collider2, (manifold, flipped) => {
-          var _rigidBody1Events$onC, _rigidBody2Events$onC, _collider1Events$onCo, _collider2Events$onCo;
+const isChildOfMeshCollider = child => {
+  let flag = false;
+  child.traverseAncestors(a => {
+    if (a.userData.r3RapierType === "MeshCollider") flag = true;
+  });
+  return flag;
+};
 
-          /* RigidBody events */
-          rigidBody1Events === null || rigidBody1Events === void 0 ? void 0 : (_rigidBody1Events$onC = rigidBody1Events.onCollisionEnter) === null || _rigidBody1Events$onC === void 0 ? void 0 : _rigidBody1Events$onC.call(rigidBody1Events, {
-            rigidBody: rigidBody2,
-            collider: collider2,
-            colliderObject: collider2State === null || collider2State === void 0 ? void 0 : collider2State.object,
-            rigidBodyObject: rigidBody2State === null || rigidBody2State === void 0 ? void 0 : rigidBody2State.object,
-            manifold,
-            flipped
-          });
-          rigidBody2Events === null || rigidBody2Events === void 0 ? void 0 : (_rigidBody2Events$onC = rigidBody2Events.onCollisionEnter) === null || _rigidBody2Events$onC === void 0 ? void 0 : _rigidBody2Events$onC.call(rigidBody2Events, {
-            rigidBody: rigidBody1,
-            collider: collider1,
-            colliderObject: collider1State === null || collider1State === void 0 ? void 0 : collider1State.object,
-            rigidBodyObject: rigidBody1State === null || rigidBody1State === void 0 ? void 0 : rigidBody1State.object,
-            manifold,
-            flipped
-          });
-          /* Collider events */
-
-          collider1Events === null || collider1Events === void 0 ? void 0 : (_collider1Events$onCo = collider1Events.onCollisionEnter) === null || _collider1Events$onCo === void 0 ? void 0 : _collider1Events$onCo.call(collider1Events, {
-            rigidBody: rigidBody2,
-            collider: collider2,
-            colliderObject: collider2State === null || collider2State === void 0 ? void 0 : collider2State.object,
-            rigidBodyObject: rigidBody2State === null || rigidBody2State === void 0 ? void 0 : rigidBody2State.object,
-            manifold,
-            flipped
-          });
-          collider2Events === null || collider2Events === void 0 ? void 0 : (_collider2Events$onCo = collider2Events.onCollisionEnter) === null || _collider2Events$onCo === void 0 ? void 0 : _collider2Events$onCo.call(collider2Events, {
-            rigidBody: rigidBody1,
-            collider: collider1,
-            colliderObject: collider1State === null || collider1State === void 0 ? void 0 : collider1State.object,
-            rigidBodyObject: rigidBody1State === null || rigidBody1State === void 0 ? void 0 : rigidBody1State.object,
-            manifold,
-            flipped
-          });
-        });
-      } else {
-        var _rigidBody1Events$onC2, _rigidBody2Events$onC2, _collider1Events$onCo2, _collider2Events$onCo2;
-
-        rigidBody1Events === null || rigidBody1Events === void 0 ? void 0 : (_rigidBody1Events$onC2 = rigidBody1Events.onCollisionExit) === null || _rigidBody1Events$onC2 === void 0 ? void 0 : _rigidBody1Events$onC2.call(rigidBody1Events, {
-          rigidBody: rigidBody2,
-          collider: collider2
-        });
-        rigidBody2Events === null || rigidBody2Events === void 0 ? void 0 : (_rigidBody2Events$onC2 = rigidBody2Events.onCollisionExit) === null || _rigidBody2Events$onC2 === void 0 ? void 0 : _rigidBody2Events$onC2.call(rigidBody2Events, {
-          rigidBody: rigidBody1,
-          collider: collider1
-        });
-        collider1Events === null || collider1Events === void 0 ? void 0 : (_collider1Events$onCo2 = collider1Events.onCollisionExit) === null || _collider1Events$onCo2 === void 0 ? void 0 : _collider1Events$onCo2.call(collider1Events, {
-          rigidBody: rigidBody2,
-          collider: collider2
-        });
-        collider2Events === null || collider2Events === void 0 ? void 0 : (_collider2Events$onCo2 = collider2Events.onCollisionExit) === null || _collider2Events$onCo2 === void 0 ? void 0 : _collider2Events$onCo2.call(collider2Events, {
-          rigidBody: rigidBody1,
-          collider: collider1
-        });
-      } // Sensor Intersections
-
-
-      if (started) {
-        if (world.intersectionPair(collider1, collider2)) {
-          var _rigidBody1Events$onI, _rigidBody2Events$onI, _collider1Events$onIn, _collider2Events$onIn;
-
-          rigidBody1Events === null || rigidBody1Events === void 0 ? void 0 : (_rigidBody1Events$onI = rigidBody1Events.onIntersectionEnter) === null || _rigidBody1Events$onI === void 0 ? void 0 : _rigidBody1Events$onI.call(rigidBody1Events, {
-            rigidBody: rigidBody2,
-            collider: collider2,
-            colliderObject: collider2State === null || collider2State === void 0 ? void 0 : collider2State.object,
-            rigidBodyObject: rigidBody2State === null || rigidBody2State === void 0 ? void 0 : rigidBody2State.object
-          });
-          rigidBody2Events === null || rigidBody2Events === void 0 ? void 0 : (_rigidBody2Events$onI = rigidBody2Events.onIntersectionEnter) === null || _rigidBody2Events$onI === void 0 ? void 0 : _rigidBody2Events$onI.call(rigidBody2Events, {
-            rigidBody: rigidBody1,
-            collider: collider1,
-            colliderObject: collider1State === null || collider1State === void 0 ? void 0 : collider1State.object,
-            rigidBodyObject: rigidBody1State === null || rigidBody1State === void 0 ? void 0 : rigidBody1State.object
-          });
-          collider1Events === null || collider1Events === void 0 ? void 0 : (_collider1Events$onIn = collider1Events.onIntersectionEnter) === null || _collider1Events$onIn === void 0 ? void 0 : _collider1Events$onIn.call(collider1Events, {
-            rigidBody: rigidBody2,
-            collider: collider2,
-            colliderObject: collider2State === null || collider2State === void 0 ? void 0 : collider2State.object,
-            rigidBodyObject: rigidBody2State === null || rigidBody2State === void 0 ? void 0 : rigidBody2State.object
-          });
-          collider2Events === null || collider2Events === void 0 ? void 0 : (_collider2Events$onIn = collider2Events.onIntersectionEnter) === null || _collider2Events$onIn === void 0 ? void 0 : _collider2Events$onIn.call(collider2Events, {
-            rigidBody: rigidBody1,
-            collider: collider1,
-            colliderObject: collider1State === null || collider1State === void 0 ? void 0 : collider1State.object,
-            rigidBodyObject: rigidBody1State === null || rigidBody1State === void 0 ? void 0 : rigidBody1State.object
-          });
-        }
-      } else {
-        var _rigidBody1Events$onI2, _rigidBody2Events$onI2, _collider1Events$onIn2, _collider2Events$onIn2;
-
-        rigidBody1Events === null || rigidBody1Events === void 0 ? void 0 : (_rigidBody1Events$onI2 = rigidBody1Events.onIntersectionExit) === null || _rigidBody1Events$onI2 === void 0 ? void 0 : _rigidBody1Events$onI2.call(rigidBody1Events, {
-          rigidBody: rigidBody2,
-          collider: collider2
-        });
-        rigidBody2Events === null || rigidBody2Events === void 0 ? void 0 : (_rigidBody2Events$onI2 = rigidBody2Events.onIntersectionExit) === null || _rigidBody2Events$onI2 === void 0 ? void 0 : _rigidBody2Events$onI2.call(rigidBody2Events, {
-          rigidBody: rigidBody1,
-          collider: collider1
-        });
-        collider1Events === null || collider1Events === void 0 ? void 0 : (_collider1Events$onIn2 = collider1Events.onIntersectionExit) === null || _collider1Events$onIn2 === void 0 ? void 0 : _collider1Events$onIn2.call(collider1Events, {
-          rigidBody: rigidBody2,
-          collider: collider2
-        });
-        collider2Events === null || collider2Events === void 0 ? void 0 : (_collider2Events$onIn2 = collider2Events.onIntersectionExit) === null || _collider2Events$onIn2 === void 0 ? void 0 : _collider2Events$onIn2.call(collider2Events, {
-          rigidBody: rigidBody1,
-          collider: collider1
-        });
-      }
-    });
-  }, updatePriority);
-  const api = useMemo(() => createWorldApi(getWorldRef), []);
-  const context = useMemo(() => ({
-    rapier,
-    world: api,
-    physicsOptions: {
-      colliders: _colliders,
-      gravity: _gravity
-    },
-    rigidBodyStates,
-    colliderStates,
-    rigidBodyEvents,
-    colliderEvents,
-    isPaused: _paused
-  }), [_paused]);
-  return /*#__PURE__*/React.createElement(RapierContext.Provider, {
-    value: context
-  }, children);
+const createColliderState = (collider, object, rigidBodyObject) => {
+  return {
+    collider,
+    worldParent: rigidBodyObject || undefined,
+    object
+  };
+};
+const autoColliderMap = {
+  cuboid: "cuboid",
+  ball: "ball",
+  hull: "convexHull",
+  trimesh: "trimesh"
 };
+const createColliderPropsFromChildren = ({
+  object,
+  ignoreMeshColliders: _ignoreMeshColliders = true,
+  options
+}) => {
+  const colliderProps = [];
+  object.updateWorldMatrix(true, false);
+  const invertedParentMatrixWorld = object.matrixWorld.clone().invert();
 
-function _extends() {
-  _extends = Object.assign ? Object.assign.bind() : function (target) {
-    for (var i = 1; i < arguments.length; i++) {
-      var source = arguments[i];
+  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);
 
-      for (var key in source) {
-        if (Object.prototype.hasOwnProperty.call(source, key)) {
-          target[key] = source[key];
-        }
-      }
-    }
+      _matrix4.copy(child.matrixWorld).premultiply(invertedParentMatrixWorld).decompose(_position, _rotation, _scale);
 
-    return target;
+      const rotationEuler = new Euler().setFromQuaternion(_rotation, "XYZ");
+      const {
+        geometry
+      } = child;
+      const {
+        args,
+        offset
+      } = getColliderArgsFromGeometry(geometry, options.colliders || "cuboid");
+      colliderProps.push(_objectSpread2(_objectSpread2({}, options), {}, {
+        args: args,
+        shape: shape,
+        rotation: [rotationEuler.x, rotationEuler.y, rotationEuler.z],
+        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]
+      }));
+    }
   };
-  return _extends.apply(this, arguments);
-}
-
-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];
+  if (options.includeInvisible) {
+    object.traverse(colliderFromChild);
+  } else {
+    object.traverseVisible(colliderFromChild);
   }
 
-  return target;
-}
-
-function _objectWithoutProperties(source, excluded) {
-  if (source == null) return {};
-  var target = _objectWithoutPropertiesLoose(source, excluded);
-  var key, i;
+  return colliderProps;
+};
+const getColliderArgsFromGeometry = (geometry, colliders) => {
+  switch (colliders) {
+    case "cuboid":
+      {
+        geometry.computeBoundingBox();
+        const {
+          boundingBox
+        } = geometry;
+        const size = boundingBox.getSize(new Vector3());
+        return {
+          args: [size.x / 2, size.y / 2, size.z / 2],
+          offset: boundingBox.getCenter(new Vector3())
+        };
+      }
 
-  if (Object.getOwnPropertySymbols) {
-    var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
+    case "ball":
+      {
+        geometry.computeBoundingSphere();
+        const {
+          boundingSphere
+        } = geometry;
+        const radius = boundingSphere.radius;
+        return {
+          args: [radius],
+          offset: boundingSphere.center
+        };
+      }
 
-    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];
-    }
-  }
+    case "trimesh":
+      {
+        var _clonedGeometry$index;
 
-  return target;
-}
+        const clonedGeometry = geometry.index ? geometry.clone() : mergeVertices(geometry);
+        return {
+          args: [clonedGeometry.attributes.position.array, (_clonedGeometry$index = clonedGeometry.index) === null || _clonedGeometry$index === void 0 ? void 0 : _clonedGeometry$index.array],
+          offset: new Vector3()
+        };
+      }
 
-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;
+    case "hull":
+      {
+        const g = geometry.clone();
+        return {
+          args: [g.attributes.position.array],
+          offset: new Vector3()
+        };
+      }
   }
 
-  return obj;
-}
-
-function ownKeys(object, enumerableOnly) {
-  var keys = Object.keys(object);
+  return {
+    args: [],
+    offset: new Vector3()
+  };
+};
+const useColliderEvents = (collidersRef, props, events) => {
+  const {
+    onCollisionEnter,
+    onCollisionExit,
+    onIntersectionEnter,
+    onIntersectionExit,
+    onContactForce
+  } = props;
+  useEffect(() => {
+    var _collidersRef$current;
 
-  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);
-  }
+    (_collidersRef$current = collidersRef.current) === null || _collidersRef$current === void 0 ? void 0 : _collidersRef$current.forEach(collider => {
+      const hasCollisionEvent = !!(onCollisionEnter || onCollisionExit || onIntersectionEnter || onIntersectionExit);
+      const hasContactForceEvent = !!onContactForce;
 
-  return keys;
-}
+      if (hasCollisionEvent && hasContactForceEvent) {
+        collider.setActiveEvents(ActiveEvents.COLLISION_EVENTS | ActiveEvents.CONTACT_FORCE_EVENTS);
+      } else if (hasCollisionEvent) {
+        collider.setActiveEvents(ActiveEvents.COLLISION_EVENTS);
+      } else if (hasContactForceEvent) {
+        collider.setActiveEvents(ActiveEvents.CONTACT_FORCE_EVENTS);
+      }
 
-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));
+      events.set(collider.handle, {
+        onCollisionEnter,
+        onCollisionExit,
+        onIntersectionEnter,
+        onIntersectionExit,
+        onContactForce
+      });
     });
-  }
+    return () => {
+      var _collidersRef$current2;
 
-  return target;
-}
+      (_collidersRef$current2 = collidersRef.current) === null || _collidersRef$current2 === void 0 ? void 0 : _collidersRef$current2.forEach(collider => events.delete(collider.handle));
+    };
+  }, [onCollisionEnter, onCollisionExit, onIntersectionEnter, onIntersectionExit, onContactForce]);
+};
 
 const rigidBodyDescFromOptions = options => {
   const type = rigidBodyTypeFromString((options === null || options === void 0 ? void 0 : options.type) || "dynamic");
@@ -642,6 +612,9 @@ const mutableRigidBodyOptions = {
   ccd: (rb, value) => {
     rb.enableCcd(value);
   },
+  userData: (rb, value) => {
+    rb.userData = value;
+  },
   position: () => {},
   rotation: () => {},
   quaternion: () => {},
@@ -725,443 +698,626 @@ const useRigidBodyEvents = (rigidBodyRef, props, events) => {
   }, [onWake, onSleep, onCollisionEnter, onCollisionExit, onIntersectionEnter, onIntersectionExit]);
 };
 
-const scaleColliderArgs = (shape, args, scale) => {
-  const newArgs = args.slice(); // Heightfield uses a vector
+const useRapier = () => {
+  return useContext(RapierContext);
+};
+const useChildColliderProps = (ref, options, ignoreMeshColliders = true) => {
+  const [colliderProps, setColliderProps] = useState([]);
+  useEffect(() => {
+    const object = ref.current;
 
-  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
+    if (object && options.colliders !== false) {
+      setColliderProps(createColliderPropsFromChildren({
+        object: ref.current,
+        options,
+        ignoreMeshColliders
+      }));
+    }
+  }, [options.colliders]);
+  return colliderProps;
+};
+const useRigidBody = (options = {}) => {
+  const {
+    world,
+    rigidBodyStates,
+    physicsOptions,
+    rigidBodyEvents
+  } = useRapier();
+  const ref = useRef();
+  const mergedOptions = useMemo(() => {
+    return _objectSpread2(_objectSpread2(_objectSpread2({}, physicsOptions), options), {}, {
+      children: undefined
+    });
+  }, [physicsOptions, options]);
+  const childColliderProps = useChildColliderProps(ref, mergedOptions); // Create rigidbody
 
+  const rigidBodyRef = useRef();
+  const getRigidBodyRef = useRef(() => {
+    if (!rigidBodyRef.current) {
+      const desc = rigidBodyDescFromOptions(options);
+      const rigidBody = world.createRigidBody(desc);
+      rigidBodyRef.current = world.getRigidBody(rigidBody.handle);
+    }
 
-  if (shape === "trimesh" || shape === "convexHull") {
-    newArgs[0] = scaleVertices(newArgs[0], scale);
-    return newArgs;
-  } // Prepfill with some extra
+    return rigidBodyRef.current;
+  }); // Setup
 
+  useEffect(() => {
+    const rigidBody = getRigidBodyRef.current();
+    rigidBodyRef.current = rigidBody;
 
-  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, rigidBody) => {
-  const scaledArgs = scaleColliderArgs(options.shape, options.args, scale); // @ts-ignore
+    if (!ref.current) {
+      ref.current = new Object3D();
+    }
 
-  const desc = ColliderDesc[options.shape](...scaledArgs);
-  return world.createCollider(desc, rigidBody);
-};
-const massPropertiesConflictError = "Please pick ONLY ONE of the `density`, `mass` and `massProperties` options.";
+    rigidBodyStates.set(rigidBody.handle, createRigidBodyState({
+      rigidBody,
+      object: ref.current
+    }));
+    return () => {
+      world.removeRigidBody(rigidBody);
+      rigidBodyStates.delete(rigidBody.handle);
+      rigidBodyRef.current = undefined;
+    };
+  }, []);
+  useUpdateRigidBodyOptions(rigidBodyRef, mergedOptions, rigidBodyStates);
+  useRigidBodyEvents(rigidBodyRef, mergedOptions, rigidBodyEvents);
+  const api = useMemo(() => createRigidBodyApi(getRigidBodyRef), []);
+  return [ref, api, childColliderProps];
+}; // Joints
 
-const setColliderMassOptions = (collider, options) => {
-  if (options.density !== undefined) {
-    if (options.mass !== undefined || options.massProperties !== undefined) {
-      throw new Error(massPropertiesConflictError);
+const useImpulseJoint = (body1, body2, params) => {
+  const {
+    world
+  } = useRapier();
+  const jointRef = useRef();
+  const getJointRef = useRef(() => {
+    if (!jointRef.current) {
+      let rb1;
+      let rb2;
+
+      if ("current" in body1 && body1.current && "current" in body2 && body2.current) {
+        rb1 = world.getRigidBody(body1.current.handle);
+        rb2 = world.getRigidBody(body2.current.handle);
+        const newJoint = world.createImpulseJoint(params, rb1, rb2);
+        jointRef.current = newJoint;
+      }
     }
 
-    collider.setDensity(options.density);
-    return;
-  }
+    return jointRef.current;
+  });
+  useEffect(() => {
+    const joint = getJointRef.current();
+    return () => {
+      if (joint) {
+        world.removeImpulseJoint(joint);
+        jointRef.current = undefined;
+      }
+    };
+  }, []);
+  const api = useMemo(() => createJointApi(getJointRef), []);
+  return api;
+};
+/**
+ *
+ * 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.
+ * The fixed-joint makes these frames coincide in world-space.
+ */
 
-  if (options.mass !== undefined) {
-    if (options.massProperties !== undefined) {
-      throw new Error(massPropertiesConflictError);
-    }
+const useFixedJoint = (body1, body2, [body1Anchor, body1LocalFrame, body2Anchor, body2LocalFrame]) => {
+  const {
+    rapier
+  } = useRapier();
+  return useImpulseJoint(body1, body2, rapier.JointData.fixed(vectorArrayToVector3(body1Anchor), _objectSpread2(_objectSpread2({}, vectorArrayToVector3(body1LocalFrame)), {}, {
+    w: 1
+  }), vectorArrayToVector3(body2Anchor), _objectSpread2(_objectSpread2({}, vectorArrayToVector3(body2LocalFrame)), {}, {
+    w: 1
+  })));
+};
+/**
+ * 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.
+ * They are characterized by one local anchor on each rigid-body. Each anchor represents the location of the
+ * points that need to coincide on the local-space of each rigid-body.
+ */
 
-    collider.setMass(options.mass);
-    return;
-  }
+const useSphericalJoint = (body1, body2, [body1Anchor, body2Anchor]) => {
+  const {
+    rapier
+  } = useRapier();
+  return useImpulseJoint(body1, body2, rapier.JointData.spherical(vectorArrayToVector3(body1Anchor), vectorArrayToVector3(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.
+ * They are characterized by one local anchor as well as one local axis on each rigid-body.
+ */
 
-  if (options.massProperties !== undefined) {
-    collider.setMassProperties(options.massProperties.mass, options.massProperties.centerOfMass, options.massProperties.principalAngularInertia, options.massProperties.angularInertiaLocalFrame);
-  }
+const useRevoluteJoint = (body1, body2, [body1Anchor, body2Anchor, axis]) => {
+  const {
+    rapier
+  } = useRapier();
+  return useImpulseJoint(body1, body2, rapier.JointData.revolute(vectorArrayToVector3(body1Anchor), vectorArrayToVector3(body2Anchor), vectorArrayToVector3(axis)));
 };
+/**
+ * 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
+ * local tangent axis can be specified for each rigid-body.
+ */
 
-const mutableColliderOptions = {
-  sensor: (collider, value) => {
-    collider.setSensor(value);
-  },
-  collisionGroups: (collider, value) => {
-    collider.setCollisionGroups(value);
-  },
-  solverGroups: (collider, value) => {
-    collider.setSolverGroups(value);
-  },
-  friction: (collider, value) => {
-    collider.setFriction(value);
-  },
-  frictionCombineRule: (collider, value) => {
-    collider.setFrictionCombineRule(value);
-  },
-  restitution: (collider, value) => {
-    collider.setRestitution(value);
-  },
-  restitutionCombineRule: (collider, value) => {
-    collider.setRestitutionCombineRule(value);
-  },
-  // To make sure the options all mutalbe options are listed
-  quaternion: () => {},
-  position: () => {},
-  rotation: () => {},
-  scale: () => {}
+const usePrismaticJoint = (body1, body2, [body1Anchor, body2Anchor, axis]) => {
+  const {
+    rapier
+  } = useRapier();
+  return useImpulseJoint(body1, body2, rapier.JointData.prismatic(vectorArrayToVector3(body1Anchor), vectorArrayToVector3(body2Anchor), vectorArrayToVector3(axis)));
 };
-const mutableColliderOptionKeys = Object.keys(mutableColliderOptions);
-const setColliderOptions = (collider, options, states) => {
-  const state = states.get(collider.handle);
 
-  if (state) {
-    // Update collider position based on the object's position
-    const parentWorldScale = state.object.parent.getWorldScale(_vector3);
-    state.object.updateWorldMatrix(true, false);
+const calcForceByType = {
+  static: (s, m2, r, d, G) => s,
+  linear: (s, m2, r, d, G) => s * (d / r),
+  newtonian: (s, m2, r, d, G) => G * s * m2 / Math.pow(d, 2)
+};
+const applyAttractorForceOnRigidBody = (rigidBody, {
+  object,
+  strength,
+  range,
+  gravitationalConstant,
+  collisionGroups,
+  type
+}) => {
+  const rbPosition = rigidBody.translation();
 
-    _matrix4.copy(state.object.matrixWorld).premultiply(state.worldParent.matrixWorld.clone().invert()).decompose(_position, _rotation, _scale);
+  _position.set(rbPosition.x, rbPosition.y, rbPosition.z);
 
-    if (collider.parent()) {
-      collider.setTranslationWrtParent({
-        x: _position.x * parentWorldScale.x,
-        y: _position.y * parentWorldScale.y,
-        z: _position.z * parentWorldScale.z
-      });
-      collider.setRotationWrtParent(_rotation);
-    } else {
-      collider.setTranslation({
-        x: _position.x * parentWorldScale.x,
-        y: _position.y * parentWorldScale.y,
-        z: _position.z * parentWorldScale.z
-      });
-      collider.setRotation(_rotation);
-    }
+  const worldPosition = object.getWorldPosition(new Vector3());
+  const distance = worldPosition.distanceTo(_position);
 
-    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
-        option, options);
+  if (distance < range) {
+    let force = calcForceByType[type](strength, rigidBody.mass(), range, distance, gravitationalConstant); // Prevent wild forces when Attractors collide
+
+    force = force === Infinity ? strength : force; // Naively test if the rigidBody contains a collider in one of the collision groups
+
+    let isRigidBodyInCollisionGroup = collisionGroups === undefined ? true : false;
+
+    if (collisionGroups !== undefined) {
+      for (let i = 0; i < rigidBody.numColliders(); i++) {
+        const collider = rigidBody.collider(i);
+        const colliderCollisionGroups = collider.collisionGroups();
+
+        if ((collisionGroups >> 16 & colliderCollisionGroups) != 0 && (colliderCollisionGroups >> 16 & collisionGroups) != 0) {
+          isRigidBodyInCollisionGroup = true;
+          break;
+        }
       }
-    }); // handle mass separately, because the assignments
-    // are exclusive.
+    }
 
-    setColliderMassOptions(collider, options);
+    if (isRigidBodyInCollisionGroup) {
+      _vector3.set(0, 0, 0).subVectors(worldPosition, _position).normalize().multiplyScalar(force);
+
+      rigidBody.applyImpulse(_vector3, true);
+    }
   }
 };
-const useUpdateColliderOptions = (collidersRef, props, states) => {
-  // TODO: Improve this, split each prop into its own effect
-  const mutablePropsAsFlatArray = useMemo(() => mutableColliderOptionKeys.flatMap(key => {
-    return vectorToTuple(props[key]);
-  }), [props]);
+const Attractor = /*#__PURE__*/memo(props => {
+  const {
+    position = [0, 0, 0],
+    strength = 1,
+    range = 10,
+    type = "static",
+    gravitationalConstant = 6.673e-11,
+    collisionGroups
+  } = props;
+  const {
+    attractorStates
+  } = useRapier();
+  const object = useRef(null);
   useEffect(() => {
-    collidersRef.current.forEach(collider => {
-      setColliderOptions(collider, props, states);
-    });
-  }, mutablePropsAsFlatArray);
-};
+    var _object$current;
+
+    let uuid = ((_object$current = object.current) === null || _object$current === void 0 ? void 0 : _object$current.uuid) || "_";
+
+    if (object.current) {
+      attractorStates.set(uuid, {
+        object: object.current,
+        strength,
+        range,
+        type,
+        gravitationalConstant,
+        collisionGroups
+      });
+    }
 
-const isChildOfMeshCollider = child => {
-  let flag = false;
-  child.traverseAncestors(a => {
-    if (a.userData.r3RapierType === "MeshCollider") flag = true;
+    return () => {
+      attractorStates.delete(uuid);
+    };
+  }, [props]);
+  return /*#__PURE__*/React.createElement("object3D", {
+    ref: object,
+    position: position
   });
-  return flag;
-};
+});
+
+const RapierContext = /*#__PURE__*/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;
 
-const createColliderState = (collider, object, rigidBodyObject) => {
   return {
-    collider,
-    worldParent: rigidBodyObject || object.parent,
-    object
+    target: {
+      rigidBody: target.rigidBody.object,
+      collider: target.collider.object,
+      colliderObject: (_target$collider$stat = target.collider.state) === null || _target$collider$stat === void 0 ? void 0 : _target$collider$stat.object,
+      rigidBodyObject: (_target$rigidBody$sta = target.rigidBody.state) === null || _target$rigidBody$sta === void 0 ? void 0 : _target$rigidBody$sta.object
+    },
+    other: {
+      rigidBody: other.rigidBody.object,
+      collider: other.collider.object,
+      colliderObject: (_other$collider$state = other.collider.state) === null || _other$collider$state === void 0 ? void 0 : _other$collider$state.object,
+      rigidBodyObject: (_other$rigidBody$stat = other.rigidBody.state) === null || _other$rigidBody$stat === void 0 ? void 0 : _other$rigidBody$stat.object
+    },
+    rigidBody: other.rigidBody.object,
+    collider: other.collider.object,
+    colliderObject: (_other$collider$state2 = other.collider.state) === null || _other$collider$state2 === void 0 ? void 0 : _other$collider$state2.object,
+    rigidBodyObject: (_other$rigidBody$stat2 = other.rigidBody.state) === null || _other$rigidBody$stat2 === void 0 ? void 0 : _other$rigidBody$stat2.object
   };
 };
-const autoColliderMap = {
-  cuboid: "cuboid",
-  ball: "ball",
-  hull: "convexHull",
-  trimesh: "trimesh"
+
+const importRapier = async () => {
+  let r = await import('@dimforge/rapier3d-compat');
+  await r.init();
+  return r;
 };
-const createColliderPropsFromChildren = ({
-  object,
-  ignoreMeshColliders: _ignoreMeshColliders = true,
-  options
+
+const Physics = ({
+  colliders: _colliders = "cuboid",
+  gravity: _gravity = [0, -9.81, 0],
+  children,
+  timeStep: _timeStep = 1 / 60,
+  paused: _paused = false,
+  updatePriority,
+  interpolate: _interpolate = true
 }) => {
-  const colliderProps = [];
-  object.updateWorldMatrix(true, false);
-  const invertedParentMatrixWorld = object.matrixWorld.clone().invert();
+  const rapier = useAsset(importRapier);
+  const worldRef = useRef();
+  const getWorldRef = useRef(() => {
+    if (!worldRef.current) {
+      const world = new rapier.World(vectorArrayToVector3(_gravity));
+      worldRef.current = world;
+    }
 
-  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);
+    return worldRef.current;
+  });
+  const [rigidBodyStates] = useState(() => new Map());
+  const [colliderStates] = useState(() => new Map());
+  const [rigidBodyEvents] = useState(() => new Map());
+  const [colliderEvents] = useState(() => new Map());
+  const [eventQueue] = useState(() => new EventQueue(false));
+  const [attractorStates] = useState(() => new Map()); // Init world
 
-      _matrix4.copy(child.matrixWorld).premultiply(invertedParentMatrixWorld).decompose(_position, _rotation, _scale);
+  useEffect(() => {
+    const world = getWorldRef.current();
+    return () => {
+      if (world) {
+        world.free();
+        worldRef.current = undefined;
+      }
+    };
+  }, []); // Update gravity
 
-      const rotationEuler = new Euler().setFromQuaternion(_rotation, "XYZ");
-      const {
-        geometry
-      } = child;
-      const {
-        args,
-        offset
-      } = getColliderArgsFromGeometry(geometry, options.colliders || "cuboid");
-      colliderProps.push(_objectSpread2(_objectSpread2({}, options), {}, {
-        args: args,
-        shape: shape,
-        rotation: [rotationEuler.x, rotationEuler.y, rotationEuler.z],
-        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]
-      }));
+  useEffect(() => {
+    const world = worldRef.current;
+
+    if (world) {
+      world.gravity = vectorArrayToVector3(_gravity);
     }
-  };
+  }, [_gravity]);
+  const getSourceFromColliderHandle = useCallback(handle => {
+    const world = worldRef.current;
 
-  if (options.includeInvisible) {
-    object.traverse(colliderFromChild);
-  } else {
-    object.traverseVisible(colliderFromChild);
-  }
+    if (world) {
+      var _collider$parent;
+
+      const collider = world.getCollider(handle);
+      const colEvents = colliderEvents.get(handle);
+      const colliderState = colliderStates.get(handle);
+      const rigidBodyHandle = collider === null || collider === void 0 ? void 0 : (_collider$parent = collider.parent()) === null || _collider$parent === void 0 ? void 0 : _collider$parent.handle;
+      const rigidBody = rigidBodyHandle !== undefined ? world.getRigidBody(rigidBodyHandle) : undefined;
+      const rbEvents = rigidBody && rigidBodyHandle !== undefined ? rigidBodyEvents.get(rigidBodyHandle) : undefined;
+      const rigidBodyState = rigidBodyHandle !== undefined ? rigidBodyStates.get(rigidBodyHandle) : undefined;
+      const source = {
+        collider: {
+          object: collider,
+          events: colEvents,
+          state: colliderState
+        },
+        rigidBody: {
+          object: rigidBody,
+          events: rbEvents,
+          state: rigidBodyState
+        }
+      };
+      return source;
+    }
+  }, []);
+  const [steppingState] = useState({
+    previousState: {},
+    accumulator: 0
+  });
+  const step = useCallback(dt => {
+    const world = worldRef.current;
+    if (!world) return;
+    /* 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. */
 
-  return colliderProps;
-};
-const getColliderArgsFromGeometry = (geometry, colliders) => {
-  switch (colliders) {
-    case "cuboid":
-      {
-        geometry.computeBoundingBox();
-        const {
-          boundingBox
-        } = geometry;
-        const size = boundingBox.getSize(new Vector3());
-        return {
-          args: [size.x / 2, size.y / 2, size.z / 2],
-          offset: boundingBox.getCenter(new Vector3())
-        };
+    const timeStepVariable = _timeStep === "vary";
+    /**
+     * Fixed timeStep simulation progression
+     * @see https://gafferongames.com/post/fix_your_timestep/
+     */
+
+    const clampedDelta = MathUtils.clamp(dt, 0, 0.2);
+
+    if (timeStepVariable) {
+      world.timestep = clampedDelta;
+      world.step(eventQueue);
+    } else {
+      world.timestep = _timeStep; // don't step time forwards if paused
+      // Increase accumulator
+
+      steppingState.accumulator += clampedDelta;
+
+      while (steppingState.accumulator >= _timeStep) {
+        world.forEachRigidBody(body => {
+          // Set up previous state
+          // needed for accurate interpolations if the world steps more than once
+          if (_interpolate) {
+            steppingState.previousState = {};
+            steppingState.previousState[body.handle] = {
+              position: body.translation(),
+              rotation: body.rotation()
+            };
+          } // Apply attractors
+
+
+          attractorStates.forEach(attractorState => {
+            applyAttractorForceOnRigidBody(body, attractorState);
+          });
+        });
+        world.step(eventQueue);
+        steppingState.accumulator -= _timeStep;
       }
+    }
 
-    case "ball":
-      {
-        geometry.computeBoundingSphere();
-        const {
-          boundingSphere
-        } = geometry;
-        const radius = boundingSphere.radius;
-        return {
-          args: [radius],
-          offset: boundingSphere.center
-        };
+    const interpolationAlpha = timeStepVariable || !_interpolate || _paused ? 1 : steppingState.accumulator / _timeStep; // 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();
       }
 
-    case "trimesh":
-      {
-        var _clonedGeometry$index;
+      if (!rigidBody || rigidBody.isSleeping() || !state.setMatrix) {
+        return;
+      } // New states
 
-        const clonedGeometry = geometry.index ? geometry.clone() : mergeVertices(geometry);
-        return {
-          args: [clonedGeometry.attributes.position.array, (_clonedGeometry$index = clonedGeometry.index) === null || _clonedGeometry$index === void 0 ? void 0 : _clonedGeometry$index.array],
-          offset: new Vector3()
-        };
+
+      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
+
+
+        if (!(state.object instanceof InstancedMesh)) {
+          state.object.position.copy(_position);
+          state.object.quaternion.copy(_rotation);
+        }
+      } // Get new position
+
+
+      _matrix4.compose(t, rapierQuaternionToQuaternion(r), state.scale).premultiply(state.invertedWorldMatrix).decompose(_position, _rotation, _scale);
+
+      if (state.object instanceof InstancedMesh) {
+        state.setMatrix(_matrix4);
+        state.object.instanceMatrix.needsUpdate = true;
+      } else {
+        // Interpolate to new position
+        state.object.position.lerp(_position, interpolationAlpha);
+        state.object.quaternion.slerp(_rotation, interpolationAlpha);
       }
+    });
+    eventQueue.drainCollisionEvents((handle1, handle2, started) => {
+      const source1 = getSourceFromColliderHandle(handle1);
+      const source2 = getSourceFromColliderHandle(handle2); // Collision Events
 
-    case "hull":
-      {
-        const g = geometry.clone();
-        return {
-          args: [g.attributes.position.array],
-          offset: new Vector3()
-        };
+      if (!(source1 !== null && source1 !== void 0 && source1.collider.object) || !(source2 !== null && source2 !== void 0 && source2.collider.object)) {
+        return;
       }
-  }
 
-  return {
-    args: [],
-    offset: new Vector3()
-  };
-};
-const useColliderEvents = (collidersRef, props, events) => {
-  const {
-    onCollisionEnter,
-    onCollisionExit,
-    onIntersectionEnter,
-    onIntersectionExit
-  } = props;
-  useEffect(() => {
-    var _collidersRef$current;
+      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,
+            flipped
+          }));
+          (_source2$rigidBody$ev = source2.rigidBody.events) === null || _source2$rigidBody$ev === void 0 ? void 0 : (_source2$rigidBody$ev2 = _source2$rigidBody$ev.onCollisionEnter) === null || _source2$rigidBody$ev2 === void 0 ? void 0 : _source2$rigidBody$ev2.call(_source2$rigidBody$ev, _objectSpread2(_objectSpread2({}, collisionPayload2), {}, {
+            manifold,
+            flipped
+          }));
+          /* 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
+          }));
+          (_source2$collider$eve = source2.collider.events) === null || _source2$collider$eve === void 0 ? void 0 : (_source2$collider$eve2 = _source2$collider$eve.onCollisionEnter) === null || _source2$collider$eve2 === void 0 ? void 0 : _source2$collider$eve2.call(_source2$collider$eve, _objectSpread2(_objectSpread2({}, collisionPayload2), {}, {
+            manifold,
+            flipped
+          }));
+        });
+      } 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
 
-    (_collidersRef$current = collidersRef.current) === null || _collidersRef$current === void 0 ? void 0 : _collidersRef$current.forEach(collider => {
-      if (onCollisionEnter || onCollisionExit || onIntersectionEnter || onIntersectionExit) {
-        collider.setActiveEvents(ActiveEvents.COLLISION_EVENTS);
-      }
 
-      events.set(collider.handle, {
-        onCollisionEnter,
-        onCollisionExit,
-        onIntersectionEnter,
-        onIntersectionExit
-      });
+      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);
+          (_source2$collider$eve5 = source2.collider.events) === null || _source2$collider$eve5 === void 0 ? void 0 : (_source2$collider$eve6 = _source2$collider$eve5.onIntersectionEnter) === null || _source2$collider$eve6 === void 0 ? void 0 : _source2$collider$eve6.call(_source2$collider$eve5, collisionPayload2);
+        }
+      } 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);
+        (_source2$collider$eve7 = source2.collider.events) === null || _source2$collider$eve7 === void 0 ? void 0 : (_source2$collider$eve8 = _source2$collider$eve7.onIntersectionExit) === null || _source2$collider$eve8 === void 0 ? void 0 : _source2$collider$eve8.call(_source2$collider$eve7, collisionPayload2);
+      }
     });
-    return () => {
-      var _collidersRef$current2;
+    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;
 
-      (_collidersRef$current2 = collidersRef.current) === null || _collidersRef$current2 === void 0 ? void 0 : _collidersRef$current2.forEach(collider => events.delete(collider.handle));
-    };
-  }, [onCollisionEnter, onCollisionExit, onIntersectionEnter, onIntersectionExit]);
-};
+      const source1 = getSourceFromColliderHandle(event.collider1());
+      const source2 = getSourceFromColliderHandle(event.collider2()); // Collision Events
 
-const useRapier = () => {
-  return useContext(RapierContext);
-};
-const useChildColliderProps = (ref, options, ignoreMeshColliders = true) => {
-  const [colliderProps, setColliderProps] = useState([]);
-  useEffect(() => {
-    const object = ref.current;
+      if (!(source1 !== null && source1 !== void 0 && source1.collider.object) || !(source2 !== null && source2 !== void 0 && source2.collider.object)) {
+        return;
+      }
 
-    if (object && options.colliders !== false) {
-      setColliderProps(createColliderPropsFromChildren({
-        object: ref.current,
-        options,
-        ignoreMeshColliders
+      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), {}, {
+        totalForce: event.totalForce(),
+        totalForceMagnitude: event.totalForceMagnitude(),
+        maxForceDirection: event.maxForceDirection(),
+        maxForceMagnitude: event.maxForceMagnitude()
+      }));
+      (_source2$rigidBody$ev9 = source2.rigidBody.events) === null || _source2$rigidBody$ev9 === void 0 ? void 0 : (_source2$rigidBody$ev10 = _source2$rigidBody$ev9.onContactForce) === null || _source2$rigidBody$ev10 === void 0 ? void 0 : _source2$rigidBody$ev10.call(_source2$rigidBody$ev9, _objectSpread2(_objectSpread2({}, collisionPayload2), {}, {
+        totalForce: event.totalForce(),
+        totalForceMagnitude: event.totalForceMagnitude(),
+        maxForceDirection: event.maxForceDirection(),
+        maxForceMagnitude: event.maxForceMagnitude()
+      }));
+      (_source1$collider$eve9 = source1.collider.events) === null || _source1$collider$eve9 === void 0 ? void 0 : (_source1$collider$eve10 = _source1$collider$eve9.onContactForce) === null || _source1$collider$eve10 === void 0 ? void 0 : _source1$collider$eve10.call(_source1$collider$eve9, _objectSpread2(_objectSpread2({}, collisionPayload1), {}, {
+        totalForce: event.totalForce(),
+        totalForceMagnitude: event.totalForceMagnitude(),
+        maxForceDirection: event.maxForceDirection(),
+        maxForceMagnitude: event.maxForceMagnitude()
+      }));
+      (_source2$collider$eve9 = source2.collider.events) === null || _source2$collider$eve9 === void 0 ? void 0 : (_source2$collider$eve10 = _source2$collider$eve9.onContactForce) === null || _source2$collider$eve10 === void 0 ? void 0 : _source2$collider$eve10.call(_source2$collider$eve9, _objectSpread2(_objectSpread2({}, collisionPayload2), {}, {
+        totalForce: event.totalForce(),
+        totalForceMagnitude: event.totalForceMagnitude(),
+        maxForceDirection: event.maxForceDirection(),
+        maxForceMagnitude: event.maxForceMagnitude()
       }));
-    }
-  }, [options.colliders]);
-  return colliderProps;
-};
-const useRigidBody = (options = {}) => {
-  const {
-    world,
-    rigidBodyStates,
-    physicsOptions,
-    rigidBodyEvents
-  } = useRapier();
-  const ref = useRef();
-  const mergedOptions = useMemo(() => {
-    return _objectSpread2(_objectSpread2(_objectSpread2({}, physicsOptions), options), {}, {
-      children: undefined
     });
-  }, [physicsOptions, options]);
-  const childColliderProps = useChildColliderProps(ref, mergedOptions); // Create rigidbody
+  }, [_paused, _timeStep, _interpolate]);
+  useFrame((_, dt) => {
+    if (!_paused) step(dt);
+  }, updatePriority);
+  const api = useMemo(() => createWorldApi(getWorldRef), []);
+  const context = useMemo(() => ({
+    rapier,
+    world: api,
+    physicsOptions: {
+      colliders: _colliders,
+      gravity: _gravity
+    },
+    rigidBodyStates,
+    colliderStates,
+    rigidBodyEvents,
+    colliderEvents,
+    attractorStates,
+    isPaused: _paused,
+    step
+  }), [_paused, step]);
+  return /*#__PURE__*/React.createElement(RapierContext.Provider, {
+    value: context
+  }, children);
+};
 
-  const rigidBodyRef = useRef();
-  const getRigidBodyRef = useRef(() => {
-    if (!rigidBodyRef.current) {
-      const desc = rigidBodyDescFromOptions(options);
-      const rigidBody = world.createRigidBody(desc);
-      rigidBodyRef.current = world.getRigidBody(rigidBody.handle);
+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 rigidBodyRef.current;
-  }); // Setup
+    return target;
+  };
+  return _extends.apply(this, arguments);
+}
 
-  useEffect(() => {
-    const rigidBody = getRigidBodyRef.current();
-    rigidBodyRef.current = rigidBody;
+function _objectWithoutPropertiesLoose(source, excluded) {
+  if (source == null) return {};
+  var target = {};
+  var sourceKeys = Object.keys(source);
+  var key, i;
 
-    if (!ref.current) {
-      ref.current = new Object3D();
-    } // isSleeping used for onSleep and onWake events
+  for (i = 0; i < sourceKeys.length; i++) {
+    key = sourceKeys[i];
+    if (excluded.indexOf(key) >= 0) continue;
+    target[key] = source[key];
+  }
 
+  return target;
+}
 
-    ref.current.userData.isSleeping = false;
-    rigidBodyStates.set(rigidBody.handle, createRigidBodyState({
-      rigidBody,
-      object: ref.current
-    }));
-    return () => {
-      world.removeRigidBody(rigidBody);
-      rigidBodyStates.delete(rigidBody.handle);
-      rigidBodyRef.current = undefined;
-    };
-  }, []);
-  useUpdateRigidBodyOptions(rigidBodyRef, mergedOptions, rigidBodyStates);
-  useRigidBodyEvents(rigidBodyRef, mergedOptions, rigidBodyEvents);
-  const api = useMemo(() => createRigidBodyApi(getRigidBodyRef), []);
-  return [ref, api, childColliderProps];
-}; // Joints
+function _objectWithoutProperties(source, excluded) {
+  if (source == null) return {};
+  var target = _objectWithoutPropertiesLoose(source, excluded);
+  var key, i;
 
-const useImpulseJoint = (body1, body2, params) => {
-  const {
-    world
-  } = useRapier();
-  const jointRef = useRef();
-  const getJointRef = useRef(() => {
-    if (!jointRef.current) {
-      let rb1;
-      let rb2;
+  if (Object.getOwnPropertySymbols) {
+    var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
 
-      if ("current" in body1 && body1.current && "current" in body2 && body2.current) {
-        rb1 = world.getRigidBody(body1.current.handle);
-        rb2 = world.getRigidBody(body2.current.handle);
-        const newJoint = world.createImpulseJoint(params, rb1, rb2);
-        jointRef.current = newJoint;
-      }
+    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];
     }
+  }
 
-    return jointRef.current;
-  });
-  useEffect(() => {
-    const joint = getJointRef.current();
-    return () => {
-      if (joint) {
-        world.removeImpulseJoint(joint);
-        jointRef.current = undefined;
-      }
-    };
-  }, []);
-  const api = useMemo(() => createJointApi(getJointRef), []);
-  return api;
-};
-/**
- *
- * 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.
- * The fixed-joint makes these frames coincide in world-space.
- */
-
-const useFixedJoint = (body1, body2, [body1Anchor, body1LocalFrame, body2Anchor, body2LocalFrame]) => {
-  const {
-    rapier
-  } = useRapier();
-  return useImpulseJoint(body1, body2, rapier.JointData.fixed(vectorArrayToVector3(body1Anchor), _objectSpread2(_objectSpread2({}, vectorArrayToVector3(body1LocalFrame)), {}, {
-    w: 1
-  }), vectorArrayToVector3(body2Anchor), _objectSpread2(_objectSpread2({}, vectorArrayToVector3(body2LocalFrame)), {}, {
-    w: 1
-  })));
-};
-/**
- * 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.
- * They are characterized by one local anchor on each rigid-body. Each anchor represents the location of the
- * points that need to coincide on the local-space of each rigid-body.
- */
-
-const useSphericalJoint = (body1, body2, [body1Anchor, body2Anchor]) => {
-  const {
-    rapier
-  } = useRapier();
-  return useImpulseJoint(body1, body2, rapier.JointData.spherical(vectorArrayToVector3(body1Anchor), vectorArrayToVector3(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.
- * They are characterized by one local anchor as well as one local axis on each rigid-body.
- */
-
-const useRevoluteJoint = (body1, body2, [body1Anchor, body2Anchor, axis]) => {
-  const {
-    rapier
-  } = useRapier();
-  return useImpulseJoint(body1, body2, rapier.JointData.revolute(vectorArrayToVector3(body1Anchor), vectorArrayToVector3(body2Anchor), vectorArrayToVector3(axis)));
-};
-/**
- * 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
- * local tangent axis can be specified for each rigid-body.
- */
-
-const usePrismaticJoint = (body1, body2, [body1Anchor, body2Anchor, axis]) => {
-  const {
-    rapier
-  } = useRapier();
-  return useImpulseJoint(body1, body2, rapier.JointData.prismatic(vectorArrayToVector3(body1Anchor), vectorArrayToVector3(body2Anchor), vectorArrayToVector3(axis)));
-};
+  return target;
+}
 
 // Colliders
 const AnyCollider = /*#__PURE__*/memo( /*#__PURE__*/React.forwardRef((props, forwardedRef) => {
@@ -1170,7 +1326,8 @@ const AnyCollider = /*#__PURE__*/memo( /*#__PURE__*/React.forwardRef((props, for
     position,
     rotation,
     quaternion,
-    scale
+    scale,
+    name
   } = props;
   const {
     world,
@@ -1230,7 +1387,8 @@ const AnyCollider = /*#__PURE__*/memo( /*#__PURE__*/React.forwardRef((props, for
     rotation: rotation,
     quaternion: quaternion,
     scale: scale,
-    ref: ref
+    ref: ref,
+    name: name
   }, children);
 }));
 const CuboidCollider = /*#__PURE__*/React.forwardRef((props, ref) => {
@@ -1287,6 +1445,15 @@ const ConvexHullCollider = /*#__PURE__*/React.forwardRef((props, ref) => {
     ref: ref
   }));
 });
+CuboidCollider.displayName = "CuboidCollider";
+RoundCuboidCollider.displayName = "RoundCuboidCollider";
+BallCollider.displayName = "BallCollider";
+CapsuleCollider.displayName = "CapsuleCollider";
+HeightfieldCollider.displayName = "HeightfieldCollider";
+TrimeshCollider.displayName = "TrimeshCollider";
+ConeCollider.displayName = "ConeCollider";
+CylinderCollider.displayName = "CylinderCollider";
+ConvexHullCollider.displayName = "ConvexHullCollider";
 
 const _excluded$1 = ["children", "type", "position", "rotation", "scale", "quaternion"];
 const RigidBodyContext = /*#__PURE__*/createContext(undefined);
@@ -1322,6 +1489,7 @@ const RigidBody = /*#__PURE__*/memo( /*#__PURE__*/forwardRef((props, ref) => {
     key: index
   }, colliderProps)))));
 }));
+RigidBody.displayName = "RigidBody";
 
 const MeshCollider = props => {
   const {
@@ -1352,26 +1520,96 @@ const MeshCollider = props => {
     key: index
   }, colliderProps))));
 };
+MeshCollider.displayName = "MeshCollider";
+
+function mapsEqual(map1, map2) {
+  var testVal;
+
+  if (map1.size !== map2.size) {
+    return false;
+  }
+
+  for (var [key, val] of map1) {
+    testVal = map2.get(key);
+
+    if (testVal !== val || testVal === undefined && !map2.has(key)) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+const AttractorHelper = props => {
+  const {
+    scene
+  } = useThree();
+  const ref = useRef(null);
+  const normalsHelper = useRef();
+  const color = props.strength > 0 ? 0x0000ff : 0xff0000;
+  useEffect(() => {
+    if (ref.current) {
+      normalsHelper.current = new VertexNormalsHelper(ref.current, props.range, color);
+      normalsHelper.current.frustumCulled = false;
+      scene.add(normalsHelper.current);
+    }
+
+    return () => {
+      if (normalsHelper.current) {
+        scene.remove(normalsHelper.current);
+      }
+    };
+  }, [props]);
+  useFrame(() => {
+    if (ref.current) {
+      var _normalsHelper$curren;
+
+      const worldPosition = props.object.getWorldPosition(_vector3);
+      ref.current.position.copy(worldPosition);
+      (_normalsHelper$curren = normalsHelper.current) === null || _normalsHelper$curren === void 0 ? void 0 : _normalsHelper$curren.update();
+    }
+  });
+  return /*#__PURE__*/React.createElement("mesh", {
+    ref: ref,
+    position: props.object.position,
+    frustumCulled: false
+  }, /*#__PURE__*/React.createElement("sphereGeometry", {
+    args: [0.2, 6, 6]
+  }), /*#__PURE__*/React.createElement("meshBasicMaterial", {
+    color: color,
+    wireframe: true
+  }));
+};
 
 const Debug = () => {
   const {
-    world
+    world,
+    attractorStates
   } = useRapier();
   const ref = useRef(null);
+  const [attractors, setAttractors] = useState([]);
+  const currMap = useRef(new Map());
   useFrame(() => {
     const mesh = ref.current;
     if (!mesh) return;
     const buffers = world.debugRender();
     mesh.geometry.setAttribute("position", new BufferAttribute(buffers.vertices, 3));
-    mesh.geometry.setAttribute("color", new BufferAttribute(buffers.colors, 4));
+    mesh.geometry.setAttribute("color", new BufferAttribute(buffers.colors, 4)); // Update attractors
+
+    if (!mapsEqual(currMap.current, attractorStates)) {
+      setAttractors([...attractorStates.values()]);
+      currMap.current = new Map(attractorStates);
+    }
   });
-  return /*#__PURE__*/React.createElement("lineSegments", {
+  return /*#__PURE__*/React.createElement("group", null, /*#__PURE__*/React.createElement("lineSegments", {
     ref: ref,
     frustumCulled: false
   }, /*#__PURE__*/React.createElement("lineBasicMaterial", {
     color: 0xffffff,
     vertexColors: true
-  }), /*#__PURE__*/React.createElement("bufferGeometry", null));
+  }), /*#__PURE__*/React.createElement("bufferGeometry", null)), attractors.map((attractor, i) => /*#__PURE__*/React.createElement(AttractorHelper, _extends({
+    key: attractor.object.uuid
+  }, attractor))));
 };
 
 const _excluded = ["positions", "rotations", "children"];
@@ -1484,6 +1722,7 @@ const InstancedRigidBodies = /*#__PURE__*/forwardRef((props, ref) => {
     key: index
   }, colliderProps)))));
 });
+InstancedRigidBodies.displayName = "InstancedRigidBodies";
 
 /**
  * Calculates an InteractionGroup bitmask for use in the `collisionGroups` or `solverGroups`
@@ -1521,4 +1760,4 @@ const interactionGroups = (memberships, filters) => (bitmask(memberships) << 16)
 
 const bitmask = groups => [groups].flat().reduce((acc, layer) => acc | 1 << layer, 0);
 
-export { AnyCollider, BallCollider, CapsuleCollider, ConeCollider, ConvexHullCollider, CuboidCollider, CylinderCollider, Debug, HeightfieldCollider, InstancedRigidBodies, MeshCollider, Physics, RigidBody, RoundCuboidCollider, TrimeshCollider, interactionGroups, useChildColliderProps, useFixedJoint, useImpulseJoint, usePrismaticJoint, useRapier, useRevoluteJoint, useRigidBody, useSphericalJoint };
+export { AnyCollider, Attractor, BallCollider, CapsuleCollider, ConeCollider, ConvexHullCollider, CuboidCollider, CylinderCollider, Debug, HeightfieldCollider, InstancedRigidBodies, MeshCollider, Physics, RigidBody, RoundCuboidCollider, TrimeshCollider, interactionGroups, useChildColliderProps, useFixedJoint, useImpulseJoint, usePrismaticJoint, useRapier, useRevoluteJoint, useRigidBody, useSphericalJoint };