@react-three/rapier 0.5.2 → 0.6.0

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

@@ -2,10 +2,10 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var React = require('react');
+var rapier3dCompat = require('@dimforge/rapier3d-compat');
+var React$1 = require('react');
 var useAsset = require('use-asset');
 var fiber = require('@react-three/fiber');
-var rapier3dCompat = require('@dimforge/rapier3d-compat');
 var three = require('three');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { 'default': e }; }
@@ -28,7 +28,13 @@ function _interopNamespace(e) {
   return Object.freeze(n);
 }
 
-var React__default = /*#__PURE__*/_interopDefault(React);
+var React__default = /*#__PURE__*/_interopDefault(React$1);
+
+const _quaternion = new three.Quaternion();
+const _euler = new three.Euler();
+const _vector3 = new three.Vector3();
+new three.Object3D();
+const _matrix4 = new three.Matrix4();
 
 const vectorArrayToObject = arr => {
   const [x, y, z] = arr;
@@ -38,11 +44,20 @@ const vectorArrayToObject = arr => {
     z
   };
 };
-const quaternion = new three.Quaternion();
-const euler = new three.Euler();
 const vector3ToQuaternion = v => {
-  return quaternion.setFromEuler(euler.setFromVector3(v));
+  return _quaternion.setFromEuler(_euler.setFromVector3(v));
 };
