@react-three/rapier 0.6.9 → 0.7.0

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

@@ -1,26 +1,25 @@
-import { ColliderDesc, ActiveEvents, RigidBodyDesc, CoefficientCombineRule, EventQueue, ShapeType } from '@dimforge/rapier3d-compat';
+import { EventQueue, RigidBodyDesc, ColliderDesc, ActiveEvents, ShapeType } from '@dimforge/rapier3d-compat';
 export { CoefficientCombineRule, Collider as RapierCollider, RigidBody as RapierRigidBody } from '@dimforge/rapier3d-compat';
-import React, { useState, useEffect, useRef, useMemo, createContext, useContext, forwardRef, useImperativeHandle, memo, useLayoutEffect } from 'react';
+import React, { useState, useEffect, useRef, useMemo, createContext, useContext, memo, forwardRef, useImperativeHandle, useLayoutEffect } from 'react';
 import { useAsset } from 'use-asset';
 import { useFrame } from '@react-three/fiber';
 import { Quaternion, Euler, Vector3, Object3D, Matrix4, InstancedMesh, MeshBasicMaterial, Color, PlaneGeometry, ConeBufferGeometry, CapsuleBufferGeometry, CylinderBufferGeometry, BufferGeometry, BufferAttribute, SphereBufferGeometry, BoxBufferGeometry, DynamicDrawUsage } from 'three';
-import { mergeVertices } from 'three/examples/jsm/utils/BufferGeometryUtils';
 import { clamp } from 'three/src/math/MathUtils';
-import { RoundedBoxGeometry } from 'three-stdlib';
+import { mergeVertices, RoundedBoxGeometry } from 'three-stdlib';
 
 const _quaternion = new Quaternion();
-const _euler = new Euler();
+new Euler();
 const _vector3 = new Vector3();
-new Object3D();
+const _object3d = new Object3D();
 const _matrix4 = new Matrix4();
+const _position = new Vector3();
+const _rotation = new Quaternion();
+const _scale = new Vector3();
 
 const vectorArrayToVector3 = arr => {
   const [x, y, z] = arr;
   return new Vector3(x, y, z);
 };
