@react-three/rapier 0.1.0

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

@@ -0,0 +1,842 @@
+import React, { useRef, useMemo, createContext, useContext, useEffect, useLayoutEffect, forwardRef, useImperativeHandle, useState, memo } from 'react';
+import { useAsset } from 'use-asset';
+import { useFrame } from '@react-three/fiber';
+import { ColliderDesc, CoefficientCombineRule, ShapeType } from '@dimforge/rapier3d-compat';
+export { CoefficientCombineRule, Collider as RapierCollider, RigidBody as RapierRigidBody } from '@dimforge/rapier3d-compat';
+import { Quaternion, Vector3, Object3D, Euler, CylinderBufferGeometry, BufferGeometry, BufferAttribute, SphereBufferGeometry, BoxBufferGeometry } from 'three';
+
+const vectorArrayToObject = arr => {
+  const [x, y, z] = arr;
+  return {
+    x,
+    y,
+    z
+  };
+};
+const rigidBodyTypeMap = {
+  fixed: 1,
+  dynamic: 0,
+  kinematicPosition: 2,
+  kinematicVelocity: 3
+};
+const rigidBodyTypeFromString = type => rigidBodyTypeMap[type];
+const scaleColliderArgs = (shape, args, scale) => {
+  // Heightfield only scales the last arg
+  const newArgs = args.slice();
+
+  if (shape === "heightfield") {
+    newArgs[3] *= scale.x;
+    return newArgs;
+  } // Trimesh and convex scale the vertices
+
+
+  if (shape === "trimesh" || shape === "convexHull") {
+    newArgs[0] = scaleVertices(newArgs[0], scale);
+    return newArgs;
+  }
+
+  const scaleArray = [scale.x, scale.y, scale.z];
+  return newArgs.map((arg, index) => scaleArray[index] * arg);
+};
+const createColliderFromOptions = (options, world, body, scale = {
+  x: 1,
+  y: 1,
+  z: 1
+}) => {
+  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]; // @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
+  }).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 any of the mass properties are specified, add mass properties
+
+  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: 0,
+      y: 0,
+      z: 0,
+      w: 1
+    });
+  }
+
+  const collider = world.createCollider(colliderDesc, body.handle);
+  return collider;
+};
+const createCollidersFromChildren = (object, rigidBody, type, world) => {
+  const colliders = [];
+  let desc;
+  object.traverse(child => {
+    if ("isMesh" in child) {
+      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());
+
+      switch (type) {
+        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;
+      } // We translate the colliders based on the parent's world scale
+
+
+      const parentWorldScale = child.parent.getWorldScale(new Vector3());
+      desc.setTranslation(x * parentWorldScale.x, y * parentWorldScale.y, z * parentWorldScale.z).setRotation({
+        x: rx,
+        y: ry,
+        z: rz,
+        w: rw
+      });
+      const collider = world.createCollider(desc, rigidBody.handle);
+      colliders.push(collider);
+    }
+  });
+  return colliders;
+};
+const scaleVertices = (vertices, scale) => {
+  const scaledVerts = Array.from(vertices);
+
+  for (let i = 0; i < vertices.length / 3; i++) {
+    scaledVerts[i * 3] *= scale.x;
+    scaledVerts[i * 3 + 1] *= scale.y;
+    scaledVerts[i * 3 + 2] *= scale.z;
+  }
+
+  return scaledVerts;
+};
+
+const RapierContext = /*#__PURE__*/createContext(undefined);
+
+const importRapier = async () => {
+  let r = await import('@dimforge/rapier3d-compat');
+  await r.init();
+  return r;
+};
+
+const Physics = ({
+  colliders: _colliders = 'cuboid',
+  gravity: _gravity = [0, -9.81, 0],
+  children
+}) => {
+  const rapier = useAsset(importRapier);
+  const stepFuncs = useRef([]);
+  const world = useMemo(() => {
+    if (!rapier.World) return null;
+    let world = new rapier.World(vectorArrayToObject(_gravity));
+    return world;
+  }, [rapier]);
+  const time = useRef(performance.now());
+  useFrame(context => {
+    // Set timestep to current delta, to allow for variable frame rates
+    // We cap the delta at 100, so that the physics simulation doesn't get wild
+    const now = performance.now();
+    const delta = Math.min(100, now - time.current);
+    world.timestep = delta / 1000;
+    world.step(); // Run all step funcs
+
+    stepFuncs.current.forEach(func => func());
+    time.current = now;
+  });
+  const context = useMemo(() => ({
+    RAPIER: rapier,
+    world,
+    colliders: _colliders,
+    stepFuncs: stepFuncs.current
+  }), [rapier]);
+  return /*#__PURE__*/React.createElement(RapierContext.Provider, {
+    value: context
+  }, children);
+};
+
+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);
+}; // Private hook for updating the simulations on objects
+
+const useRapierStep = callback => {
+  const {
+    stepFuncs
+  } = useRapier();
+  useEffect(() => {
+    stepFuncs.push(callback);
+    return () => {
+      const index = stepFuncs.indexOf(callback);
+      stepFuncs.splice(index, 1);
+    };
+  }, [callback]);
+};
+const useCollider = (body, options = {}) => {
+  const {
+    RAPIER,
+    world
+  } = useRapier();
+  const collider = useMemo(() => {
+    return createColliderFromOptions(options, world, body);
+  }, []);
+  useEffect(() => {
+    return () => {
+      world.removeCollider(collider, false);
+    };
+  }, []);
+  return [collider];
+};
+const useRigidBody = options => {
+  const {
+    RAPIER,
+    world
+  } = useRapier();
+  const ref = useRef(); // Create rigidbody
+
+  const rigidBody = useMemo(() => {
+    var _options$linearVeloci, _options$angularVeloc, _options$gravityScale, _options$canSleep, _options$ccd;
+
+    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 type = rigidBodyTypeFromString((options === null || options === void 0 ? void 0 : options.type) || "dynamic");
+    (options === null || options === void 0 ? void 0 : options.position) || [0, 0, 0];
+    (options === null || options === void 0 ? void 0 : options.rotation) || [0, 0, 0];
+    const rigidBodyDesc = new RAPIER.RigidBodyDesc(type).setLinvel(lvx, lvy, lvz).setAngvel({
+      x: avx,
+      y: avy,
+      z: avz
+    }).setGravityScale(gravityScale).setCanSleep(canSleep).setCcdEnabled(ccdEnabled).setTranslation(0, 0, 0);
+    const body = world.createRigidBody(rigidBodyDesc);
+    return body;
+  }, []); // Setup
+
+  useEffect(() => {
+    var _ref$current$parent, _options$colliders;
+
+    if (!ref.current) {
+      ref.current = new Object3D();
+    } // 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 eulerAngles = new Euler(rx, ry, rz, 'XYZ');
+    const rotation = new Quaternion().setFromEuler(eulerAngles).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 = (_options$colliders = options === null || options === void 0 ? void 0 : options.colliders) !== null && _options$colliders !== void 0 ? _options$colliders : false;
+    const autoColliders = colliderSetting !== false ? createCollidersFromChildren(ref.current, rigidBody, colliderSetting, world) : [];
+    return () => {
+      world.removeRigidBody(rigidBody);
+      autoColliders.forEach(collider => world.removeCollider(collider, false));
+    };
+  }, []);
+  useRapierStep(() => {
+    if (rigidBody && ref.current) {
+      const {
+        x,
+        y,
+        z
+      } = rigidBody.translation();
+      const {
+        x: rx,
+        y: ry,
+        z: rz,
+        w: rw
+      } = rigidBody.rotation();
+      const scale = ref.current.getWorldScale(new Vector3());
+
+      if (ref.current.parent) {
+        // 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(ref.current.parent.matrixWorld.clone().invert());
+        o.updateMatrix();
+        ref.current.position.setFromMatrixPosition(o.matrix);
+        ref.current.rotation.setFromRotationMatrix(o.matrix);
+      }
+    }
+  });
+  return [ref, rigidBody];
+};
+const useRigidBodyWithCollider = (rigidBodyOptions, colliderOptions) => {
+  const {
+    world
+  } = useRapier();
+  const [ref, rigidBody] = useRigidBody(rigidBodyOptions);
+  useEffect(() => {
+    if (!colliderOptions) {
+      return;
+    }
+
+    const scale = ref.current.getWorldScale(new Vector3());
+    const collider = createColliderFromOptions(colliderOptions, world, rigidBody, scale);
+    return () => {
+      world.removeCollider(collider, false);
+    };
+  }, []);
+  return [ref, rigidBody];
+};
+const useCuboid = (rigidBodyOptions = {}, colliderOptions = {}) => {
+  var _colliderOptions$args;
+
+  return useRigidBodyWithCollider(rigidBodyOptions, _objectSpread2({
+    shape: "cuboid",
+    args: (_colliderOptions$args = colliderOptions.args) !== null && _colliderOptions$args !== void 0 ? _colliderOptions$args : [0.5, 0.5, 0.5]
+  }, colliderOptions));
+};
+const useBall = (rigidBodyOptions = {}, colliderOptions = {}) => {
+  var _colliderOptions$args2;
+
+  return useRigidBodyWithCollider(rigidBodyOptions, _objectSpread2({
+    shape: "ball",
+    args: (_colliderOptions$args2 = colliderOptions.args) !== null && _colliderOptions$args2 !== void 0 ? _colliderOptions$args2 : [0.5]
+  }, colliderOptions));
+};
+const useCapsule = (rigidBodyOptions = {}, colliderOptions = {}) => {
+  var _colliderOptions$args3;
+
+  return useRigidBodyWithCollider(rigidBodyOptions, _objectSpread2({
+    shape: "capsule",
+    args: (_colliderOptions$args3 = colliderOptions.args) !== null && _colliderOptions$args3 !== void 0 ? _colliderOptions$args3 : [0.5, 0.5]
+  }, colliderOptions));
+};
+const useHeightfield = (rigidBodyOptions = {}, colliderOptions = {}) => {
+  return useRigidBodyWithCollider(rigidBodyOptions, _objectSpread2({
+    shape: "heightfield"
+  }, colliderOptions));
+};
+/**
+ * Create a trimesh collider and rigid body.
+ * Note that Trimeshes don't have mass unless provided.
+ * See https://rapier.rs/docs/user_guides/javascript/rigid_bodies#mass-properties
+ * for available properties.
+ */
+
+const useTrimesh = (rigidBodyOptions = {}, colliderOptions = {}) => {
+  return useRigidBodyWithCollider(rigidBodyOptions, _objectSpread2({
+    shape: "trimesh"
+  }, colliderOptions));
+};
+
+useTrimesh.fromMesh = (mesh, rigidBodyOptions = {}, colliderOptions = {}) => {
+  var _mesh$geometry, _mesh$geometry$index;
+
+  return useTrimesh(rigidBodyOptions, _objectSpread2({
+    args: [mesh.geometry.attributes.position.array, ((_mesh$geometry = mesh.geometry) === null || _mesh$geometry === void 0 ? void 0 : (_mesh$geometry$index = _mesh$geometry.index) === null || _mesh$geometry$index === void 0 ? void 0 : _mesh$geometry$index.array) || []]
+  }, colliderOptions));
+};
+
+const usePolyline = (rigidBodyOptions = {}, colliderOptions = {}) => {
+  return useRigidBodyWithCollider(rigidBodyOptions, _objectSpread2({
+    shape: "polyline"
+  }, colliderOptions));
+};
+const useRoundCuboid = (rigidBodyOptions = {}, colliderOptions = {}) => {
+  return useRigidBodyWithCollider(rigidBodyOptions, _objectSpread2({
+    shape: "roundCuboid"
+  }, colliderOptions));
+};
+const useCylinder = (rigidBodyOptions = {}, colliderOptions = {}) => {
+  return useRigidBodyWithCollider(rigidBodyOptions, _objectSpread2({
+    shape: "cylinder"
+  }, colliderOptions));
+};
+const useRoundCylinder = (rigidBodyOptions = {}, colliderOptions = {}) => {
+  return useRigidBodyWithCollider(rigidBodyOptions, _objectSpread2({
+    shape: "roundCylinder"
+  }, colliderOptions));
+};
+const useCone = (rigidBodyOptions = {}, colliderOptions = {}) => {
+  return useRigidBodyWithCollider(rigidBodyOptions, _objectSpread2({
+    shape: "cone"
+  }, colliderOptions));
+};
+const useRoundCone = (rigidBodyOptions = {}, colliderOptions = {}) => {
+  return useRigidBodyWithCollider(rigidBodyOptions, _objectSpread2({
+    shape: "roundCone"
+  }, colliderOptions));
+};
+const useConvexHull = (rigidBodyOptions = {}, colliderOptions = {}) => {
+  return useRigidBodyWithCollider(rigidBodyOptions, _objectSpread2({
+    shape: "convexHull"
+  }, colliderOptions));
+};
+
+useConvexHull.fromMesh = (mesh, rigidBodyOptions = {}, colliderOptions = {}) => {
+  var _mesh$geometry2, _mesh$geometry2$attri, _mesh$geometry2$attri2;
+
+  return useConvexHull(rigidBodyOptions, _objectSpread2({
+    args: [(mesh === null || mesh === void 0 ? void 0 : (_mesh$geometry2 = mesh.geometry) === null || _mesh$geometry2 === void 0 ? void 0 : (_mesh$geometry2$attri = _mesh$geometry2.attributes) === null || _mesh$geometry2$attri === void 0 ? void 0 : (_mesh$geometry2$attri2 = _mesh$geometry2$attri.position) === null || _mesh$geometry2$attri2 === void 0 ? void 0 : _mesh$geometry2$attri2.array) || []]
+  }, colliderOptions));
+};
+
+const useRoundConvexHull = (rigidBodyOptions = {}, colliderOptions = {}) => {
+  return useRigidBodyWithCollider(rigidBodyOptions, _objectSpread2({
+    shape: "roundConvexHull"
+  }, colliderOptions));
+};
+const useConvexMesh = (rigidBodyOptions = {}, colliderOptions = {}) => {
+  return useRigidBodyWithCollider(rigidBodyOptions, _objectSpread2({
+    shape: "convexMesh"
+  }, colliderOptions));
+};
+
+useConvexMesh.fromMesh = (mesh, rigidBodyOptions = {}, colliderOptions = {}) => {
+  var _mesh$geometry3, _mesh$geometry3$attri, _mesh$geometry3$attri2, _mesh$geometry4, _mesh$geometry4$index;
+
+  return useConvexMesh(rigidBodyOptions, _objectSpread2({
+    args: [mesh === null || mesh === void 0 ? void 0 : (_mesh$geometry3 = mesh.geometry) === null || _mesh$geometry3 === void 0 ? void 0 : (_mesh$geometry3$attri = _mesh$geometry3.attributes) === null || _mesh$geometry3$attri === void 0 ? void 0 : (_mesh$geometry3$attri2 = _mesh$geometry3$attri.position) === null || _mesh$geometry3$attri2 === void 0 ? void 0 : _mesh$geometry3$attri2.array, ((_mesh$geometry4 = mesh.geometry) === null || _mesh$geometry4 === void 0 ? void 0 : (_mesh$geometry4$index = _mesh$geometry4.index) === null || _mesh$geometry4$index === void 0 ? void 0 : _mesh$geometry4$index.array) || []]
+  }, colliderOptions));
+};
+
+const useRoundConvexMesh = (rigidBodyOptions = {}, colliderOptions = {}) => {
+  return useRigidBodyWithCollider(rigidBodyOptions, _objectSpread2({
+    shape: "convexMesh"
+  }, colliderOptions));
+}; // Joints
+
+const useImpulseJoint = (body1, body2, params) => {
+  const {
+    world,
+    RAPIER
+  } = useRapier();
+  useLayoutEffect(() => {
+    let joint;
+
+    if (body1 && body2 && params) {
+      joint = world.createImpulseJoint(params, body1.current, body2.current);
+    }
+
+    return () => {
+      if (joint) world.removeImpulseJoint(joint, true);
+    };
+  }, [body1, body2]);
+};
+/**
+ *
+ * A fixed joint ensures that two rigid-bodies don't move relative to each other.
+ * Fixed joints are characterized by one local frame (represented by an isometry) on each rigid-body.
+ * The fixed-joint makes these frames coincide in world-space.
+ */
+
+const useFixedJoint = (body1, body2, [body1Anchor, body1LocalFrame, body2Anchor, body2LocalFrame]) => {
+  const {
+    RAPIER
+  } = useRapier();
+  return useImpulseJoint(body1, body2, RAPIER.JointData.fixed(vectorArrayToObject(body1Anchor), _objectSpread2(_objectSpread2({}, vectorArrayToObject(body1LocalFrame)), {}, {
+    w: 1
+  }), vectorArrayToObject(body2Anchor), _objectSpread2(_objectSpread2({}, vectorArrayToObject(body2LocalFrame)), {}, {
+    w: 1
+  })));
+};
+/**
+ * The spherical joint ensures that two points on the local-spaces of two rigid-bodies always coincide (it prevents any relative
+ * translational motion at this points). This is typically used to simulate ragdolls arms, pendulums, etc.
+ * They are characterized by one local anchor on each rigid-body. Each anchor represents the location of the
+ * points that need to coincide on the local-space of each rigid-body.
+ */
+
+const useSphericalJoint = (body1, body2, [body1Anchor, body2Anchor]) => {
+  const {
+    RAPIER
+  } = useRapier();
+  return useImpulseJoint(body1, body2, RAPIER.JointData.spherical(vectorArrayToObject(body1Anchor), vectorArrayToObject(body2Anchor)));
+};
+/**
+ * The revolute joint prevents any relative movement between two rigid-bodies, except for relative
+ * rotations along one axis. This is typically used to simulate wheels, fans, etc.
+ * They are characterized by one local anchor as well as one local axis on each rigid-body.
+ */
+
+const useRevoluteJoint = (body1, body2, [body1Anchor, body2Anchor, axis]) => {
+  const {
+    RAPIER
+  } = useRapier();
+  return useImpulseJoint(body1, body2, RAPIER.JointData.revolute(vectorArrayToObject(body1Anchor), vectorArrayToObject(body2Anchor), vectorArrayToObject(axis)));
+};
+/**
+ * The prismatic joint prevents any relative movement between two rigid-bodies, except for relative translations along one axis.
+ * It is characterized by one local anchor as well as one local axis on each rigid-body. In 3D, an optional
+ * local tangent axis can be specified for each rigid-body.
+ */
+
+const usePrismaticJoint = (body1, body2, [body1Anchor, body2Anchor, axis]) => {
+  const {
+    RAPIER
+  } = useRapier();
+  return useImpulseJoint(body1, body2, RAPIER.JointData.prismatic(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"];
+const RigidBodyContext = /*#__PURE__*/createContext(undefined);
+
+const useParentRigidBody = () => useContext(RigidBodyContext); // RigidBody
+
+
+const RigidBody = /*#__PURE__*/forwardRef((_ref, ref) => {
+  let {
+    children
+  } = _ref,
+      props = _objectWithoutProperties(_ref, _excluded);
+
+  const [group, rigidBody] = useRigidBody(props);
+  useImperativeHandle(ref, () => rigidBody);
+  return /*#__PURE__*/React.createElement(RigidBodyContext.Provider, {
+    value: [group, rigidBody]
+  }, /*#__PURE__*/React.createElement("group", {
+    ref: group
+  }, children));
+}); // Colliders
+
+const AnyCollider = props => {
+  const {
+    world
+  } = useRapier();
+  const [object, rigidBody] = useParentRigidBody();
+  useEffect(() => {
+    const scale = object.current.getWorldScale(new Vector3());
+    const collider = createColliderFromOptions(props, world, rigidBody, scale);
+    return () => {
+      world.removeCollider(collider, false);
+    };
+  }, []);
+  return null;
+};
+
+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.shapeType()) {
+    case ShapeType.Cuboid:
+      {
+        const {
+          x,
+          y,
+          z
+        } = collider.halfExtents();
+        return new BoxBufferGeometry(x * 2 + 0.01, y * 2 + 0.01, z * 2 + 0.01);
+      }
+
+    case ShapeType.Ball:
+      {
+        const r = collider.radius();
+        return new SphereBufferGeometry(r + +0.01, 8, 8);
+      }
+
+    case ShapeType.TriMesh:
+      {
+        var _g$index;
+
+        const v = collider.vertices();
+        const i = collider.indices();
+        const g = new BufferGeometry();
+        g.setAttribute("position", new BufferAttribute(v, 3));
+        (_g$index = g.index) === null || _g$index === void 0 ? void 0 : _g$index.set(i);
+        g.setDrawRange(0, g.attributes.position.array.length / 3 - 1);
+        return g;
+      }
+
+    case ShapeType.ConvexPolyhedron:
+      {
+        const cv = collider.vertices();
+        const cg = new BufferGeometry();
+        cg.setAttribute("position", new BufferAttribute(cv, 3));
+        return cg;
+      }
+
+    case ShapeType.Cylinder:
+      {
+        const r = collider.radius();
+        const h = collider.halfHeight();
+        const g = new CylinderBufferGeometry(r, r, h);
+        return g;
+      }
+  }
+
+  return new BoxBufferGeometry(1, 1, 1);
+};
+
+const DebugShape = /*#__PURE__*/memo(({
+  colliderHandle
+}) => {
+  const {
+    world
+  } = useRapier();
+  const ref = useRef(null);
+  useFrame(() => {
+    const collider = world.getCollider(colliderHandle);
+
+    if (ref.current && collider) {
+      const {
+        x: rx,
+        y: ry,
+        z: rz,
+        w: rw
+      } = collider.rotation();
+      const {
+        x,
+        y,
+        z
+      } = collider.translation();
+      ref.current.position.set(x, y, z);
+      ref.current.rotation.setFromQuaternion(new Quaternion(rx, ry, rz, rw));
+    }
+  });
+  const geometry = useMemo(() => {
+    const collider = world.getCollider(colliderHandle);
+    return geometryFromCollider(collider);
+  }, [colliderHandle]);
+  return /*#__PURE__*/React.createElement("mesh", {
+    ref: ref
+  }, /*#__PURE__*/React.createElement("primitive", {
+    object: geometry,
+    attach: "geometry"
+  }), /*#__PURE__*/React.createElement("meshBasicMaterial", {
+    color: "red",
+    wireframe: true
+  }));
+});
+const Debug = () => {
+  const {
+    world
+  } = useRapier();
+  const [colliders, setColliders] = useState([]);
+  useRef({});
+
+  useFrame(() => {
+    const newColliders = [];
+    world.colliders.forEachCollider(collider => {
+      newColliders.push(collider.handle);
+    });
+    setColliders(newColliders);
+  });
+  return /*#__PURE__*/React.createElement("group", null, colliders.map(handle => /*#__PURE__*/React.createElement(DebugShape, {
+    key: handle,
+    colliderHandle: handle
+  })));
+};
+
+export { BallCollider, CapsuleCollider, ConeCollider, ConvexHullCollider, CuboidCollider, CylinderCollider, Debug, HeightfieldCollider, Physics, RigidBody, RoundCuboidCollider, TrimeshCollider, useBall, useCapsule, useCollider, useCone, useConvexHull, useConvexMesh, useCuboid, useCylinder, useFixedJoint, useHeightfield, useImpulseJoint, usePolyline, usePrismaticJoint, useRapier, useRevoluteJoint, useRigidBody, useRigidBodyWithCollider, useRoundCone, useRoundConvexHull, useRoundConvexMesh, useRoundCuboid, useRoundCylinder, useSphericalJoint, useTrimesh };