@react-three/rapier 0.5.0 → 0.6.0

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

@@ -1,9 +1,15 @@
-import React, { useRef, useState, useEffect, useMemo, createContext, useContext, forwardRef, useImperativeHandle, memo } from 'react';
+import { ColliderDesc, ActiveEvents, RigidBodyDesc, CoefficientCombineRule, EventQueue, ShapeType } from '@dimforge/rapier3d-compat';
+export { CoefficientCombineRule, Collider as RapierCollider, RigidBody as RapierRigidBody } from '@dimforge/rapier3d-compat';
+import React$1, { useRef, useState, useEffect, useMemo, createContext, useContext, forwardRef, useImperativeHandle, memo } from 'react';
 import { useAsset } from 'use-asset';
 import { useFrame } from '@react-three/fiber';
-import { ColliderDesc, CoefficientCombineRule, ActiveEvents, EventQueue, ShapeType } from '@dimforge/rapier3d-compat';
-export { CoefficientCombineRule, Collider as RapierCollider, RigidBody as RapierRigidBody } from '@dimforge/rapier3d-compat';
-import { Quaternion, Euler, Vector3, Object3D, CylinderBufferGeometry, BufferGeometry, BufferAttribute, SphereBufferGeometry, BoxBufferGeometry } from 'three';
+import { Quaternion, Euler, Vector3, Object3D, Matrix4, InstancedMesh, CylinderBufferGeometry, BufferGeometry, BufferAttribute, SphereBufferGeometry, BoxBufferGeometry, DynamicDrawUsage } from 'three';
+
+const _quaternion = new Quaternion();
+const _euler = new Euler();
+const _vector3 = new Vector3();
+new Object3D();
+const _matrix4 = new Matrix4();
 
 const vectorArrayToObject = arr => {
   const [x, y, z] = arr;
@@ -13,6 +19,20 @@ const vectorArrayToObject = arr => {
     z
   };
 };