+const rapierVector3ToVector3 = ({
+  x,
+  y,
+  z
+}) => _vector3.set(x, y, z).clone();
+const rapierQuaternionToQuaternion = ({
+  x,
+  y,
+  z,
+  w
+}) => _quaternion.set(x, y, z, w);
 const rigidBodyTypeMap = {
   fixed: 1,
   dynamic: 0,
@@ -50,6 +65,17 @@ const rigidBodyTypeMap = {
   kinematicVelocity: 3
 };
 const rigidBodyTypeFromString = type => rigidBodyTypeMap[type];
+const decomposeMatrix4 = m => {
+  const position = new three.Vector3();
+  const rotation = new three.Quaternion();
+  const scale = new three.Vector3();
+  m.decompose(position, rotation, scale);
+  return {
+    position,
+    rotation,
+    scale
+  };
+};
 const scaleColliderArgs = (shape, args, scale) => {
   // Heightfield only scales the last arg
   const newArgs = args.slice();
@@ -135,8 +161,7 @@ const isChildOfMeshCollider = child => {
 const createCollidersFromChildren = (object, rigidBody, options, world, ignoreMeshColliders = true) => {
   const hasCollisionEvents = !!(options.onCollisionEnter || options.onCollisionExit);
   const colliders = [];
-  let desc;
-  let offset = new three.Vector3();
+  new three.Vector3();
   object.traverse(child => {
     if ("isMesh" in child) {
       if (ignoreMeshColliders && isChildOfMeshCollider(child)) return;
@@ -154,62 +179,32 @@ const createCollidersFromChildren = (object, rigidBody, options, world, ignoreMe
         z: rz,
         w: rw
       } = new three.Quaternion().setFromEuler(child.rotation);
-      const scale = child.getWorldScale(new three.Vector3());
+      const scale = child.getWorldScale(new three.Vector3()); // We translate the colliders based on the parent's world scale
 
-      switch (options.colliders) {
-        case "cuboid":
-          {
-            geometry.computeBoundingBox();
-            const {
-              boundingBox
-            } = geometry;
-            const size = boundingBox.getSize(new three.Vector3());
-            boundingBox.getCenter(offset);
-            desc = rapier3dCompat.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;
-            offset.copy(boundingSphere.center);
-            desc = rapier3dCompat.ColliderDesc.ball(radius);
-          }
-          break;
-
-        case "trimesh":
-          {
-            var _g$index;
-
-            const _g = geometry.clone().scale(scale.x, scale.y, scale.z);
+      const parentWorldScale = child.parent.getWorldScale(new three.Vector3());
+      const desc = colliderDescFromGeometry(geometry, options.colliders, scale, hasCollisionEvents);
+      const offset = new three.Vector3(0, 0, 0);
 
-            desc = rapier3dCompat.ColliderDesc.trimesh(_g.attributes.position.array, (_g$index = _g.index) === null || _g$index === void 0 ? void 0 : _g$index.array);
-          }
-          break;
+      if (options.colliders === "cuboid") {
+        var _geometry$boundingBox;
 
-        case "hull":
-          const g = geometry.clone().scale(scale.x, scale.y, scale.z);
-          {
-            desc = rapier3dCompat.ColliderDesc.convexHull(g.attributes.position.array);
-          }
-          break;
-      } // We translate the colliders based on the parent's world scale
+        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);
+      }
 
-      const parentWorldScale = child.parent.getWorldScale(new three.Vector3());
+      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
       });
-      if (hasCollisionEvents) desc.setActiveEvents(rapier3dCompat.ActiveEvents.COLLISION_EVENTS);
-      if (Number.isFinite(options.friction)) desc.setFriction(options.friction);
-      if (Number.isFinite(options.restitution)) desc.setRestitution(options.restitution);
       const actualRigidBody = world.getRigidBody(rigidBody === null || rigidBody === void 0 ? void 0 : rigidBody.handle);
       const collider = world.createCollider(desc, actualRigidBody);
       colliders.push(collider);
@@ -217,6 +212,53 @@ const createCollidersFromChildren = (object, rigidBody, options, world, ignoreMe
   });
   return colliders;
 };
+const colliderDescFromGeometry = (geometry, colliders, scale, hasCollisionEvents) => {
+  let desc;
+
+  switch (colliders) {
+    case "cuboid":
+      {
+        geometry.computeBoundingBox();
+        const {
+          boundingBox
+        } = geometry;
+        const size = boundingBox.getSize(new three.Vector3());
+        desc = rapier3dCompat.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 = rapier3dCompat.ColliderDesc.ball(radius);
+      }
+      break;
+
+    case "trimesh":
+      {
+        var _g$index;
+
+        const _g = geometry.clone().scale(scale.x, scale.y, scale.z);
+
+        desc = rapier3dCompat.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 = rapier3dCompat.ColliderDesc.convexHull(g.attributes.position.array);
+      }
+      break;
+  }
+
+  if (hasCollisionEvents) desc.setActiveEvents(rapier3dCompat.ActiveEvents.COLLISION_EVENTS);
+  return desc;
+};
 const scaleVertices = (vertices, scale) => {
   const scaledVerts = Array.from(vertices);
 
@@ -228,6 +270,26 @@ const scaleVertices = (vertices, scale) => {
 
   return scaledVerts;
 };
+const rigidBodyDescFromOptions = options => {
+  var _options$linearVeloci, _options$angularVeloc, _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 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 rapier3dCompat.RigidBodyDesc(type).setLinvel(lvx, lvy, lvz).setAngvel({
+    x: avx,
+    y: avy,
+    z: avz
+  }).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 {
@@ -329,18 +391,19 @@ const createRigidBodyApi = ref => {
     setEnabledRotations: (x, y, z) => ref.current().setEnabledRotations(x, y, z, true),
     setEnabledTranslations: (x, y, z) => ref.current().setEnabledTranslations(x, y, z, true)
   };
-}; // TODO: Flesh this out
+};
+const createInstancedRigidBodiesApi = bodiesGetter => ({
+  at: index => bodiesGetter.current()[index].api,
 
-const createColliderApi = ref => {
-  return {
-    raw: () => ref.current(),
+  forEach(callback) {
+    return bodiesGetter.current().map(b => b.api).forEach(callback);
+  },
 
-    get handle() {
-      return ref.current().handle;
-    }
+  get count() {
+    return bodiesGetter.current().length;
+  }
 
-  };
-};
+}); // TODO: Flesh this out
 const createWorldApi = ref => {
   return {
     raw: () => ref.current(),
@@ -378,7 +441,7 @@ const createJointApi = ref => {
   };
 };
 
-const RapierContext = /*#__PURE__*/React.createContext(undefined);
+const RapierContext = /*#__PURE__*/React$1.createContext(undefined);
 
 const importRapier = async () => {
   let r = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('@dimforge/rapier3d-compat')); });
@@ -387,14 +450,14 @@ const importRapier = async () => {
 };
 
 const Physics = ({
-  colliders: _colliders = 'cuboid',
+  colliders: _colliders = "cuboid",
   gravity: _gravity = [0, -9.81, 0],
   children,
-  timeStep: _timeStep = 'vary'
+  timeStep: _timeStep = "vary"
 }) => {
   const rapier = useAsset.useAsset(importRapier);
-  const worldRef = React.useRef();
-  const getWorldRef = React.useRef(() => {
+  const worldRef = React$1.useRef();
+  const getWorldRef = React$1.useRef(() => {
     if (!worldRef.current) {
       const world = new rapier.World(vectorArrayToObject(_gravity));
       worldRef.current = world;
@@ -402,12 +465,12 @@ const Physics = ({
 
     return worldRef.current;
   });
-  const [colliderMeshes] = React.useState(() => new Map());
-  const [rigidBodyMeshes] = React.useState(() => new Map());
-  const [rigidBodyEvents] = React.useState(() => new Map());
-  const [eventQueue] = React.useState(() => new rapier3dCompat.EventQueue(false)); // Init world
+  const [colliderMeshes] = React$1.useState(() => new Map());
+  const [rigidBodyStates] = React$1.useState(() => new Map());
+  const [rigidBodyEvents] = React$1.useState(() => new Map());
+  const [eventQueue] = React$1.useState(() => new rapier3dCompat.EventQueue(false)); // Init world
 
-  React.useEffect(() => {
+  React$1.useEffect(() => {
     const world = getWorldRef.current();
     return () => {
       if (world) {
@@ -417,14 +480,14 @@ const Physics = ({
     };
   }, []); // Update gravity
 
-  React.useEffect(() => {
+  React$1.useEffect(() => {
     const world = worldRef.current;
 
     if (world) {
       world.gravity = vectorArrayToObject(_gravity);
     }
   }, [_gravity]);
-  const time = React.useRef(performance.now());
+  const time = React$1.useRef(performance.now());
   fiber.useFrame(context => {
     const world = worldRef.current;
     if (!world) return; // Set timestep to current delta, to allow for variable frame rates
@@ -433,7 +496,7 @@ const Physics = ({
     const now = performance.now();
     const delta = Math.min(100, now - time.current);
 
-    if (_timeStep === 'vary') {
+    if (_timeStep === "vary") {
       world.timestep = delta / 1000;
     } else {
       world.timestep = _timeStep;
@@ -441,52 +504,35 @@ const Physics = ({
 
     world.step(eventQueue); // Update meshes
 
-    rigidBodyMeshes.forEach((mesh, handle) => {
+    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() && !mesh.userData.isSleeping) {
+        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() && mesh.userData.isSleeping) {
+        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);
         }
 
-        mesh.userData.isSleeping = rigidBody.isSleeping();
+        state.isSleeping = rigidBody.isSleeping();
       }
 
-      if (!rigidBody || rigidBody.isSleeping() || rigidBody.isFixed() || !mesh.parent) {
+      if (!rigidBody || rigidBody.isSleeping() || rigidBody.isFixed() || !state.setMatrix) {
         return;
       }
 
-      const {
-        x,
-        y,
-        z
-      } = rigidBody.translation();
-      const {
-        x: rx,
-        y: ry,
-        z: rz,
-        w: rw
-      } = rigidBody.rotation();
-      const scale = mesh.getWorldScale(new three.Vector3()); // haha matrixes I have no idea what I'm doing :)
-
-      const o = new three.Object3D();
-      o.position.set(x, y, z);
-      o.rotation.setFromQuaternion(new three.Quaternion(rx, ry, rz, rw));
-      o.scale.set(scale.x, scale.y, scale.z);
-      o.updateMatrix();
-      o.applyMatrix4(mesh.parent.matrixWorld.clone().invert());
-      o.updateMatrix();
-      mesh.position.setFromMatrixPosition(o.matrix);
-      mesh.rotation.setFromRotationMatrix(o.matrix);
+      state.setMatrix(_matrix4.compose(rapierVector3ToVector3(rigidBody.translation()), rapierQuaternionToQuaternion(rigidBody.rotation()), state.worldScale).premultiply(state.invertedMatrixWorld));
+
+      if (state.mesh instanceof three.InstancedMesh) {
+        state.mesh.instanceMatrix.needsUpdate = true;
+      }
     }); // Collision events
 
     eventQueue.drainCollisionEvents((handle1, handle2, started) => {
@@ -534,8 +580,8 @@ const Physics = ({
     });
     time.current = now;
   });
-  const api = React.useMemo(() => createWorldApi(getWorldRef), []);
-  const context = React.useMemo(() => ({
+  const api = React$1.useMemo(() => createWorldApi(getWorldRef), []);
+  const context = React$1.useMemo(() => ({
     rapier,
     world: api,
     physicsOptions: {
@@ -543,7 +589,7 @@ const Physics = ({
       gravity: _gravity
     },
     colliderMeshes,
-    rigidBodyMeshes,
+    rigidBodyStates,
     rigidBodyEvents
   }), []);
   return /*#__PURE__*/React__default["default"].createElement(RapierContext.Provider, {
@@ -551,6 +597,40 @@ const Physics = ({
   }, children);
 };
 
+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];
+  }
+
+  return target;
+}
+
+function _objectWithoutProperties(source, excluded) {
+  if (source == null) return {};
+  var target = _objectWithoutPropertiesLoose(source, excluded);
+  var key, i;
+
+  if (Object.getOwnPropertySymbols) {
+    var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
+
+    for (i = 0; i < sourceSymbolKeys.length; i++) {
+      key = sourceSymbolKeys[i];
+      if (excluded.indexOf(key) >= 0) continue;
+      if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+      target[key] = source[key];
+    }
+  }
+
+  return target;
+}
+
 function _defineProperty(obj, key, value) {
   if (key in obj) {
     Object.defineProperty(obj, key, {
@@ -593,38 +673,21 @@ function _objectSpread2(target) {
 }
 
 const useRapier = () => {
-  return React.useContext(RapierContext);
+  return React$1.useContext(RapierContext);
 };
 const useRigidBody = (options = {}) => {
   const {
-    rapier,
     world,
-    rigidBodyMeshes,
+    rigidBodyStates,
     physicsOptions,
     rigidBodyEvents
   } = useRapier();
-  const ref = React.useRef(); // Create rigidbody
+  const ref = React$1.useRef(); // Create rigidbody
 
-  const rigidBodyRef = React.useRef();
-  const getRigidBodyRef = React.useRef(() => {
+  const rigidBodyRef = React$1.useRef();
+  const getRigidBodyRef = React$1.useRef(() => {
     if (!rigidBodyRef.current) {
-      var _options$linearVeloci, _options$angularVeloc, _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 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 rapier.RigidBodyDesc(type).setLinvel(lvx, lvy, lvz).setAngvel({
-        x: avx,
-        y: avy,
-        z: avz
-      }).setGravityScale(gravityScale).setCanSleep(canSleep).setCcdEnabled(ccdEnabled).enabledRotations(erx, ery, erz).enabledTranslations(etx, ety, etz);
-      if (options.lockRotations) desc.lockRotations();
-      if (options.lockTranslations) desc.lockTranslations();
+      const desc = rigidBodyDescFromOptions(options);
       const rigidBody = world.createRigidBody(desc);
       rigidBodyRef.current = world.getRigidBody(rigidBody.handle);
     }
@@ -632,7 +695,7 @@ const useRigidBody = (options = {}) => {
     return rigidBodyRef.current;
   }); // Setup
 
-  React.useEffect(() => {
+  React$1.useEffect(() => {
     var _ref$current$parent, _ref, _options$colliders;
 
     const rigidBody = getRigidBodyRef.current();
@@ -661,8 +724,7 @@ const useRigidBody = (options = {}) => {
       y: worldPosition.y + y * scale.y,
       z: worldPosition.z + z * scale.z
     }, false);
-    const eulerAngles = new three.Euler(rx, ry, rz, 'XYZ');
-    const rotation = new three.Quaternion().setFromEuler(eulerAngles).multiply(worldRotation);
+    const rotation = vector3ToQuaternion(new three.Vector3(rx, ry, rz)).multiply(worldRotation);
     rigidBody.setRotation({
       x: rotation.x,
       y: rotation.y,
@@ -675,16 +737,23 @@ const useRigidBody = (options = {}) => {
     const autoColliders = colliderSetting !== false ? createCollidersFromChildren(ref.current, rigidBody, _objectSpread2(_objectSpread2({}, options), {}, {
       colliders: colliderSetting
     }), world) : [];
-    rigidBodyMeshes.set(rigidBody.handle, ref.current);
+    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)
+    });
+    ref.current.matrixAutoUpdate = false;
     return () => {
       world.removeRigidBody(rigidBody);
       autoColliders.forEach(collider => world.removeCollider(collider));
       rigidBodyRef.current = undefined;
-      rigidBodyMeshes.delete(rigidBody.handle);
+      rigidBodyStates.delete(rigidBody.handle);
     };
   }, []); // Events
 
-  React.useEffect(() => {
+  React$1.useEffect(() => {
     const rigidBody = getRigidBodyRef.current();
     rigidBodyEvents.set(rigidBody.handle, {
       onCollisionEnter: options === null || options === void 0 ? void 0 : options.onCollisionEnter,
@@ -696,44 +765,21 @@ const useRigidBody = (options = {}) => {
       rigidBodyEvents.delete(rigidBody.handle);
     };
   }, [options.onCollisionEnter, options.onCollisionExit]);
-  const api = React.useMemo(() => createRigidBodyApi(getRigidBodyRef), []);
+  const api = React$1.useMemo(() => createRigidBodyApi(getRigidBodyRef), []);
   return [ref, api];
-};
-const useCollider = (body, options = {}) => {
-  const {
-    world
-  } = useRapier();
-  const colliderRef = React.useRef();
-  const objectRef = React.useRef();
-  const getColliderRef = React.useRef(() => {
-    if (!colliderRef.current) {
-      colliderRef.current = createColliderFromOptions(options, world, world.getRigidBody(body.handle));
-    }
-
-    return colliderRef.current;
-  });
-  React.useEffect(() => {
-    const collider = getColliderRef.current();
-    return () => {
-      if (collider) world.removeCollider(collider);
-      colliderRef.current = undefined;
-    };
-  }, []);
-  const api = React.useMemo(() => createColliderApi(getColliderRef), []);
-  return [objectRef, api];
 }; // Joints
 
 const useImpulseJoint = (body1, body2, params) => {
   const {
     world
   } = useRapier();
-  const jointRef = React.useRef();
-  const getJointRef = React.useRef(() => {
+  const jointRef = React$1.useRef();
+  const getJointRef = React$1.useRef(() => {
     if (!jointRef.current) {
       let rb1;
       let rb2;
 
-      if ('current' in body1 && body1.current && 'current' in body2 && body2.current) {
+      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);
@@ -743,7 +789,7 @@ const useImpulseJoint = (body1, body2, params) => {
 
     return jointRef.current;
   });
-  React.useEffect(() => {
+  React$1.useEffect(() => {
     const joint = getJointRef.current();
     return () => {
       if (joint) {
@@ -752,7 +798,7 @@ const useImpulseJoint = (body1, body2, params) => {
       }
     };
   }, []);
-  const api = React.useMemo(() => createJointApi(getJointRef), []);
+  const api = React$1.useMemo(() => createJointApi(getJointRef), []);
   return api;
 };
 /**
@@ -810,73 +856,18 @@ const usePrismaticJoint = (body1, body2, [body1Anchor, body2Anchor, axis]) => {
   return useImpulseJoint(body1, body2, rapier.JointData.prismatic(vectorArrayToObject(body1Anchor), vectorArrayToObject(body2Anchor), vectorArrayToObject(axis)));
 };
 
-function _extends() {
-  _extends = Object.assign || 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 target;
-  };
+const _excluded$1 = ["children"];
+const RigidBodyContext = /*#__PURE__*/React$1.createContext(undefined);
+const useRigidBodyContext = () => React$1.useContext(RigidBodyContext); // RigidBody
 
-  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];
-  }
-
-  return target;
-}
-
-function _objectWithoutProperties(source, excluded) {
-  if (source == null) return {};
-  var target = _objectWithoutPropertiesLoose(source, excluded);
-  var key, i;
-
-  if (Object.getOwnPropertySymbols) {
-    var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
-
-    for (i = 0; i < sourceSymbolKeys.length; i++) {
-      key = sourceSymbolKeys[i];
-      if (excluded.indexOf(key) >= 0) continue;
-      if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
-      target[key] = source[key];
-    }
-  }
-
-  return target;
-}
-
-const _excluded = ["children"],
-      _excluded2 = ["children"];
-const RigidBodyContext = /*#__PURE__*/React.createContext(undefined);
-
-const useRigidBodyContext = () => React.useContext(RigidBodyContext); // RigidBody
-
-
-const RigidBody = /*#__PURE__*/React.forwardRef((_ref, ref) => {
+const RigidBody = /*#__PURE__*/React$1.forwardRef((_ref, ref) => {
   let {
     children
   } = _ref,
-      props = _objectWithoutProperties(_ref, _excluded);
+      props = _objectWithoutProperties(_ref, _excluded$1);
 
   const [object, api] = useRigidBody(props);
-  React.useImperativeHandle(ref, () => api);
+  React$1.useImperativeHandle(ref, () => api);
   return /*#__PURE__*/React__default["default"].createElement(RigidBodyContext.Provider, {
     value: {
       ref: object,
@@ -888,6 +879,7 @@ const RigidBody = /*#__PURE__*/React.forwardRef((_ref, ref) => {
     ref: object
   }, children));
 });
+
 const MeshCollider = ({
   children,
   type
@@ -896,18 +888,18 @@ const MeshCollider = ({
     physicsOptions,
     world
   } = useRapier();
-  const object = React.useRef(null);
+  const object = React$1.useRef(null);
   const {
     api,
     options
   } = useRigidBodyContext();
-  React.useEffect(() => {
+  React$1.useEffect(() => {
     let autoColliders = [];
 
     if (object.current) {
-      var _ref2;
+      var _ref;
 
-      const colliderSetting = (_ref2 = type !== null && type !== void 0 ? type : physicsOptions.colliders) !== null && _ref2 !== void 0 ? _ref2 : false;
+      const colliderSetting = (_ref = type !== null && type !== void 0 ? type : physicsOptions.colliders) !== null && _ref !== void 0 ? _ref : false;
       autoColliders = colliderSetting !== false ? createCollidersFromChildren(object.current, api, _objectSpread2(_objectSpread2({}, options), {}, {
         colliders: colliderSetting
       }), world, false) : [];
@@ -919,89 +911,12 @@ const MeshCollider = ({
       });
     };
   }, []);
-  return /*#__PURE__*/React__default["default"].createElement("object3D", {
+  return /*#__PURE__*/React.createElement("object3D", {
     ref: object,
     userData: {
       r3RapierType: "MeshCollider"
     }
   }, children);
-}; // Colliders
-
-const AnyCollider = _ref3 => {
-  let {
-    children
-  } = _ref3,
-      props = _objectWithoutProperties(_ref3, _excluded2);
-
-  const {
-    world
-  } = useRapier();
-  const rigidBodyContext = useRigidBodyContext();
-  const ref = React.useRef(null);
-  React.useEffect(() => {
-    var _rigidBodyContext$api;
-
-    const scale = ref.current.getWorldScale(new three.Vector3());
-    const collider = createColliderFromOptions({
-      options: props,
-      world,
-      rigidBody: rigidBodyContext === null || rigidBodyContext === void 0 ? void 0 : (_rigidBodyContext$api = rigidBodyContext.api) === null || _rigidBodyContext$api === void 0 ? void 0 : _rigidBodyContext$api.raw(),
-      scale,
-      hasCollisionEvents: rigidBodyContext === null || rigidBodyContext === void 0 ? void 0 : rigidBodyContext.hasCollisionEvents
-    });
-    return () => {
-      world.removeCollider(collider);
-    };
-  }, []);
-  return /*#__PURE__*/React__default["default"].createElement("object3D", {
-    ref: ref
-  }, children);
-};
-
-const CuboidCollider = props => {
-  return /*#__PURE__*/React__default["default"].createElement(AnyCollider, _extends({}, props, {
-    shape: "cuboid"
-  }));
-};
-const RoundCuboidCollider = props => {
-  return /*#__PURE__*/React__default["default"].createElement(AnyCollider, _extends({}, props, {
-    shape: "roundCuboid"
-  }));
-};
-const BallCollider = props => {
-  return /*#__PURE__*/React__default["default"].createElement(AnyCollider, _extends({}, props, {
-    shape: "ball"
-  }));
-};
-const CapsuleCollider = props => {
-  return /*#__PURE__*/React__default["default"].createElement(AnyCollider, _extends({}, props, {
-    shape: "capsule"
-  }));
-};
-const HeightfieldCollider = props => {
-  return /*#__PURE__*/React__default["default"].createElement(AnyCollider, _extends({}, props, {
-    shape: "heightfield"
-  }));
-};
-const TrimeshCollider = props => {
-  return /*#__PURE__*/React__default["default"].createElement(AnyCollider, _extends({}, props, {
-    shape: "trimesh"
-  }));
-};
-const ConeCollider = props => {
-  return /*#__PURE__*/React__default["default"].createElement(AnyCollider, _extends({}, props, {
-    shape: "cone"
-  }));
-};
-const CylinderCollider = props => {
-  return /*#__PURE__*/React__default["default"].createElement(AnyCollider, _extends({}, props, {
-    shape: "cylinder"
-  }));
-};
-const ConvexHullCollider = props => {
-  return /*#__PURE__*/React__default["default"].createElement(AnyCollider, _extends({}, props, {
-    shape: "convexHull"
-  }));
 };
 
 const geometryFromCollider = collider => {
@@ -1059,13 +974,13 @@ const geometryFromCollider = collider => {
   return new three.BoxBufferGeometry(1, 1, 1);
 };
 
-const DebugShape = /*#__PURE__*/React.memo(({
+const DebugShape = /*#__PURE__*/React$1.memo(({
   colliderHandle
 }) => {
   const {
     world
   } = useRapier();
-  const ref = React.useRef(null);
+  const ref = React$1.useRef(null);
   fiber.useFrame(() => {
     const collider = world.getCollider(colliderHandle);
 
@@ -1085,7 +1000,7 @@ const DebugShape = /*#__PURE__*/React.memo(({
       ref.current.rotation.setFromQuaternion(new three.Quaternion(rx, ry, rz, rw));
     }
   });
-  const geometry = React.useMemo(() => {
+  const geometry = React$1.useMemo(() => {
     const collider = world.getCollider(colliderHandle);
     return geometryFromCollider(collider);
   }, [colliderHandle]);
@@ -1103,8 +1018,8 @@ const Debug = () => {
   const {
     world
   } = useRapier();
-  const [colliders, setColliders] = React.useState([]);
-  React.useRef({});
+  const [colliders, setColliders] = React$1.useState([]);
+  React$1.useRef({});
 
   fiber.useFrame(() => {
     const newColliders = [];
@@ -1119,6 +1034,200 @@ const Debug = () => {
   })));
 };
 
+const InstancedRigidBodies = /*#__PURE__*/React$1.forwardRef((props, ref) => {
+  const {
+    world,
+    rigidBodyStates,
+    physicsOptions
+  } = useRapier();
+  const object = React$1.useRef(null);
+  const instancesRef = React$1.useRef();
+  const instancesRefGetter = React$1.useRef(() => {
+    if (!instancesRef.current) {
+      instancesRef.current = [];
+    }
+
+    return instancesRef.current;
+  });
+  React$1.useEffect(() => {
+    const colliders = [];
+    const rigidBodies = instancesRefGetter.current();
+
+    if (object.current) {
+      const scale = object.current.getWorldScale(new three.Vector3());
+      let hasOneMesh = false;
+      object.current.traverse(mesh => {
+        if (mesh instanceof three.InstancedMesh) {
+          if (hasOneMesh) {
+            console.warn("Can only use a single InstancedMesh inside <InstancedRigidBodies />, more InstancedMeshes will be ignored.");
+            return;
+          }
+
+          hasOneMesh = true;
+          mesh.instanceMatrix.setUsage(three.DynamicDrawUsage);
+          const rigidBodyDesc = rigidBodyDescFromOptions(props);
+          const colliderDesc = colliderDescFromGeometry(mesh.geometry, props.colliders || physicsOptions.colliders, scale, false // Collisions currently not enabled for instances
+          );
+
+          for (let index = 0; index < mesh.count; index++) {
+            const rigidBody = world.createRigidBody(rigidBodyDesc);
+            const matrix = new three.Matrix4();
+            mesh.getMatrixAt(index, matrix);
+            const {
+              position,
+              rotation
+            } = decomposeMatrix4(matrix); // Set positions
+
+            if (props.positions && props.positions[index]) {
+              rigidBody.setTranslation(vectorArrayToObject(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 three.Vector3(x, y, z)), true);
+            } else {
+              rigidBody.setRotation(rotation, true);
+            }
+
+            const collider = world.createCollider(colliderDesc, rigidBody);
+            rigidBodyStates.set(rigidBody.handle, {
+              mesh: mesh,
+              isSleeping: false,
+              invertedMatrixWorld: object.current.matrixWorld.clone().invert(),
+              setMatrix: matrix => mesh.setMatrixAt(index, matrix),
+              worldScale: object.current.getWorldScale(new three.Vector3())
+            });
+            const api = createRigidBodyApi({
+              current() {
+                return rigidBody;
+              }
+
+            });
+            colliders.push(collider);
+            rigidBodies.push({
+              rigidBody,
+              api
+            });
+          }
+        }
+
+        if (mesh.type === "Mesh" && !("isInstancedMesh" in mesh)) {
+          console.warn("Can only use InstancedMesh inside <InstancedRigidBodies />, Mesh will be ignored.");
+        }
+      });
+      return () => {
+        rigidBodies.forEach(rb => world.removeRigidBody(rb.rigidBody));
+        colliders.forEach(coll => world.removeCollider(coll));
+        instancesRef.current = undefined;
+      };
+    }
+  }, []);
+  React$1.useImperativeHandle(ref, () => createInstancedRigidBodiesApi(instancesRefGetter));
+  return /*#__PURE__*/React.createElement("object3D", {
+    ref: object
+  }, props.children);
+});
+
+function _extends() {
+  _extends = Object.assign || 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 target;
+  };
+
+  return _extends.apply(this, arguments);
+}
+
+const _excluded = ["children"];
+
+const AnyCollider = _ref => {
+  let {
+    children
+  } = _ref,
+      props = _objectWithoutProperties(_ref, _excluded);
+
+  const {
+    world
+  } = useRapier();
+  const rigidBodyContext = useRigidBodyContext();
+  const ref = React$1.useRef(null);
+  React$1.useEffect(() => {
+    var _rigidBodyContext$api;
+
+    const scale = ref.current.getWorldScale(new three.Vector3());
+    const collider = createColliderFromOptions({
+      options: props,
+      world,
+      rigidBody: rigidBodyContext === null || rigidBodyContext === void 0 ? void 0 : (_rigidBodyContext$api = rigidBodyContext.api) === null || _rigidBodyContext$api === void 0 ? void 0 : _rigidBodyContext$api.raw(),
+      scale,
+      hasCollisionEvents: rigidBodyContext === null || rigidBodyContext === void 0 ? void 0 : rigidBodyContext.hasCollisionEvents
+    });
+    return () => {
+      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"
+  }));
+};
+
 Object.defineProperty(exports, 'CoefficientCombineRule', {
   enumerable: true,
   get: function () { return rapier3dCompat.CoefficientCombineRule; }
@@ -1139,12 +1248,12 @@ exports.CuboidCollider = CuboidCollider;
 exports.CylinderCollider = CylinderCollider;
 exports.Debug = Debug;
 exports.HeightfieldCollider = HeightfieldCollider;
+exports.InstancedRigidBodies = InstancedRigidBodies;
 exports.MeshCollider = MeshCollider;
 exports.Physics = Physics;
 exports.RigidBody = RigidBody;
 exports.RoundCuboidCollider = RoundCuboidCollider;
 exports.TrimeshCollider = TrimeshCollider;
-exports.useCollider = useCollider;
 exports.useFixedJoint = useFixedJoint;
 exports.useImpulseJoint = useImpulseJoint;
 exports.usePrismaticJoint = usePrismaticJoint;