@react-three/rapier 0.6.4 → 0.6.7

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

@@ -7,6 +7,8 @@ var React = require('react');
 var useAsset = require('use-asset');
 var fiber = require('@react-three/fiber');
 var three = require('three');
+var BufferGeometryUtils = require('three/examples/jsm/utils/BufferGeometryUtils');
+var threeStdlib = require('three-stdlib');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { 'default': e }; }
 
@@ -73,11 +75,13 @@ const decomposeMatrix4 = m => {
   };
 };
 const scaleColliderArgs = (shape, args, scale) => {
-  // Heightfield only scales the last arg
-  const newArgs = args.slice();
+  const newArgs = args.slice(); // Heightfield uses a vector
 
   if (shape === "heightfield") {
-    newArgs[3] *= scale.x;
+    const s = newArgs[3];
+    s.x *= scale.x;
+    s.x *= scale.y;
+    s.x *= scale.z;
     return newArgs;
   } // Trimesh and convex scale the vertices
 
@@ -85,9 +89,10 @@ const scaleColliderArgs = (shape, args, scale) => {
   if (shape === "trimesh" || shape === "convexHull") {
     newArgs[0] = scaleVertices(newArgs[0], scale);
     return newArgs;
-  }
+  } // Prepfill with some extra
+
 
-  const scaleArray = [scale.x, scale.y, scale.z];
+  const scaleArray = [scale.x, scale.y, scale.z, scale.x, scale.x];
   return newArgs.map((arg, index) => scaleArray[index] * arg);
 };
 const createColliderFromOptions = ({
@@ -117,6 +122,10 @@ const createColliderFromOptions = ({
     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 : rapier3dCompat.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 : rapier3dCompat.CoefficientCombineRule.Average);
 
+  if (colliderShape === "heightfield") {
+    console.log(colliderDesc);
+  }
+
   if (hasCollisionEvents) {
     colliderDesc = colliderDesc.setActiveEvents(rapier3dCompat.ActiveEvents.COLLISION_EVENTS);
   } // If any of the mass properties are specified, add mass properties
@@ -244,15 +253,15 @@ const colliderDescFromGeometry = (geometry, colliders, scale, hasCollisionEvents
       {
         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);
+        const clonedGeometry = geometry.index ? geometry.clone() : BufferGeometryUtils.mergeVertices(geometry);
+        const g = clonedGeometry.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);
       {
+        const g = geometry.clone().scale(scale.x, scale.y, scale.z);
         desc = rapier3dCompat.ColliderDesc.convexHull(g.attributes.position.array);
       }
       break;
@@ -469,10 +478,15 @@ const Physics = ({
   colliders: _colliders = "cuboid",
   gravity: _gravity = [0, -9.81, 0],
   children,
-  timeStep: _timeStep = "vary",
+  timeStep: _timeStep = 1 / 60,
+  maxSubSteps: _maxSubSteps = 10,
   paused: _paused = false
 }) => {
   const rapier = useAsset.useAsset(importRapier);
+  const [isPaused, setIsPaused] = React.useState(_paused);
+  React.useEffect(() => {
+    setIsPaused(_paused);
+  }, [_paused]);
   const worldRef = React.useRef();
   const getWorldRef = React.useRef(() => {
     if (!worldRef.current) {
@@ -492,7 +506,6 @@ const Physics = ({
     return () => {
       if (world) {
         world.free();
-        worldRef.current = undefined;
       }
     };
   }, []); // Update gravity
@@ -504,22 +517,46 @@ const Physics = ({
       world.gravity = vectorArrayToVector3(_gravity);
     }
   }, [_gravity]);
-  const time = React.useRef(performance.now());
-  fiber.useFrame(context => {
+  const [steppingState] = React.useState({
+    time: 0,
+    lastTime: 0,
+    accumulator: 0
+  });
+  fiber.useFrame((_, delta) => {
     const world = worldRef.current;
-    if (!world) return; // 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);
-
-    if (_timeStep === "vary") {
-      world.timestep = delta / 1000;
-    } else {
-      world.timestep = _timeStep;
+    if (!world) return;
+    world.timestep = _timeStep;
+    /**
+     * Fixed timeStep simulation progression
+     * @see https://gafferongames.com/post/fix_your_timestep/ 
+    */
+
+    let previousTranslations = {}; // don't step time forwards if paused
+
+    const nowTime = steppingState.time += _paused ? 0 : delta * 1000;
+    const timeStepMs = _timeStep * 1000;
+    const timeSinceLast = nowTime - steppingState.lastTime;
+    steppingState.lastTime = nowTime;
+    steppingState.accumulator += timeSinceLast;
+
+    if (!_paused) {
+      let subSteps = 0;
+
+      while (steppingState.accumulator >= timeStepMs && subSteps < _maxSubSteps) {
+        // Collect previous state
+        world.bodies.forEach(b => {
+          previousTranslations[b.handle] = {
+            rotation: rapierQuaternionToQuaternion(b.rotation()).normalize(),
+            translation: rapierVector3ToVector3(b.translation())
+          };
+        });
+        world.step(eventQueue);
+        subSteps++;
+        steppingState.accumulator -= timeStepMs;
+      }
     }
 
-    if (!_paused) world.step(eventQueue); // Update meshes
+    const interpolationAlpha = steppingState.accumulator % timeStepMs / timeStepMs; // Update meshes
 
     rigidBodyStates.forEach((state, handle) => {
       const rigidBody = world.getRigidBody(handle);
@@ -541,11 +578,16 @@ const Physics = ({
         state.isSleeping = rigidBody.isSleeping();
       }
 
-      if (!rigidBody || rigidBody.isSleeping() || rigidBody.isFixed() || !state.setMatrix) {
+      if (!rigidBody || rigidBody.isSleeping() || !state.setMatrix) {
         return;
       }
 
-      state.setMatrix(_matrix4.compose(rapierVector3ToVector3(rigidBody.translation()), rapierQuaternionToQuaternion(rigidBody.rotation()), state.worldScale).premultiply(state.invertedMatrixWorld));
+      let oldState = previousTranslations[rigidBody.handle];
+      let newTranslation = rapierVector3ToVector3(rigidBody.translation());
+      let newRotation = rapierQuaternionToQuaternion(rigidBody.rotation());
+      let interpolatedTranslation = oldState ? oldState.translation.lerp(newTranslation, 1) : newTranslation;
+      let interpolatedRotation = oldState ? oldState.rotation.slerp(newRotation, interpolationAlpha) : newRotation;
+      state.setMatrix(_matrix4.compose(interpolatedTranslation, interpolatedRotation, state.worldScale).premultiply(state.invertedMatrixWorld));
 
       if (state.mesh instanceof three.InstancedMesh) {
         state.mesh.instanceMatrix.needsUpdate = true;
@@ -595,7 +637,6 @@ const Physics = ({
         });
       }
     });
-    time.current = now;
   });
   const api = React.useMemo(() => createWorldApi(getWorldRef), []);
   const context = React.useMemo(() => ({
@@ -607,13 +648,32 @@ const Physics = ({
     },
     colliderMeshes,
     rigidBodyStates,
-    rigidBodyEvents
-  }), []);
+    rigidBodyEvents,
+    isPaused
+  }), [isPaused]);
   return /*#__PURE__*/React__default["default"].createElement(RapierContext.Provider, {
     value: context
   }, 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);
+}
+
 function _objectWithoutPropertiesLoose(source, excluded) {
   if (source == null) return {};
   var target = {};
@@ -880,7 +940,8 @@ const usePrismaticJoint = (body1, body2, [body1Anchor, body2Anchor, axis]) => {
   return useImpulseJoint(body1, body2, rapier.JointData.prismatic(vectorArrayToVector3(body1Anchor), vectorArrayToVector3(body2Anchor), vectorArrayToVector3(axis)));
 };
 
-const _excluded$1 = ["children"];
+const _excluded$1 = ["children"],
+      _excluded2 = ["type", "position", "rotation"];
 const RigidBodyContext = /*#__PURE__*/React.createContext(undefined);
 const useRigidBodyContext = () => React.useContext(RigidBodyContext); // RigidBody
 
@@ -891,6 +952,9 @@ const RigidBody = /*#__PURE__*/React.forwardRef((_ref, ref) => {
       props = _objectWithoutProperties(_ref, _excluded$1);
 
   const [object, api] = useRigidBody(props);
+
+  const objectProps = _objectWithoutProperties(props, _excluded2);
+
   React.useImperativeHandle(ref, () => api);
   return /*#__PURE__*/React__default["default"].createElement(RigidBodyContext.Provider, {
     value: {
@@ -899,9 +963,9 @@ const RigidBody = /*#__PURE__*/React.forwardRef((_ref, ref) => {
       hasCollisionEvents: !!(props.onCollisionEnter || props.onCollisionExit),
       options: props
     }
-  }, /*#__PURE__*/React__default["default"].createElement("object3D", {
+  }, /*#__PURE__*/React__default["default"].createElement("object3D", _extends({
     ref: object
-  }, children));
+  }, objectProps), children));
 });
 
 const MeshCollider = ({
@@ -964,6 +1028,17 @@ const geometryFromCollider = collider => {
         return new three.BoxBufferGeometry(x * 2 + 0.01, y * 2 + 0.01, z * 2 + 0.01);
       }
 
+    case rapier3dCompat.ShapeType.RoundCuboid:
+      {
+        const {
+          x,
+          y,
+          z
+        } = collider.shape.halfExtents;
+        const radius = collider.shape.borderRadius;
+        return new threeStdlib.RoundedBoxGeometry(x * 2 + radius * 2, y * 2 + radius * 2, z * 2 + radius * 2, 8, radius);
+      }
+
     case rapier3dCompat.ShapeType.Ball:
       {
         const r = collider.shape.radius;
@@ -999,7 +1074,38 @@ const geometryFromCollider = collider => {
       {
         const r = collider.shape.radius;
         const h = collider.shape.halfHeight;
-        const g = new three.CylinderBufferGeometry(r, r, h);
+        const g = new three.CylinderBufferGeometry(r, r, h * 2);
+        return g;
+      }
+
+    case rapier3dCompat.ShapeType.Capsule:
+      {
+        const r = collider.shape.radius;
+        const h = collider.shape.halfHeight;
+        const g = new three.CapsuleBufferGeometry(r, h * 2, 4, 8);
+        return g;
+      }
+
+    case rapier3dCompat.ShapeType.Cone:
+      {
+        const r = collider.shape.radius;
+        const h = collider.shape.halfHeight;
+        const g = new three.ConeBufferGeometry(r, h * 2, 16);
+        return g;
+      }
+
+    case rapier3dCompat.ShapeType.HeightField:
+      {
+        const rows = collider.shape.nrows;
+        const cols = collider.shape.ncols;
+        const heights = collider.shape.heights;
+        const scale = collider.shape.scale;
+        const g = new three.PlaneGeometry(scale.x, scale.z, cols, rows);
+        const verts = g.attributes.position.array;
+        verts.forEach((v, index) => verts[index * 3 + 2] = heights[index] * scale.y);
+        g.scale(1, -1, 1);
+        g.rotateX(-Math.PI / 2);
+        g.rotateY(-Math.PI / 2);
         return g;
       }
   }
@@ -1008,12 +1114,18 @@ const geometryFromCollider = collider => {
 };
 
 const DebugShape = /*#__PURE__*/React.memo(({
-  colliderHandle
+  colliderHandle,
+  color,
+  sleepColor
 }) => {
   const {
     world
   } = useRapier();
   const ref = React.useRef(null);
+  const [material] = React.useState(new three.MeshBasicMaterial({
+    color,
+    wireframe: true
+  }));
   fiber.useFrame(() => {
     const collider = world.getCollider(colliderHandle);
 
@@ -1029,6 +1141,14 @@ const DebugShape = /*#__PURE__*/React.memo(({
         y,
         z
       } = collider.translation();
+      const parent = collider.parent();
+
+      if (parent !== null && parent !== void 0 && parent.isSleeping() || parent !== null && parent !== void 0 && parent.isFixed() || parent !== null && parent !== void 0 && parent.isKinematic()) {
+        material.color = new three.Color(sleepColor);
+      } else {
+        material.color = new three.Color(color);
+      }
+
       ref.current.position.set(x, y, z);
       ref.current.rotation.setFromQuaternion(new three.Quaternion(rx, ry, rz, rw));
     }
@@ -1038,16 +1158,17 @@ const DebugShape = /*#__PURE__*/React.memo(({
     return geometryFromCollider(collider);
   }, [colliderHandle]);
   return /*#__PURE__*/React__default["default"].createElement("mesh", {
-    ref: ref
+    ref: ref,
+    material: material
   }, /*#__PURE__*/React__default["default"].createElement("primitive", {
     object: geometry,
     attach: "geometry"
-  }), /*#__PURE__*/React__default["default"].createElement("meshBasicMaterial", {
-    color: "red",
-    wireframe: true
   }));
 });
-const Debug = () => {
+const Debug = ({
+  color: _color = "red",
+  sleepColor: _sleepColor = "blue"
+}) => {
   const {
     world
   } = useRapier();
@@ -1063,7 +1184,9 @@ const Debug = () => {
   });
   return /*#__PURE__*/React__default["default"].createElement("group", null, colliders.map(handle => /*#__PURE__*/React__default["default"].createElement(DebugShape, {
     key: handle,
-    colliderHandle: handle
+    colliderHandle: handle,
+    color: _color,
+    sleepColor: _sleepColor
   })));
 };
 
@@ -1191,24 +1314,6 @@ const InstancedRigidBodies = /*#__PURE__*/React.forwardRef((props, ref) => {
   }, 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 => {