-const vector3ToQuaternion = v => {
-  return _quaternion.setFromEuler(_euler.setFromVector3(v));
-};
 const rapierVector3ToVector3 = ({
   x,
   y,
@@ -39,216 +38,6 @@ const rigidBodyTypeMap = {
   kinematicVelocity: 3
 };
 const rigidBodyTypeFromString = type => rigidBodyTypeMap[type];
-const decomposeMatrix4 = m => {
-  const position = new Vector3();
-  const rotation = new Quaternion();
-  const scale = new Vector3();
-  m.decompose(position, rotation, scale);
-  return {
-    position,
-    rotation,
-    scale
-  };
-};
-const scaleColliderArgs = (shape, args, scale) => {
-  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
-
-
-  if (shape === "trimesh" || shape === "convexHull") {
-    newArgs[0] = scaleVertices(newArgs[0], scale);
-    return newArgs;
-  } // 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 applyColliderOptions = (collider, options) => {
-  if (options.collisionGroups !== undefined) collider.setCollisionGroups(options.collisionGroups);
-  if (options.solverGroups !== undefined) collider.setSolverGroups(options.solverGroups);
-};
-
-const createColliderFromOptions = ({
-  options,
-  world,
-  rigidBody,
-  scale,
-  hasCollisionEvents
-}) => {
-  var _options$shape, _options$args, _options$restitution, _options$restitutionC, _options$friction, _options$frictionComb;
-
-  const mass = (options === null || options === void 0 ? void 0 : options.mass) || 1;
-  const colliderShape = (_options$shape = options === null || options === void 0 ? void 0 : options.shape) !== null && _options$shape !== void 0 ? _options$shape : "cuboid";
-  const colliderArgs = (_options$args = options === null || options === void 0 ? void 0 : options.args) !== null && _options$args !== void 0 ? _options$args : [];
-  const [cmx, cmy, cmz] = (options === null || options === void 0 ? void 0 : options.centerOfMass) || [0, 0, 0];
-  const [pix, piy, piz] = (options === null || options === void 0 ? void 0 : options.principalAngularInertia) || [mass * 0.2, mass * 0.2, mass * 0.2];
-  const [x, y, z] = (options === null || options === void 0 ? void 0 : options.position) || [0, 0, 0];
-  const [rx, ry, rz] = (options === null || options === void 0 ? void 0 : options.rotation) || [0, 0, 0];
-  const qRotation = vector3ToQuaternion(new Vector3(rx, ry, rz)); // @ts-ignore
-
-  const scaledArgs = scaleColliderArgs(options.shape, colliderArgs, scale);
-  let colliderDesc = ColliderDesc[colliderShape]( // @ts-ignore
-  ...scaledArgs).setTranslation(x * scale.x, y * scale.y, z * scale.z).setRotation({
-    x: qRotation.x,
-    y: qRotation.y,
-    z: qRotation.z,
-    w: qRotation.w
-  }).setRestitution((_options$restitution = options === null || options === void 0 ? void 0 : options.restitution) !== null && _options$restitution !== void 0 ? _options$restitution : 0).setRestitutionCombineRule((_options$restitutionC = options === null || options === void 0 ? void 0 : options.restitutionCombineRule) !== null && _options$restitutionC !== void 0 ? _options$restitutionC : CoefficientCombineRule.Average).setFriction((_options$friction = options === null || options === void 0 ? void 0 : options.friction) !== null && _options$friction !== void 0 ? _options$friction : 0.7).setFrictionCombineRule((_options$frictionComb = options === null || options === void 0 ? void 0 : options.frictionCombineRule) !== null && _options$frictionComb !== void 0 ? _options$frictionComb : CoefficientCombineRule.Average);
-
-  if (hasCollisionEvents) {
-    colliderDesc = colliderDesc.setActiveEvents(ActiveEvents.COLLISION_EVENTS);
-  } // If any of the mass properties are specified, add mass properties
-
-
-  const qMassRot = vector3ToQuaternion(new Vector3(0, 0, 0));
-
-  if (options !== null && options !== void 0 && options.mass || options !== null && options !== void 0 && options.centerOfMass || options !== null && options !== void 0 && options.principalAngularInertia) {
-    colliderDesc.setDensity(0);
-    colliderDesc.setMassProperties(mass, {
-      x: cmx,
-      y: cmy,
-      z: cmz
-    }, {
-      x: pix,
-      y: piy,
-      z: piz
-    }, {
-      x: qMassRot.x,
-      y: qMassRot.y,
-      z: qMassRot.z,
-      w: qMassRot.w
-    });
-  }
-
-  const collider = world.createCollider(colliderDesc, rigidBody);
-  applyColliderOptions(collider, options);
-  return collider;
-};
-
-const isChildOfMeshCollider = child => {
-  let flag = false;
-  child.traverseAncestors(a => {
-    if (a.userData.r3RapierType === "MeshCollider") flag = true;
-  });
-  return flag;
-};
-
-const createCollidersFromChildren = ({
-  object,
-  rigidBody,
-  options,
-  world,
-  ignoreMeshColliders: _ignoreMeshColliders = true
-}) => {
-  const hasCollisionEvents = !!(options.onCollisionEnter || options.onCollisionExit);
-  const colliders = [];
-  object.traverseVisible(child => {
-    if ("isMesh" in child) {
-      if (_ignoreMeshColliders && isChildOfMeshCollider(child)) return;
-      const {
-        geometry
-      } = child;
-      const {
-        x,
-        y,
-        z
-      } = child.position;
-      const {
-        x: rx,
-        y: ry,
-        z: rz,
-        w: rw
-      } = new Quaternion().setFromEuler(child.rotation);
-      const scale = child.getWorldScale(new Vector3()); // We translate the colliders based on the parent's world scale
-
-      const parentWorldScale = child.parent.getWorldScale(new Vector3());
-      const desc = colliderDescFromGeometry(geometry, options.colliders, scale, hasCollisionEvents);
-      const offset = new Vector3(0, 0, 0);
-
-      if (options.colliders === "cuboid") {
-        var _geometry$boundingBox;
-
-        geometry.computeBoundingBox();
-        (_geometry$boundingBox = geometry.boundingBox) === null || _geometry$boundingBox === void 0 ? void 0 : _geometry$boundingBox.getCenter(offset);
-      }
-
-      if (options.colliders === "ball") {
-        geometry.computeBoundingSphere();
-        offset.copy(geometry.boundingSphere.center);
-      }
-
-      if (Number.isFinite(options.friction)) desc.setFriction(options.friction);
-      if (Number.isFinite(options.restitution)) desc.setRestitution(options.restitution);
-      desc.setTranslation((x + offset.x) * parentWorldScale.x, (y + offset.y) * parentWorldScale.y, (z + offset.z) * parentWorldScale.z).setRotation({
-        x: rx,
-        y: ry,
-        z: rz,
-        w: rw
-      });
-      const actualRigidBody = rigidBody ? world.getRigidBody(rigidBody.handle) : undefined;
-      const collider = world.createCollider(desc, actualRigidBody);
-      applyColliderOptions(collider, options);
-      colliders.push(collider);
-    }
-  });
-  return colliders;
-};
-const colliderDescFromGeometry = (geometry, colliders, scale, hasCollisionEvents) => {
-  let desc;
-
-  switch (colliders) {
-    case "cuboid":
-      {
-        geometry.computeBoundingBox();
-        const {
-          boundingBox
-        } = geometry;
-        const size = boundingBox.getSize(new Vector3());
-        desc = ColliderDesc.cuboid(size.x / 2 * scale.x, size.y / 2 * scale.y, size.z / 2 * scale.z);
-      }
-      break;
-
-    case "ball":
-      {
-        geometry.computeBoundingSphere();
-        const {
-          boundingSphere
-        } = geometry;
-        const radius = boundingSphere.radius * scale.x;
-        desc = ColliderDesc.ball(radius);
-      }
-      break;
-
-    case "trimesh":
-      {
-        var _g$index;
-
-        const clonedGeometry = geometry.index ? geometry.clone() : mergeVertices(geometry);
-        const g = clonedGeometry.scale(scale.x, scale.y, scale.z);
-        desc = ColliderDesc.trimesh(g.attributes.position.array, (_g$index = g.index) === null || _g$index === void 0 ? void 0 : _g$index.array);
-      }
-      break;
-
-    case "hull":
-      {
-        const g = geometry.clone().scale(scale.x, scale.y, scale.z);
-        desc = ColliderDesc.convexHull(g.attributes.position.array);
-      }
-      break;
-  }
-
-  if (hasCollisionEvents) desc.setActiveEvents(ActiveEvents.COLLISION_EVENTS);
-  return desc;
-};
 const scaleVertices = (vertices, scale) => {
   const scaledVerts = Array.from(vertices);
 
@@ -260,28 +49,6 @@ const scaleVertices = (vertices, scale) => {
 
   return scaledVerts;
 };
-const rigidBodyDescFromOptions = options => {
-  var _options$linearVeloci, _options$angularVeloc, _options$angularDampi, _options$linearDampin, _options$gravityScale, _options$canSleep, _options$ccd, _options$enabledRotat, _options$enabledTrans;
-
-  const type = rigidBodyTypeFromString((options === null || options === void 0 ? void 0 : options.type) || "dynamic");
-  const [lvx, lvy, lvz] = (_options$linearVeloci = options === null || options === void 0 ? void 0 : options.linearVelocity) !== null && _options$linearVeloci !== void 0 ? _options$linearVeloci : [0, 0, 0];
-  const [avx, avy, avz] = (_options$angularVeloc = options === null || options === void 0 ? void 0 : options.angularVelocity) !== null && _options$angularVeloc !== void 0 ? _options$angularVeloc : [0, 0, 0];
-  const angularDamping = (_options$angularDampi = options === null || options === void 0 ? void 0 : options.angularDamping) !== null && _options$angularDampi !== void 0 ? _options$angularDampi : 0;
-  const linearDamping = (_options$linearDampin = options === null || options === void 0 ? void 0 : options.linearDamping) !== null && _options$linearDampin !== void 0 ? _options$linearDampin : 0;
-  const gravityScale = (_options$gravityScale = options === null || options === void 0 ? void 0 : options.gravityScale) !== null && _options$gravityScale !== void 0 ? _options$gravityScale : 1;
-  const canSleep = (_options$canSleep = options === null || options === void 0 ? void 0 : options.canSleep) !== null && _options$canSleep !== void 0 ? _options$canSleep : true;
-  const ccdEnabled = (_options$ccd = options === null || options === void 0 ? void 0 : options.ccd) !== null && _options$ccd !== void 0 ? _options$ccd : false;
-  const [erx, ery, erz] = (_options$enabledRotat = options === null || options === void 0 ? void 0 : options.enabledRotations) !== null && _options$enabledRotat !== void 0 ? _options$enabledRotat : [true, true, true];
-  const [etx, ety, etz] = (_options$enabledTrans = options === null || options === void 0 ? void 0 : options.enabledTranslations) !== null && _options$enabledTrans !== void 0 ? _options$enabledTrans : [true, true, true];
-  const desc = new RigidBodyDesc(type).setLinvel(lvx, lvy, lvz).setAngvel({
-    x: avx,
-    y: avy,
-    z: avz
-  }).setLinearDamping(linearDamping).setAngularDamping(angularDamping).setGravityScale(gravityScale).setCanSleep(canSleep).setCcdEnabled(ccdEnabled).enabledRotations(erx, ery, erz).enabledTranslations(etx, ety, etz);
-  if (options.lockRotations) desc.lockRotations();
-  if (options.lockTranslations) desc.lockTranslations();
-  return desc;
-};
 
 const createRigidBodyApi = ref => {
   return {
@@ -433,7 +200,6 @@ const Physics = ({
   gravity: _gravity = [0, -9.81, 0],
   children,
   timeStep: _timeStep = 1 / 60,
-  maxSubSteps: _maxSubSteps = 10,
   paused: _paused = false,
   updatePriority
 }) => {
@@ -452,6 +218,7 @@ const Physics = ({
     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
@@ -473,11 +240,9 @@ const Physics = ({
     }
   }, [_gravity]);
   const [steppingState] = useState({
-    time: 0,
-    lastTime: 0,
     accumulator: 0
   });
-  useFrame((_, delta) => {
+  useFrame((_, dt) => {
     const world = worldRef.current;
     if (!world) return;
     world.timestep = _timeStep;
@@ -485,33 +250,19 @@ const Physics = ({
      * Fixed timeStep simulation progression
      * @see https://gafferongames.com/post/fix_your_timestep/
     */
+    // don't step time forwards if paused
+    // Increase accumulator
 
-    let previousTranslations = {}; // don't step time forwards if paused
-
-    const nowTime = steppingState.time += _paused ? 0 : clamp(delta, 0, 1) * 1000;
-    const timeStepMs = _timeStep * 1000;
-    const timeSinceLast = nowTime - steppingState.lastTime;
-    steppingState.lastTime = nowTime;
-    steppingState.accumulator += timeSinceLast;
+    steppingState.accumulator += _paused ? 0 : clamp(dt, 0, 0.2);
 
     if (!_paused) {
-      let subSteps = 0;
-
-      while (steppingState.accumulator >= timeStepMs && subSteps < _maxSubSteps) {
-        // Collect previous state
-        world.bodies.forEach(b => {
-          previousTranslations[b.handle] = {
-            rotation: rapierQuaternionToQuaternion(b.rotation()).normalize(),
-            translation: rapierVector3ToVector3(b.translation())
-          };
-        });
+      while (steppingState.accumulator >= _timeStep) {
         world.step(eventQueue);
-        subSteps++;
-        steppingState.accumulator -= timeStepMs;
+        steppingState.accumulator -= _timeStep;
       }
     }
 
-    const interpolationAlpha = steppingState.accumulator % timeStepMs / timeStepMs; // Update meshes
+    const interpolationAlpha = steppingState.accumulator % _timeStep / _timeStep; // Update meshes
 
     rigidBodyStates.forEach((state, handle) => {
       const rigidBody = world.getRigidBody(handle);
@@ -537,86 +288,151 @@ const Physics = ({
         return;
       }
 
-      let oldState = previousTranslations[rigidBody.handle];
-      let newTranslation = rigidBody.translation();
-      let newRotation = rapierQuaternionToQuaternion(rigidBody.rotation());
-      let interpolatedTranslation = oldState ? oldState.translation.lerp(newTranslation, 1) : newTranslation;
-      let interpolatedRotation = oldState ? oldState.rotation.slerp(newRotation, interpolationAlpha) : newRotation;
-      state.setMatrix(_matrix4.compose(interpolatedTranslation, interpolatedRotation, state.worldScale).premultiply(state.invertedMatrixWorld));
+      let t = rigidBody.translation();
+      let r = rigidBody.rotation(); // Get new position
 
-      if (state.mesh instanceof InstancedMesh) {
-        state.mesh.instanceMatrix.needsUpdate = true;
-      }
-    }); // Collision events
+      _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 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;
 
       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;
+      const rigidBodyHandle2 = (_collider2$parent = collider2.parent()) === null || _collider2$parent === void 0 ? void 0 : _collider2$parent.handle; // Collision Events
 
-      if (!collider1 || !collider2 || rigidBodyHandle1 === undefined || rigidBodyHandle2 === undefined) {
+      if (!collider1 || !collider2) {
         return;
       }
 
-      const rigidBody1 = world.getRigidBody(rigidBodyHandle1);
-      const rigidBody2 = world.getRigidBody(rigidBodyHandle2);
-      const rigidBody1Events = rigidBodyEvents.get(rigidBodyHandle1);
-      const rigidBoyd2Events = rigidBodyEvents.get(rigidBodyHandle2);
       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;
 
       if (started) {
         world.contactPair(collider1, collider2, (manifold, flipped) => {
-          var _rigidBody1Events$onC, _rigidBoyd2Events$onC, _collider1Events$onCo, _collider2Events$onCo;
+          var _rigidBody1Events$onC, _rigidBody2Events$onC, _collider1Events$onCo, _collider2Events$onCo;
 
           /* RigidBody events */
           rigidBody1Events === null || rigidBody1Events === void 0 ? void 0 : (_rigidBody1Events$onC = rigidBody1Events.onCollisionEnter) === null || _rigidBody1Events$onC === void 0 ? void 0 : _rigidBody1Events$onC.call(rigidBody1Events, {
-            target: rigidBody2,
+            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
           });
-          rigidBoyd2Events === null || rigidBoyd2Events === void 0 ? void 0 : (_rigidBoyd2Events$onC = rigidBoyd2Events.onCollisionEnter) === null || _rigidBoyd2Events$onC === void 0 ? void 0 : _rigidBoyd2Events$onC.call(rigidBoyd2Events, {
-            target: rigidBody1,
+          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, {
-            target: rigidBody2,
+            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, {
-            target: rigidBody1,
+            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, _rigidBoyd2Events$onC2, _collider1Events$onCo2, _collider2Events$onCo2;
+        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, {
-          target: rigidBody2,
+          rigidBody: rigidBody2,
           collider: collider2
         });
-        rigidBoyd2Events === null || rigidBoyd2Events === void 0 ? void 0 : (_rigidBoyd2Events$onC2 = rigidBoyd2Events.onCollisionExit) === null || _rigidBoyd2Events$onC2 === void 0 ? void 0 : _rigidBoyd2Events$onC2.call(rigidBoyd2Events, {
-          target: rigidBody1,
+        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, {
-          target: rigidBody2,
+          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, {
-          target: rigidBody1,
+          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
         });
       }
@@ -631,6 +447,7 @@ const Physics = ({
       gravity: _gravity
     },
     rigidBodyStates,
+    colliderStates,
     rigidBodyEvents,
     colliderEvents,
     isPaused
@@ -733,150 +550,449 @@ function _objectSpread2(target) {
   return target;
 }
 
-const useRapier = () => {
-  return useContext(RapierContext);
+const rigidBodyDescFromOptions = options => {
+  const type = rigidBodyTypeFromString((options === null || options === void 0 ? void 0 : options.type) || "dynamic");
+  const desc = new RigidBodyDesc(type);
+  return desc;
 };
-const useRigidBody = (options = {}) => {
-  const {
-    world,
-    rigidBodyStates,
-    physicsOptions,
-    rigidBodyEvents
-  } = useRapier();
-  const ref = useRef(); // 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);
-    }
-
-    return rigidBodyRef.current;
-  }); // Setup
-
-  useEffect(() => {
-    var _ref$current$parent, _ref, _options$colliders;
+const createRigidBodyState = ({
+  rigidBody,
+  object,
+  setMatrix,
+  getMatrix,
+  worldScale
+}) => {
+  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
+  };
+};
+const mutableRigidBodyOptions = {
+  gravityScale: (rb, value) => {
+    rb.setGravityScale(value, true);
+  },
+  linearDamping: (rb, value) => {
+    rb.setLinearDamping(value);
+  },
+  angularDamping: (rb, value) => {
+    rb.setAngularDamping(value);
+  },
+  enabledRotations: (rb, [x, y, z]) => {
+    rb.setEnabledRotations(x, y, z, true);
+  },
+  enabledTranslations: (rb, [x, y, z]) => {
+    rb.setEnabledTranslations(x, y, z, 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);
+  }
+};
+const mutableRigidBodyOptionKeys = Object.keys(mutableRigidBodyOptions);
+const setRigidBodyOptions = (rigidBody, options, states) => {
+  if (!rigidBody) {
+    return;
+  }
 
-    const rigidBody = getRigidBodyRef.current();
-    rigidBodyRef.current = rigidBody;
+  const state = states.get(rigidBody.handle);
 
-    if (!ref.current) {
-      ref.current = new Object3D();
-    } // isSleeping used for onSleep and onWake events
+  if (state) {
+    state.object.updateWorldMatrix(true, false);
 
+    _matrix4.copy(state.object.matrixWorld).decompose(_position, _rotation, _scale);
 
-    ref.current.userData.isSleeping = false; // Get intitial world transforms
-
-    const worldPosition = ref.current.getWorldPosition(new Vector3());
-    const worldRotation = ref.current.getWorldQuaternion(new Quaternion());
-    const scale = ((_ref$current$parent = ref.current.parent) === null || _ref$current$parent === void 0 ? void 0 : _ref$current$parent.getWorldScale(new Vector3())) || {
-      x: 1,
-      y: 1,
-      z: 1
-    }; // Transforms from options
-
-    const [x, y, z] = (options === null || options === void 0 ? void 0 : options.position) || [0, 0, 0];
-    const [rx, ry, rz] = (options === null || options === void 0 ? void 0 : options.rotation) || [0, 0, 0]; // Set initial transforms based on world transforms
-
-    rigidBody.setTranslation({
-      x: worldPosition.x + x * scale.x,
-      y: worldPosition.y + y * scale.y,
-      z: worldPosition.z + z * scale.z
-    }, false);
-    const rotation = vector3ToQuaternion(new Vector3(rx, ry, rz)).multiply(worldRotation);
-    rigidBody.setRotation({
-      x: rotation.x,
-      y: rotation.y,
-      z: rotation.z,
-      w: rotation.w
-    }, false);
-    rigidBody.resetForces(false);
-    rigidBody.resetTorques(false);
-    const colliderSetting = (_ref = (_options$colliders = options === null || options === void 0 ? void 0 : options.colliders) !== null && _options$colliders !== void 0 ? _options$colliders : physicsOptions.colliders) !== null && _ref !== void 0 ? _ref : false;
-    const autoColliders = colliderSetting !== false ? createCollidersFromChildren({
-      object: ref.current,
-      rigidBody,
-      options: _objectSpread2(_objectSpread2({}, options), {}, {
-        colliders: colliderSetting
-      }),
-      world,
-      ignoreMeshColliders: true
-    }) : [];
-    rigidBodyStates.set(rigidBody.handle, {
-      mesh: ref.current,
-      invertedMatrixWorld: ref.current.parent.matrixWorld.clone().invert(),
-      isSleeping: false,
-      worldScale: ref.current.getWorldScale(_vector3).clone(),
-      setMatrix: mat => ref.current.matrix.copy(mat),
-      getMatrix: () => ref.current.matrix
+    rigidBody.setTranslation(_position, false);
+    rigidBody.setRotation(_rotation, false);
+    mutableRigidBodyOptionKeys.forEach(key => {
+      if (key in options) {
+        mutableRigidBodyOptions[key](rigidBody, options[key]);
+      }
     });
-    ref.current.matrixAutoUpdate = false;
-    return () => {
-      world.removeRigidBody(rigidBody);
-      autoColliders.forEach(collider => world.removeCollider(collider));
-      rigidBodyRef.current = undefined;
-      rigidBodyStates.delete(rigidBody.handle);
-    };
-  }, []); // Events
-
+  }
+};
+const useUpdateRigidBodyOptions = (rigidBodyRef, props, states) => {
   useEffect(() => {
-    const rigidBody = getRigidBodyRef.current();
-    rigidBodyEvents.set(rigidBody.handle, {
-      onCollisionEnter: options === null || options === void 0 ? void 0 : options.onCollisionEnter,
-      onCollisionExit: options === null || options === void 0 ? void 0 : options.onCollisionExit,
-      onSleep: options === null || options === void 0 ? void 0 : options.onSleep,
-      onWake: options === null || options === void 0 ? void 0 : options.onWake
-    });
-    return () => {
-      rigidBodyEvents.delete(rigidBody.handle);
-    };
-  }, [options.onCollisionEnter, options.onCollisionExit]);
-  const api = useMemo(() => createRigidBodyApi(getRigidBodyRef), []);
-  return [ref, api];
-}; // Joints
-
-const useImpulseJoint = (body1, body2, params) => {
+    setRigidBodyOptions(rigidBodyRef.current, props, states);
+  }, [props]);
+};
+const useRigidBodyEvents = (rigidBodyRef, props, events) => {
   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;
-      }
-    }
-
-    return jointRef.current;
-  });
+    onWake,
+    onSleep,
+    onCollisionEnter,
+    onCollisionExit,
+    onIntersectionEnter,
+    onIntersectionExit
+  } = props;
   useEffect(() => {
-    const joint = getJointRef.current();
+    events.set(rigidBodyRef.current.handle, {
+      onWake,
+      onSleep,
+      onCollisionEnter,
+      onCollisionExit,
+      onIntersectionEnter,
+      onIntersectionExit
+    });
     return () => {
-      if (joint) {
-        world.removeImpulseJoint(joint);
-        jointRef.current = undefined;
-      }
+      events.delete(rigidBodyRef.current.handle);
     };
-  }, []);
-  const api = useMemo(() => createJointApi(getJointRef), []);
-  return api;
+  }, [onWake, onSleep, onCollisionEnter, onCollisionExit]);
 };
-/**
- *
- * 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 scaleColliderArgs = (shape, args, scale) => {
+  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
+
+
+  if (shape === "trimesh" || shape === "convexHull") {
+    newArgs[0] = scaleVertices(newArgs[0], scale);
+    return newArgs;
+  } // 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, rigidBody) => {
+  const scaledArgs = scaleColliderArgs(options.shape, options.args, scale); // @ts-ignore
+
+  const desc = ColliderDesc[options.shape](...scaledArgs);
+  return world.createCollider(desc, rigidBody);
+};
+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);
+  },
+  restitution: (collider, value) => {
+    collider.setRestitution(value);
+  },
+  density: (collider, value) => {
+    collider.setDensity(value);
+  },
+  mass: (collider, value) => {
+    collider.setMass(value);
+  }
+};
+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);
+
+    _matrix4.copy(state.object.matrixWorld).premultiply(state.worldParent.matrixWorld.clone().invert()).decompose(_position, _rotation, _scale);
+
+    collider.setTranslationWrtParent({
+      x: _position.x * parentWorldScale.x,
+      y: _position.y * parentWorldScale.y,
+      z: _position.z * parentWorldScale.z
+    });
+    collider.setRotationWrtParent(_rotation);
+    mutableColliderOptionKeys.forEach(key => {
+      if (key in options) {
+        mutableColliderOptions[key](collider, options[key]);
+      }
+    });
+  }
+};
+const useUpdateColliderOptions = (collidersRef, props, states) => {
+  useEffect(() => {
+    collidersRef.current.forEach(collider => {
+      setColliderOptions(collider, props, states);
+    });
+  }, [props]);
+};
+
+const isChildOfMeshCollider = child => {
+  let flag = false;
+  child.traverseAncestors(a => {
+    if (a.userData.r3RapierType === "MeshCollider") flag = true;
+  });
+  return flag;
+};
+
+const createColliderState = (collider, object, rigidBodyObject) => {
+  return {
+    collider,
+    worldParent: rigidBodyObject || object.parent,
+    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();
+  object.traverseVisible(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 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 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())
+        };
+      }
+
+    case "ball":
+      {
+        geometry.computeBoundingSphere();
+        const {
+          boundingSphere
+        } = geometry;
+        const radius = boundingSphere.radius;
+        return {
+          args: [radius],
+          offset: boundingSphere.center
+        };
+      }
+
+    case "trimesh":
+      {
+        var _clonedGeometry$index;
+
+        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()
+        };
+      }
+
+    case "hull":
+      {
+        const g = geometry.clone();
+        return {
+          args: [g.attributes.position.array],
+          offset: new Vector3()
+        };
+      }
+  }
+
+  return {
+    args: [],
+    offset: new Vector3()
+  };
+};
+const useColliderEvents = (collidersRef, props, events) => {
+  const {
+    onCollisionEnter,
+    onCollisionExit,
+    onIntersectionEnter,
+    onIntersectionExit
+  } = props;
+  useEffect(() => {
+    var _collidersRef$current;
+
+    (_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
+      });
+    });
+    return () => {
+      var _collidersRef$current2;
+
+      (_collidersRef$current2 = collidersRef.current) === null || _collidersRef$current2 === void 0 ? void 0 : _collidersRef$current2.forEach(collider => events.delete(collider.handle));
+    };
+  }, [onCollisionEnter, onCollisionExit]);
+};
+
+const useRapier = () => {
+  return useContext(RapierContext);
+};
+const useChildColliderProps = (ref, options, ignoreMeshColliders = true) => {
+  const [colliderProps, setColliderProps] = useState([]);
+  useEffect(() => {
+    const object = ref.current;
+
+    if (object && options.colliders !== false) {
+      setColliderProps(createColliderPropsFromChildren({
+        object: ref.current,
+        options,
+        ignoreMeshColliders
+      }));
+    }
+  }, [options]);
+  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);
+    }
+
+    return rigidBodyRef.current;
+  }); // Setup
+
+  useEffect(() => {
+    const rigidBody = getRigidBodyRef.current();
+    rigidBodyRef.current = rigidBody;
+
+    if (!ref.current) {
+      ref.current = new Object3D();
+    } // isSleeping used for onSleep and onWake events
+
+
+    ref.current.userData.isSleeping = false;
+    rigidBodyStates.set(rigidBody.handle, createRigidBodyState({
+      rigidBody,
+      object: ref.current
+    }));
+    return () => {
+      world.removeRigidBody(rigidBody);
+      rigidBodyStates.delete(rigidBody.handle);
+    };
+  }, []);
+  useUpdateRigidBodyOptions(rigidBodyRef, mergedOptions, rigidBodyStates);
+  useRigidBodyEvents(rigidBodyRef, mergedOptions, rigidBodyEvents);
+  const api = useMemo(() => createRigidBodyApi(getRigidBodyRef), []);
+  return [ref, api, childColliderProps];
+}; // Joints
+
+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;
+      }
+    }
+
+    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();
@@ -924,80 +1040,173 @@ const usePrismaticJoint = (body1, body2, [body1Anchor, body2Anchor, axis]) => {
   return useImpulseJoint(body1, body2, rapier.JointData.prismatic(vectorArrayToVector3(body1Anchor), vectorArrayToVector3(body2Anchor), vectorArrayToVector3(axis)));
 };
 
-const _excluded$1 = ["children"],
-      _excluded2 = ["type", "position", "rotation"];
-const RigidBodyContext = /*#__PURE__*/createContext(undefined);
-const useRigidBodyContext = () => useContext(RigidBodyContext); // RigidBody
+// Colliders
+const AnyCollider = /*#__PURE__*/memo(props => {
+  const {
+    children,
+    position,
+    rotation,
+    quaternion,
+    scale
+  } = props;
+  const {
+    world,
+    colliderEvents,
+    colliderStates
+  } = useRapier();
+  const rigidBodyContext = useRigidBodyContext();
+  const ref = useRef(null);
+  const collidersRef = useRef([]);
+  useEffect(() => {
+    const object = ref.current;
+    const worldScale = object.getWorldScale(new Vector3());
+    const colliders = []; // If this is an InstancedRigidBody api
 
-const RigidBody = /*#__PURE__*/forwardRef((_ref, ref) => {
-  let {
-    children
-  } = _ref,
-      props = _objectWithoutProperties(_ref, _excluded$1);
+    if (rigidBodyContext && "at" in rigidBodyContext.api) {
+      rigidBodyContext.api.forEach((body, index) => {
+        var _rigidBodyContext$opt, _rigidBodyContext$opt2;
+
+        let instanceScale = worldScale;
+
+        if ("scales" in rigidBodyContext.options && rigidBodyContext !== null && rigidBodyContext !== void 0 && (_rigidBodyContext$opt = rigidBodyContext.options) !== null && _rigidBodyContext$opt !== void 0 && (_rigidBodyContext$opt2 = _rigidBodyContext$opt.scales) !== null && _rigidBodyContext$opt2 !== void 0 && _rigidBodyContext$opt2[index]) {
+          instanceScale = instanceScale.clone().multiply(vectorArrayToVector3(rigidBodyContext.options.scales[index]));
+        }
 
-  const [object, api] = useRigidBody(props);
+        const collider = createColliderFromOptions(props, world, instanceScale, body.raw());
+        colliderStates.set(collider.handle, createColliderState(collider, object, rigidBodyContext === null || rigidBodyContext === void 0 ? void 0 : rigidBodyContext.ref.current));
+        colliders.push(collider);
+      });
+    } else {
+      const collider = createColliderFromOptions(props, world, worldScale, rigidBodyContext && (rigidBodyContext === null || rigidBodyContext === void 0 ? void 0 : rigidBodyContext.api).raw());
+      colliderStates.set(collider.handle, createColliderState(collider, object, rigidBodyContext === null || rigidBodyContext === void 0 ? void 0 : rigidBodyContext.ref.current));
+      colliders.push(collider);
+    }
+
+    collidersRef.current = colliders;
+    return () => {
+      colliders.forEach(collider => {
+        world.removeCollider(collider);
+      });
+    };
+  }, []);
+  useUpdateColliderOptions(collidersRef, props, colliderStates);
+  useColliderEvents(collidersRef, props, colliderEvents);
+  return /*#__PURE__*/React.createElement("object3D", {
+    position: position,
+    rotation: rotation,
+    quaternion: quaternion,
+    scale: scale,
+    ref: ref
+  }, children);
+});
+const CuboidCollider = props => {
+  return /*#__PURE__*/React.createElement(AnyCollider, _extends({}, props, {
+    shape: "cuboid"
+  }));
+};
+const RoundCuboidCollider = props => {
+  return /*#__PURE__*/React.createElement(AnyCollider, _extends({}, props, {
+    shape: "roundCuboid"
+  }));
+};
+const BallCollider = props => {
+  return /*#__PURE__*/React.createElement(AnyCollider, _extends({}, props, {
+    shape: "ball"
+  }));
+};
+const CapsuleCollider = props => {
+  return /*#__PURE__*/React.createElement(AnyCollider, _extends({}, props, {
+    shape: "capsule"
+  }));
+};
+const HeightfieldCollider = props => {
+  return /*#__PURE__*/React.createElement(AnyCollider, _extends({}, props, {
+    shape: "heightfield"
+  }));
+};
+const TrimeshCollider = props => {
+  return /*#__PURE__*/React.createElement(AnyCollider, _extends({}, props, {
+    shape: "trimesh"
+  }));
+};
+const ConeCollider = props => {
+  return /*#__PURE__*/React.createElement(AnyCollider, _extends({}, props, {
+    shape: "cone"
+  }));
+};
+const CylinderCollider = props => {
+  return /*#__PURE__*/React.createElement(AnyCollider, _extends({}, props, {
+    shape: "cylinder"
+  }));
+};
+const ConvexHullCollider = props => {
+  return /*#__PURE__*/React.createElement(AnyCollider, _extends({}, props, {
+    shape: "convexHull"
+  }));
+};
 
-  const objectProps = _objectWithoutProperties(props, _excluded2);
+const _excluded$1 = ["children", "type", "position", "rotation", "scale", "quaternion"];
+const RigidBodyContext = /*#__PURE__*/createContext(undefined);
+const useRigidBodyContext = () => useContext(RigidBodyContext);
+const RigidBody = /*#__PURE__*/forwardRef((props, ref) => {
+  const {
+    children,
+    type,
+    position,
+    rotation,
+    scale,
+    quaternion
+  } = props,
+        objectProps = _objectWithoutProperties(props, _excluded$1);
 
+  const [object, api, childColliderProps] = useRigidBody(props);
   useImperativeHandle(ref, () => api);
   return /*#__PURE__*/React.createElement(RigidBodyContext.Provider, {
     value: {
       ref: object,
       api,
-      hasCollisionEvents: !!(props.onCollisionEnter || props.onCollisionExit),
       options: props
     }
   }, /*#__PURE__*/React.createElement("object3D", _extends({
     ref: object
-  }, objectProps), children));
+  }, objectProps, {
+    position: position,
+    rotation: rotation,
+    quaternion: quaternion,
+    scale: scale
+  }), children, childColliderProps.map((colliderProps, index) => /*#__PURE__*/React.createElement(AnyCollider, _extends({
+    key: index
+  }, colliderProps)))));
 });
 
-const MeshCollider = ({
-  children,
-  type
-}) => {
+const MeshCollider = props => {
+  const {
+    children,
+    type
+  } = props;
   const {
     physicsOptions,
     world
   } = useRapier();
   const object = useRef(null);
   const {
-    api,
     options
   } = useRigidBodyContext();
-  useEffect(() => {
-    let autoColliders = [];
-
-    if (object.current) {
-      var _ref;
-
-      const colliderSetting = (_ref = type !== null && type !== void 0 ? type : physicsOptions.colliders) !== null && _ref !== void 0 ? _ref : false;
-
-      if ("raw" in api) {
-        autoColliders = createCollidersFromChildren({
-          object: object.current,
-          rigidBody: api,
-          options: _objectSpread2(_objectSpread2({}, options), {}, {
-            colliders: colliderSetting
-          }),
-          world,
-          ignoreMeshColliders: false
-        });
-      }
-    }
-
-    return () => {
-      autoColliders.forEach(collider => {
-        world.removeCollider(collider);
-      });
-    };
-  }, []);
+  const mergedOptions = useMemo(() => {
+    return _objectSpread2(_objectSpread2(_objectSpread2({}, physicsOptions), options), {}, {
+      children: undefined,
+      colliders: type
+    });
+  }, [physicsOptions, options]);
+  const childColliderProps = useChildColliderProps(object, mergedOptions, false);
   return /*#__PURE__*/React.createElement("object3D", {
     ref: object,
     userData: {
       r3RapierType: "MeshCollider"
     }
-  }, children);
+  }, children, childColliderProps.map((colliderProps, index) => /*#__PURE__*/React.createElement(AnyCollider, _extends({
+    key: index
+  }, colliderProps))));
 };
 
 const geometryFromCollider = collider => {
@@ -1174,6 +1383,7 @@ const Debug = ({
   })));
 };
 
+const _excluded = ["positions", "rotations", "children"];
 const InstancedRigidBodies = /*#__PURE__*/forwardRef((props, ref) => {
   const {
     world,
@@ -1181,6 +1391,14 @@ const InstancedRigidBodies = /*#__PURE__*/forwardRef((props, ref) => {
     physicsOptions
   } = useRapier();
   const object = useRef(null);
+
+  const {
+    positions,
+    rotations,
+    children
+  } = props,
+        options = _objectWithoutProperties(props, _excluded);
+
   const instancesRef = useRef();
   const instancesRefGetter = useRef(() => {
     if (!instancesRef.current) {
@@ -1189,235 +1407,85 @@ const InstancedRigidBodies = /*#__PURE__*/forwardRef((props, ref) => {
 
     return instancesRef.current;
   });
+  const mergedOptions = useMemo(() => {
+    return _objectSpread2(_objectSpread2({}, physicsOptions), options);
+  }, [physicsOptions, options]);
+  const childColliderProps = useChildColliderProps(object, mergedOptions);
   useLayoutEffect(() => {
-    const colliders = [];
+    object.current.updateWorldMatrix(true, false);
     const rigidBodies = instancesRefGetter.current();
-
-    if (object.current) {
-      const worldScale = object.current.getWorldScale(new Vector3());
-      let hasOneMesh = false;
-      object.current.traverse(mesh => {
-        if (mesh instanceof InstancedMesh) {
-          if (hasOneMesh) {
-            console.warn("Can only use a single InstancedMesh inside <InstancedRigidBodies />, more InstancedMeshes will be ignored.");
-            return;
-          }
-
-          hasOneMesh = true;
-          mesh.instanceMatrix.setUsage(DynamicDrawUsage);
-
-          for (let index = 0; index < mesh.count; index++) {
-            const scale = worldScale.clone();
-            const rigidBodyDesc = rigidBodyDescFromOptions(props);
-
-            if (props.scales && props.scales[index]) {
-              const s = vectorArrayToVector3(props.scales[index]);
-              scale.multiply(s);
+    const invertedWorld = object.current.matrixWorld.clone().invert();
+    object.current.traverseVisible(mesh => {
+      if (mesh instanceof InstancedMesh) {
+        mesh.instanceMatrix.setUsage(DynamicDrawUsage);
+        const worldScale = mesh.getWorldScale(_scale);
+
+        for (let index = 0; index < mesh.count; index++) {
+          var _options$scales;
+
+          const desc = rigidBodyDescFromOptions(props);
+          const rigidBody = world.createRigidBody(desc);
+          const scale = ((_options$scales = options.scales) === null || _options$scales === void 0 ? void 0 : _options$scales[index]) || [1, 1, 1];
+          const instanceScale = worldScale.clone().multiply(vectorArrayToVector3(scale));
+          rigidBodyStates.set(rigidBody.handle, createRigidBodyState({
+            rigidBody,
+            object: mesh,
+            setMatrix: matrix => mesh.setMatrixAt(index, matrix),
+            getMatrix: matrix => {
+              mesh.getMatrixAt(index, matrix);
+              return matrix;
+            },
+            worldScale: instanceScale
+          }));
+          const [x, y, z] = (positions === null || positions === void 0 ? void 0 : positions[index]) || [0, 0, 0];
+          const [rx, ry, rz] = (rotations === null || rotations === void 0 ? void 0 : rotations[index]) || [0, 0, 0];
+
+          _object3d.position.set(x, y, z);
+
+          _object3d.rotation.set(rx, ry, rz);
+
+          _object3d.applyMatrix4(invertedWorld); // Set initial transforms based on world transforms
+          // will be replaced by the setRigidBodyOption below
+
+
+          rigidBody.setTranslation(_object3d.position, false);
+          rigidBody.setRotation(_object3d.quaternion, false);
+          const api = createRigidBodyApi({
+            current() {
+              return rigidBody;
             }
 
-            const rigidBody = world.createRigidBody(rigidBodyDesc);
-            const matrix = new Matrix4();
-            mesh.getMatrixAt(index, matrix);
-            const {
-              position,
-              rotation
-            } = decomposeMatrix4(matrix);
-
-            if (props.colliders !== false) {
-              const colliderDesc = colliderDescFromGeometry(mesh.geometry, props.colliders !== undefined ? props.colliders : physicsOptions.colliders, scale, false // Collisions currently not enabled for instances
-              );
-              const collider = world.createCollider(colliderDesc, rigidBody);
-              colliders.push(collider);
-            } // Set positions
-
-
-            if (props.positions && props.positions[index]) {
-              rigidBody.setTranslation(vectorArrayToVector3(props.positions[index]), true);
-            } else {
-              rigidBody.setTranslation(position, true);
-            } // Set rotations
-
-
-            if (props.rotations && props.rotations[index]) {
-              const [x, y, z] = props.rotations[index];
-              rigidBody.setRotation(vector3ToQuaternion(new Vector3(x, y, z)), true);
-            } else {
-              rigidBody.setRotation(rotation, true);
-            }
-
-            rigidBodyStates.set(rigidBody.handle, {
-              mesh: mesh,
-              isSleeping: false,
-              invertedMatrixWorld: object.current.matrixWorld.clone().invert(),
-              setMatrix: matrix => mesh.setMatrixAt(index, matrix),
-              getMatrix: () => {
-                const m = new Matrix4();
-                mesh.getMatrixAt(index, m);
-                return m;
-              },
-              // Setting the world scale to the scale here, because
-              // we want the scales to be reflected by instance
-              worldScale: scale
-            });
-            const api = createRigidBodyApi({
-              current() {
-                return rigidBody;
-              }
-
-            });
-            rigidBodies.push({
-              rigidBody,
-              api
-            });
-          }
-        }
-
-        if (mesh.type === "Mesh" && !("isInstancedMesh" in mesh)) {
-          console.warn("Can only use InstancedMesh inside <InstancedRigidBodies />, Mesh will be ignored.");
+          });
+          rigidBodies.push({
+            rigidBody,
+            api
+          });
         }
+      }
+    });
+    return () => {
+      rigidBodies.forEach(rb => {
+        world.removeRigidBody(rb.rigidBody);
+        rigidBodyStates.delete(rb.rigidBody.handle);
       });
-      return () => {
-        rigidBodies.forEach(rb => world.removeRigidBody(rb.rigidBody));
-        colliders.forEach(coll => world.removeCollider(coll));
-        instancesRef.current = undefined;
-      };
-    }
+      instancesRef.current = undefined;
+    };
   }, []);
   const api = useMemo(() => createInstancedRigidBodiesApi(instancesRefGetter), []);
-  useImperativeHandle(ref, () => api); // console.log(api);
-
+  useImperativeHandle(ref, () => api);
   return /*#__PURE__*/React.createElement(RigidBodyContext.Provider, {
     value: {
       ref: object,
       api,
-      hasCollisionEvents: false,
       options: props
     }
   }, /*#__PURE__*/React.createElement("object3D", {
     ref: object
-  }, props.children));
+  }, props.children, childColliderProps.map((colliderProps, index) => /*#__PURE__*/React.createElement(AnyCollider, _extends({
+    key: index
+  }, colliderProps)))));
 });
 
-const _excluded = ["children", "onCollisionEnter", "onCollisionExit"];
-
-const AnyCollider = _ref => {
-  let {
-    children,
-    onCollisionEnter,
-    onCollisionExit
-  } = _ref,
-      props = _objectWithoutProperties(_ref, _excluded);
-
-  const {
-    world,
-    colliderEvents
-  } = useRapier();
-  const rigidBodyContext = useRigidBodyContext();
-  const ref = useRef(null);
-  useEffect(() => {
-    const scale = ref.current.getWorldScale(new Vector3());
-    const colliders = [];
-    const hasCollisionEvents = (rigidBodyContext === null || rigidBodyContext === void 0 ? void 0 : rigidBodyContext.hasCollisionEvents) || !!onCollisionEnter || !!onCollisionExit; // If this is an InstancedRigidBody api
-
-    if (rigidBodyContext && "at" in rigidBodyContext.api) {
-      rigidBodyContext.api.forEach((body, index) => {
-        var _rigidBodyContext$opt, _rigidBodyContext$opt2;
-
-        let instanceScale = scale.clone();
-
-        if ("scales" in rigidBodyContext.options && rigidBodyContext !== null && rigidBodyContext !== void 0 && (_rigidBodyContext$opt = rigidBodyContext.options) !== null && _rigidBodyContext$opt !== void 0 && (_rigidBodyContext$opt2 = _rigidBodyContext$opt.scales) !== null && _rigidBodyContext$opt2 !== void 0 && _rigidBodyContext$opt2[index]) {
-          instanceScale.multiply(vectorArrayToVector3(rigidBodyContext.options.scales[index]));
-        }
-
-        colliders.push(createColliderFromOptions({
-          options: _objectSpread2({
-            solverGroups: rigidBodyContext.options.solverGroups,
-            collisionGroups: rigidBodyContext.options.collisionGroups
-          }, props),
-          world,
-          rigidBody: body.raw(),
-          scale: instanceScale,
-          hasCollisionEvents
-        }));
-      });
-    } else {
-      colliders.push(createColliderFromOptions({
-        options: _objectSpread2({
-          solverGroups: (rigidBodyContext === null || rigidBodyContext === void 0 ? void 0 : rigidBodyContext.options.solverGroups) || props.solverGroups,
-          collisionGroups: (rigidBodyContext === null || rigidBodyContext === void 0 ? void 0 : rigidBodyContext.options.collisionGroups) || props.collisionGroups
-        }, props),
-        world,
-        // Initiate with a rigidbody, or undefined, because colliders can exist without a rigid body
-        rigidBody: rigidBodyContext && "raw" in rigidBodyContext.api ? rigidBodyContext.api.raw() : undefined,
-        scale,
-        hasCollisionEvents
-      }));
-    }
-    /* Register collision events. */
-
-
-    colliders.forEach(collider => colliderEvents.set(collider.handle, {
-      onCollisionEnter,
-      onCollisionExit
-    }));
-    return () => {
-      colliders.forEach(collider => {
-        colliderEvents.delete(collider.handle);
-        world.removeCollider(collider);
-      });
-    };
-  }, []);
-  return /*#__PURE__*/React.createElement("object3D", {
-    ref: ref
-  }, children);
-};
-
-const CuboidCollider = props => {
-  return /*#__PURE__*/React.createElement(AnyCollider, _extends({}, props, {
-    shape: "cuboid"
-  }));
-};
-const RoundCuboidCollider = props => {
-  return /*#__PURE__*/React.createElement(AnyCollider, _extends({}, props, {
-    shape: "roundCuboid"
-  }));
-};
-const BallCollider = props => {
-  return /*#__PURE__*/React.createElement(AnyCollider, _extends({}, props, {
-    shape: "ball"
-  }));
-};
-const CapsuleCollider = props => {
-  return /*#__PURE__*/React.createElement(AnyCollider, _extends({}, props, {
-    shape: "capsule"
-  }));
-};
-const HeightfieldCollider = props => {
-  return /*#__PURE__*/React.createElement(AnyCollider, _extends({}, props, {
-    shape: "heightfield"
-  }));
-};
-const TrimeshCollider = props => {
-  return /*#__PURE__*/React.createElement(AnyCollider, _extends({}, props, {
-    shape: "trimesh"
-  }));
-};
-const ConeCollider = props => {
-  return /*#__PURE__*/React.createElement(AnyCollider, _extends({}, props, {
-    shape: "cone"
-  }));
-};
-const CylinderCollider = props => {
-  return /*#__PURE__*/React.createElement(AnyCollider, _extends({}, props, {
-    shape: "cylinder"
-  }));
-};
-const ConvexHullCollider = props => {
-  return /*#__PURE__*/React.createElement(AnyCollider, _extends({}, props, {
-    shape: "convexHull"
-  }));
-};
-
 /**
  * Calculates an InteractionGroup bitmask for use in the `collisionGroups` or `solverGroups`
  * properties of RigidBody or Collider components. The first argument represents a list of
@@ -1454,4 +1522,4 @@ const interactionGroups = (memberships, filters) => (bitmask(memberships) << 16)
 
 const bitmask = groups => [groups].flat().reduce((acc, layer) => acc | 1 << layer, 0);
 
-export { BallCollider, CapsuleCollider, ConeCollider, ConvexHullCollider, CuboidCollider, CylinderCollider, Debug, HeightfieldCollider, InstancedRigidBodies, MeshCollider, Physics, RigidBody, RoundCuboidCollider, TrimeshCollider, interactionGroups, useFixedJoint, useImpulseJoint, usePrismaticJoint, useRapier, useRevoluteJoint, useRigidBody, useSphericalJoint };
+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 };