+const vector3ToQuaternion = 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,
@@ -20,6 +40,17 @@ 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) => {
   // Heightfield only scales the last arg
   const newArgs = args.slice();
@@ -38,11 +69,13 @@ const scaleColliderArgs = (shape, args, scale) => {
   const scaleArray = [scale.x, scale.y, scale.z];
   return newArgs.map((arg, index) => scaleArray[index] * arg);
 };
-const createColliderFromOptions = (options, world, rigidBody, scale = {
-  x: 1,
-  y: 1,
-  z: 1
-}, hasCollisionEvents = false) => {
+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;
@@ -51,15 +84,16 @@ const createColliderFromOptions = (options, world, rigidBody, scale = {
   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]; // @ts-ignore
+  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: rx,
-    y: ry,
-    z: rz,
-    w: 1
+    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) {
@@ -67,6 +101,8 @@ const createColliderFromOptions = (options, world, rigidBody, scale = {
   } // 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, {
@@ -78,23 +114,32 @@ const createColliderFromOptions = (options, world, rigidBody, scale = {
       y: piy,
       z: piz
     }, {
-      x: 0,
-      y: 0,
-      z: 0,
-      w: 1
+      x: qMassRot.x,
+      y: qMassRot.y,
+      z: qMassRot.z,
+      w: qMassRot.w
     });
   }
 
   const collider = world.createCollider(colliderDesc, rigidBody);
   return collider;
 };
-const createCollidersFromChildren = (object, rigidBody, options, world) => {
+
+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 = true) => {
   const hasCollisionEvents = !!(options.onCollisionEnter || options.onCollisionExit);
   const colliders = [];
-  let desc;
-  let offset = new Vector3();
+  new Vector3();
   object.traverse(child => {
     if ("isMesh" in child) {
+      if (ignoreMeshColliders && isChildOfMeshCollider(child)) return;
       const {
         geometry
       } = child;
@@ -109,68 +154,86 @@ const createCollidersFromChildren = (object, rigidBody, options, world) => {
         z: rz,
         w: rw
       } = new Quaternion().setFromEuler(child.rotation);
-      const scale = child.getWorldScale(new Vector3());
-
-      switch (options.colliders) {
-        case "cuboid":
-          {
-            geometry.computeBoundingBox();
-            const {
-              boundingBox
-            } = geometry;
-            const size = boundingBox.getSize(new Vector3());
-            boundingBox.getCenter(offset);
-            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;
-            offset.copy(boundingSphere.center);
-            desc = ColliderDesc.ball(radius);
-          }
-          break;
-
-        case "trimesh":
-          {
-            var _g$index;
+      const scale = child.getWorldScale(new Vector3()); // We translate the colliders based on the parent's world scale
 
-            const _g = geometry.clone().scale(scale.x, scale.y, scale.z);
+      const parentWorldScale = child.parent.getWorldScale(new Vector3());
+      const desc = colliderDescFromGeometry(geometry, options.colliders, scale, hasCollisionEvents);
+      const offset = new Vector3(0, 0, 0);
 
-            desc = 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 = 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 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(ActiveEvents.COLLISION_EVENTS);
-      if (Number.isFinite(options.friction)) desc.setFriction(options.friction);
-      if (Number.isFinite(options.restitution)) desc.setRestitution(options.restitution);
-      const collider = world.createCollider(desc, rigidBody);
+      const actualRigidBody = world.getRigidBody(rigidBody === null || rigidBody === void 0 ? void 0 : rigidBody.handle);
+      const collider = world.createCollider(desc, actualRigidBody);
       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 _g = geometry.clone().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);
 
@@ -182,53 +245,27 @@ const scaleVertices = (vertices, scale) => {
 
   return scaledVerts;
 };
-const quaternion = new Quaternion();
-const euler = new Euler();
-const vector3ToQuaternion = v => {
-  return quaternion.setFromEuler(euler.setFromVector3(v));
+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 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;
 };
 
-function _defineProperty(obj, key, value) {
-  if (key in obj) {
-    Object.defineProperty(obj, key, {
-      value: value,
-      enumerable: true,
-      configurable: true,
-      writable: true
-    });
-  } else {
-    obj[key] = value;
-  }
-
-  return obj;
-}
-
-function ownKeys(object, enumerableOnly) {
-  var keys = Object.keys(object);
-
-  if (Object.getOwnPropertySymbols) {
-    var symbols = Object.getOwnPropertySymbols(object);
-    enumerableOnly && (symbols = symbols.filter(function (sym) {
-      return Object.getOwnPropertyDescriptor(object, sym).enumerable;
-    })), keys.push.apply(keys, symbols);
-  }
-
-  return keys;
-}
-
-function _objectSpread2(target) {
-  for (var i = 1; i < arguments.length; i++) {
-    var source = null != arguments[i] ? arguments[i] : {};
-    i % 2 ? ownKeys(Object(source), !0).forEach(function (key) {
-      _defineProperty(target, key, source[key]);
-    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) {
-      Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
-    });
-  }
-
-  return target;
-}
-
 const createRigidBodyApi = ref => {
   return {
     raw: () => ref.current(),
@@ -273,9 +310,19 @@ const createRigidBodyApi = ref => {
       return new Quaternion(x, y, z, w);
     },
 
-    setRotation: rotation => ref.current().setRotation(_objectSpread2(_objectSpread2({}, rotation), {}, {
-      w: 1
-    }), true),
+    setRotation: ({
+      x,
+      y,
+      z
+    }) => {
+      const q = vector3ToQuaternion(new Vector3(x, y, z));
+      ref.current().setRotation({
+        x: q.x,
+        y: q.y,
+        z: q.z,
+        w: q.w
+      }, true);
+    },
 
     linvel() {
       const {
@@ -319,18 +366,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(),
@@ -377,10 +425,10 @@ 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(importRapier);
   const worldRef = useRef();
@@ -393,7 +441,7 @@ const Physics = ({
     return worldRef.current;
   });
   const [colliderMeshes] = useState(() => new Map());
-  const [rigidBodyMeshes] = useState(() => new Map());
+  const [rigidBodyStates] = useState(() => new Map());
   const [rigidBodyEvents] = useState(() => new Map());
   const [eventQueue] = useState(() => new EventQueue(false)); // Init world
 
@@ -423,7 +471,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;
@@ -431,52 +479,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 Vector3()); // haha matrixes I have no idea what I'm doing :)
-
-      const o = new Object3D();
-      o.position.set(x, y, z);
-      o.rotation.setFromQuaternion(new 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 InstancedMesh) {
+        state.mesh.instanceMatrix.needsUpdate = true;
+      }
     }); // Collision events
 
     eventQueue.drainCollisionEvents((handle1, handle2, started) => {
@@ -533,22 +564,96 @@ const Physics = ({
       gravity: _gravity
     },
     colliderMeshes,
-    rigidBodyMeshes,
+    rigidBodyStates,
     rigidBodyEvents
   }), []);
-  return /*#__PURE__*/React.createElement(RapierContext.Provider, {
+  return /*#__PURE__*/React$1.createElement(RapierContext.Provider, {
     value: context
   }, 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, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+
+  return obj;
+}
+
+function ownKeys(object, enumerableOnly) {
+  var keys = Object.keys(object);
+
+  if (Object.getOwnPropertySymbols) {
+    var symbols = Object.getOwnPropertySymbols(object);
+    enumerableOnly && (symbols = symbols.filter(function (sym) {
+      return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+    })), keys.push.apply(keys, symbols);
+  }
+
+  return keys;
+}
+
+function _objectSpread2(target) {
+  for (var i = 1; i < arguments.length; i++) {
+    var source = null != arguments[i] ? arguments[i] : {};
+    i % 2 ? ownKeys(Object(source), !0).forEach(function (key) {
+      _defineProperty(target, key, source[key]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) {
+      Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+    });
+  }
+
+  return target;
+}
+
 const useRapier = () => {
   return useContext(RapierContext);
 };
 const useRigidBody = (options = {}) => {
   const {
-    rapier,
     world,
-    rigidBodyMeshes,
+    rigidBodyStates,
     physicsOptions,
     rigidBodyEvents
   } = useRapier();
@@ -557,23 +662,7 @@ const useRigidBody = (options = {}) => {
   const rigidBodyRef = useRef();
   const getRigidBodyRef = 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);
     }
@@ -610,8 +699,7 @@ const useRigidBody = (options = {}) => {
       y: worldPosition.y + y * scale.y,
       z: worldPosition.z + z * scale.z
     }, false);
-    const eulerAngles = new Euler(rx, ry, rz, 'XYZ');
-    const rotation = new Quaternion().setFromEuler(eulerAngles).multiply(worldRotation);
+    const rotation = vector3ToQuaternion(new Vector3(rx, ry, rz)).multiply(worldRotation);
     rigidBody.setRotation({
       x: rotation.x,
       y: rotation.y,
@@ -624,12 +712,19 @@ 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
 
@@ -647,29 +742,6 @@ const useRigidBody = (options = {}) => {
   }, [options.onCollisionEnter, options.onCollisionExit]);
   const api = useMemo(() => createRigidBodyApi(getRigidBodyRef), []);
   return [ref, api];
-};
-const useCollider = (body, options = {}) => {
-  const {
-    world
-  } = useRapier();
-  const colliderRef = useRef();
-  const objectRef = useRef();
-  const getColliderRef = useRef(() => {
-    if (!colliderRef.current) {
-      colliderRef.current = createColliderFromOptions(options, world, world.getRigidBody(body.handle));
-    }
-
-    return colliderRef.current;
-  });
-  useEffect(() => {
-    const collider = getColliderRef.current();
-    return () => {
-      if (collider) world.removeCollider(collider);
-      colliderRef.current = undefined;
-    };
-  }, []);
-  const api = useMemo(() => createColliderApi(getColliderRef), []);
-  return [objectRef, api];
 }; // Joints
 
 const useImpulseJoint = (body1, body2, params) => {
@@ -682,7 +754,7 @@ const useImpulseJoint = (body1, body2, params) => {
       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);
@@ -759,149 +831,69 @@ 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;
-  };
-
-  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 _excluded$1 = ["children"];
 const RigidBodyContext = /*#__PURE__*/createContext(undefined);
-
 const useRigidBodyContext = () => useContext(RigidBodyContext); // RigidBody
 
-
 const RigidBody = /*#__PURE__*/forwardRef((_ref, ref) => {
   let {
     children
   } = _ref,
-      props = _objectWithoutProperties(_ref, _excluded);
-
-  const [object, rigidBody] = useRigidBody(props);
-  useImperativeHandle(ref, () => rigidBody);
-  return /*#__PURE__*/React.createElement(RigidBodyContext.Provider, {
-    value: [object, rigidBody, !!(props.onCollisionEnter || props.onCollisionExit)]
-  }, /*#__PURE__*/React.createElement("object3D", {
+      props = _objectWithoutProperties(_ref, _excluded$1);
+
+  const [object, api] = useRigidBody(props);
+  useImperativeHandle(ref, () => api);
+  return /*#__PURE__*/React$1.createElement(RigidBodyContext.Provider, {
+    value: {
+      ref: object,
+      api,
+      hasCollisionEvents: !!(props.onCollisionEnter || props.onCollisionExit),
+      options: props
+    }
+  }, /*#__PURE__*/React$1.createElement("object3D", {
     ref: object
   }, children));
-}); // Colliders
-
-const AnyCollider = _ref2 => {
-  let {
-    children
-  } = _ref2,
-      props = _objectWithoutProperties(_ref2, _excluded2);
+});
 
+const MeshCollider = ({
+  children,
+  type
+}) => {
   const {
+    physicsOptions,
     world
   } = useRapier();
-  const [, rigidBody, hasCollisionEvents] = useRigidBodyContext();
-  const ref = useRef(null);
+  const object = useRef(null);
+  const {
+    api,
+    options
+  } = useRigidBodyContext();
   useEffect(() => {
-    const scale = ref.current.getWorldScale(new Vector3());
-    const collider = createColliderFromOptions(props, world, rigidBody.raw(), scale, hasCollisionEvents);
+    let autoColliders = [];
+
+    if (object.current) {
+      var _ref;
+
+      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) : [];
+    }
+
     return () => {
-      world.removeCollider(collider);
+      autoColliders.forEach(collider => {
+        world.removeCollider(collider);
+      });
     };
   }, []);
   return /*#__PURE__*/React.createElement("object3D", {
-    ref: ref
+    ref: object,
+    userData: {
+      r3RapierType: "MeshCollider"
+    }
   }, 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 geometryFromCollider = collider => {
   switch (collider.shape.type) {
     case ShapeType.Cuboid:
@@ -987,12 +979,12 @@ const DebugShape = /*#__PURE__*/memo(({
     const collider = world.getCollider(colliderHandle);
     return geometryFromCollider(collider);
   }, [colliderHandle]);
-  return /*#__PURE__*/React.createElement("mesh", {
+  return /*#__PURE__*/React$1.createElement("mesh", {
     ref: ref
-  }, /*#__PURE__*/React.createElement("primitive", {
+  }, /*#__PURE__*/React$1.createElement("primitive", {
     object: geometry,
     attach: "geometry"
-  }), /*#__PURE__*/React.createElement("meshBasicMaterial", {
+  }), /*#__PURE__*/React$1.createElement("meshBasicMaterial", {
     color: "red",
     wireframe: true
   }));
@@ -1011,10 +1003,204 @@ const Debug = () => {
     });
     setColliders(newColliders);
   });
-  return /*#__PURE__*/React.createElement("group", null, colliders.map(handle => /*#__PURE__*/React.createElement(DebugShape, {
+  return /*#__PURE__*/React$1.createElement("group", null, colliders.map(handle => /*#__PURE__*/React$1.createElement(DebugShape, {
     key: handle,
     colliderHandle: handle
   })));
 };
 
-export { BallCollider, CapsuleCollider, ConeCollider, ConvexHullCollider, CuboidCollider, CylinderCollider, Debug, HeightfieldCollider, Physics, RigidBody, RoundCuboidCollider, TrimeshCollider, useCollider, useFixedJoint, useImpulseJoint, usePrismaticJoint, useRapier, useRevoluteJoint, useRigidBody, useSphericalJoint };
+const InstancedRigidBodies = /*#__PURE__*/forwardRef((props, ref) => {
+  const {
+    world,
+    rigidBodyStates,
+    physicsOptions
+  } = useRapier();
+  const object = useRef(null);
+  const instancesRef = useRef();
+  const instancesRefGetter = useRef(() => {
+    if (!instancesRef.current) {
+      instancesRef.current = [];
+    }
+
+    return instancesRef.current;
+  });
+  useEffect(() => {
+    const colliders = [];
+    const rigidBodies = instancesRefGetter.current();
+
+    if (object.current) {
+      const scale = 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);
+          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 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 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 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;
+      };
+    }
+  }, []);
+  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 = useRef(null);
+  useEffect(() => {
+    var _rigidBodyContext$api;
+
+    const scale = ref.current.getWorldScale(new 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"
+  }));
+};
+
+export { BallCollider, CapsuleCollider, ConeCollider, ConvexHullCollider, CuboidCollider, CylinderCollider, Debug, HeightfieldCollider, InstancedRigidBodies, MeshCollider, Physics, RigidBody, RoundCuboidCollider, TrimeshCollider, useFixedJoint, useImpulseJoint, usePrismaticJoint, useRapier, useRevoluteJoint, useRigidBody, useSphericalJoint };