@react-three/rapier 1.2.1 → 1.3.0

package/dist/declarations/src/components/Physics.d.ts

@@ -149,30 +149,34 @@ export interface PhysicsProps {
      */
     gravity?: Vector3Tuple;
     /**
-     * The maximum velocity iterations the velocity-based constraint solver can make to attempt
-     * to remove the energy introduced by constraint stabilization.
-     *
-     * @defaultValue 1
+     * Amount of penetration the engine wont attempt to correct
+     * @defaultValue 0.001
      */
-    maxStabilizationIterations?: number;
+    allowedLinearError?: number;
     /**
-     * The maximum velocity iterations the velocity-based friction constraint solver can make.
-     *
-     * The greater this value is, the most realistic friction will be.
+     * The number of solver iterations run by the constraints solver for calculating forces.
+     * The greater this value is, the most rigid and realistic the physics simulation will be.
      * However a greater number of iterations is more computationally intensive.
      *
-     * @defaultValue 8
+     * @defaultValue 4
      */
-    maxVelocityFrictionIterations?: number;
+    numSolverIterations?: number;
     /**
-     * The maximum velocity iterations the velocity-based force constraint solver can make.
-     *
-     * The greater this value is, the most rigid and realistic the physics simulation will be.
+     * Number of addition friction resolution iteration run during the last solver sub-step.
+     * The greater this value is, the most realistic friction will be.
      * However a greater number of iterations is more computationally intensive.
      *
      * @defaultValue 4
      */
-    maxVelocityIterations?: number;
+    numAdditionalFrictionIterations?: number;
+    /**
+     * Number of internal Project Gauss Seidel (PGS) iterations run at each solver iteration.
+     * Increasing this parameter will improve stability of the simulation. It will have a lesser effect than
+     * increasing `numSolverIterations` but is also less computationally expensive.
+     *
+     * @defaultValue 1
+     */
+    numInternalPgsIterations?: number;
     /**
      * The maximal distance separating two objects that will generate predictive contacts
      *
@@ -181,7 +185,20 @@ export interface PhysicsProps {
      */
     predictionDistance?: number;
     /**
-     * The Error Reduction Parameter in between 0 and 1, is the proportion of the positional error to be corrected at each time step
+     * Minimum number of dynamic bodies in each active island
+     *
+     * @defaultValue 128
+     */
+    minIslandSize?: number;
+    /**
+     * Maximum number of substeps performed by the solver
+     *
+     * @defaultValue 1
+     */
+    maxCcdSubsteps?: number;
+    /**
+     * The Error Reduction Parameter in between 0 and 1, is the proportion of the positional error to be corrected at each time step.
+     *
      * @defaultValue 0.8
      */
     erp?: number;

package/dist/declarations/src/hooks/joints.d.ts

@@ -1,11 +1,11 @@
-import { ImpulseJoint, FixedImpulseJoint, SphericalImpulseJoint, RevoluteImpulseJoint, PrismaticImpulseJoint } from "@dimforge/rapier3d-compat";
-import React, { RefObject } from "react";
-import { RapierRigidBody, UseImpulseJoint, FixedJointParams, SphericalJointParams, RevoluteJointParams, PrismaticJointParams } from "..";
+import { FixedImpulseJoint, ImpulseJoint, PrismaticImpulseJoint, RevoluteImpulseJoint, RopeImpulseJoint, SphericalImpulseJoint, SpringImpulseJoint } from "@dimforge/rapier3d-compat";
+import { RefObject } from "react";
+import { FixedJointParams, PrismaticJointParams, RapierRigidBody, RevoluteJointParams, RopeJointParams, SphericalJointParams, SpringJointParams, UseImpulseJoint } from "..";
 import type Rapier from "@dimforge/rapier3d-compat";
 /**
  * @internal
  */
-export declare const useImpulseJoint: <JointType extends ImpulseJoint>(body1: RefObject<RapierRigidBody>, body2: RefObject<RapierRigidBody>, params: Rapier.JointData) => React.MutableRefObject<JointType | undefined>;
+export declare const useImpulseJoint: <JointType extends ImpulseJoint>(body1: RefObject<RapierRigidBody>, body2: RefObject<RapierRigidBody>, params: Rapier.JointData) => import("react").MutableRefObject<JointType | undefined>;
 /**
  * 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.
@@ -39,3 +39,13 @@ export declare const useRevoluteJoint: UseImpulseJoint<RevoluteJointParams, Revo
  * @category Hooks - Joints
  */
 export declare const usePrismaticJoint: UseImpulseJoint<PrismaticJointParams, PrismaticImpulseJoint>;
+/**
+ * The rope joint limits the max distance between two bodies.
+ * @category Hooks - Joints
+ */
+export declare const useRopeJoint: UseImpulseJoint<RopeJointParams, RopeImpulseJoint>;
+/**
+ * The spring joint applies a force proportional to the distance between two objects.
+ * @category Hooks - Joints
+ */
+export declare const useSpringJoint: UseImpulseJoint<SpringJointParams, SpringImpulseJoint>;

package/dist/declarations/src/types.d.ts

@@ -1,7 +1,7 @@
 import { MutableRefObject, RefObject } from "react";
 import { CoefficientCombineRule, Collider as RapierCollider, ImpulseJoint, InteractionGroups, RigidBody as RapierRigidBody, TempContactManifold } from "@dimforge/rapier3d-compat";
 import { Rotation, Vector } from "@dimforge/rapier3d-compat/math";
-import { Object3DProps } from "@react-three/fiber";
+import { Object3DProps, Vector3, Quaternion } from "@react-three/fiber";
 import { Object3D } from "three";
 import { ColliderProps } from ".";
 import { RigidBodyState } from "./components/Physics";
@@ -305,6 +305,16 @@ export interface RigidBodyOptions extends ColliderProps {
      * This does not affect any non-automatic child collider-components.
      */
     restitution?: number;
+    /**
+     * Sets the number of additional solver iterations that will be run for this
+     * rigid-body and everything that interacts with it directly or indirectly
+     * through contacts or joints.
+     *
+     * Compared to increasing the global `World.numSolverIteration`, setting this
+     * value lets you increase accuracy on only a subset of the scene, resulting in reduced
+     * performance loss.
+     */
+    additionalSolverIterations?: number;
     /**
      * The default collision groups bitmask for all colliders in this rigid body.
      * Can be customized per-collider.
@@ -348,27 +358,39 @@ export interface RigidBodyOptions extends ColliderProps {
     transformState?: (state: RigidBodyState) => RigidBodyState;
 }
 export declare type SphericalJointParams = [
-    body1Anchor: Vector3Tuple,
-    body2Anchor: Vector3Tuple
+    body1Anchor: Vector3,
+    body2Anchor: Vector3
 ];
 export declare type FixedJointParams = [
-    body1Anchor: Vector3Tuple,
-    body1LocalFrame: Vector4Tuple,
-    body2Anchor: Vector3Tuple,
-    body2LocalFrame: Vector4Tuple
+    body1Anchor: Vector3,
+    body1LocalFrame: Quaternion,
+    body2Anchor: Vector3,
+    body2LocalFrame: Quaternion
 ];
 export declare type PrismaticJointParams = [
-    body1Anchor: Vector3Tuple,
-    body2Anchor: Vector3Tuple,
-    axis: Vector3Tuple,
+    body1Anchor: Vector3,
+    body2Anchor: Vector3,
+    axis: Vector3,
     limits?: [min: number, max: number]
 ];
 export declare type RevoluteJointParams = [
-    body1Anchor: Vector3Tuple,
-    body2Anchor: Vector3Tuple,
-    axis: Vector3Tuple,
+    body1Anchor: Vector3,
+    body2Anchor: Vector3,
+    axis: Vector3,
     limits?: [min: number, max: number]
 ];
+export declare type RopeJointParams = [
+    body1Anchor: Vector3,
+    body2Anchor: Vector3,
+    length: number
+];
+export declare type SpringJointParams = [
+    body1Anchor: Vector3,
+    body2Anchor: Vector3,
+    restLength: number,
+    stiffness: number,
+    damping: number
+];
 export interface UseImpulseJoint<JointParams, JointType extends ImpulseJoint> {
     (body1: RefObject<RapierRigidBody>, body2: RefObject<RapierRigidBody>, params: JointParams): RefObject<JointType | undefined>;
 }

package/dist/declarations/src/utils/utils-collider.d.ts

@@ -47,6 +47,7 @@ export declare const cleanRigidBodyPropsForCollider: (props?: RigidBodyProps) =>
     colliders?: RigidBodyAutoCollider | undefined;
     friction?: number | undefined;
     restitution?: number | undefined;
+    additionalSolverIterations?: number | undefined;
     collisionGroups?: number | undefined;
     solverGroups?: number | undefined;
     onSleep?(): void;

package/dist/declarations/src/utils/utils.d.ts

@@ -1,11 +1,13 @@
 import { Quaternion as RapierQuaternion, Vector3 as RapierVector3 } from "@dimforge/rapier3d-compat";
 import { Euler, Quaternion, Vector3 } from "three";
 import { RigidBodyTypeString, Vector3Tuple } from "../types";
+import { Vector3 as Vector3Like, Quaternion as QuaternionLike } from "@react-three/fiber";
 export declare const vectorArrayToVector3: (arr: Vector3Tuple) => Vector3;
-export declare const tupleToObject: <T extends readonly any[], K extends readonly string[]>(tuple: T, keys: K) => { [Key in K[number]]: T[number]; };
 export declare const vector3ToQuaternion: (v: Vector3) => Quaternion;
 export declare const rapierVector3ToVector3: ({ x, y, z }: RapierVector3) => Vector3;
 export declare const rapierQuaternionToQuaternion: ({ x, y, z, w }: RapierQuaternion) => Quaternion;
+export declare const vector3ToRapierVector: (v: Vector3Like) => RapierVector3;
+export declare const quaternionToRapierQuaternion: (v: QuaternionLike) => RapierQuaternion;
 export declare const rigidBodyTypeFromString: (type: RigidBodyTypeString) => 0 | 3 | 1 | 2;
 export declare const scaleVertices: (vertices: ArrayLike<number>, scale: Vector3) => number[];
 export declare const vectorToTuple: (v: Vector3 | Quaternion | any[] | undefined | number | Euler) => any[];

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

@@ -85,18 +85,29 @@ const vectorArrayToVector3 = arr => {
   const [x, y, z] = arr;
   return new three.Vector3(x, y, z);
 };
-const tupleToObject = (tuple, keys) => {
-  return keys.reduce((obj, key, i) => {
-    obj[key] = tuple[i];
-    return obj;
-  }, {});
-};
 const rapierQuaternionToQuaternion = ({
   x,
   y,
   z,
   w
 }) => _quaternion.set(x, y, z, w);
+const vector3ToRapierVector = v => {
+  if (Array.isArray(v)) {
+    return new rapier3dCompat.Vector3(v[0], v[1], v[2]);
+  } else if (typeof v === "number") {
+    return new rapier3dCompat.Vector3(v, v, v);
+  } else {
+    const threeVector3 = v;
+    return new rapier3dCompat.Vector3(threeVector3.x, threeVector3.y, threeVector3.z);
+  }
+};
+const quaternionToRapierQuaternion = v => {
+  if (Array.isArray(v)) {
+    return new rapier3dCompat.Quaternion(v[0], v[1], v[2], v[3]);
+  } else {
+    return new rapier3dCompat.Quaternion(v.x, v.y, v.z, v.w);
+  }
+};
 const rigidBodyTypeMap = {
   fixed: 1,
   dynamic: 0,
@@ -744,10 +755,13 @@ const Physics = props => {
     updateLoop = "follow",
     debug = false,
     gravity = [0, -9.81, 0],
-    maxStabilizationIterations = 1,
-    maxVelocityFrictionIterations = 8,
-    maxVelocityIterations = 4,
+    allowedLinearError = 0.001,
     predictionDistance = 0.002,
+    numSolverIterations = 4,
+    numAdditionalFrictionIterations = 4,
+    numInternalPgsIterations = 1,
+    minIslandSize = 128,
+    maxCcdSubsteps = 1,
     erp = 0.8
   } = props;
   const rapier = useAsset.useAsset(importRapier);
@@ -780,13 +794,16 @@ const Physics = props => {
   }, []); // Update mutable props
 
   React.useEffect(() => {
-    worldProxy.gravity = vectorArrayToVector3(gravity);
-    worldProxy.integrationParameters.maxStabilizationIterations = maxStabilizationIterations;
-    worldProxy.integrationParameters.maxVelocityFrictionIterations = maxVelocityFrictionIterations;
-    worldProxy.integrationParameters.maxVelocityIterations = maxVelocityIterations;
+    worldProxy.gravity = vector3ToRapierVector(gravity);
+    worldProxy.integrationParameters.numSolverIterations = numSolverIterations;
+    worldProxy.integrationParameters.numAdditionalFrictionIterations = numAdditionalFrictionIterations;
+    worldProxy.integrationParameters.numInternalPgsIterations = numInternalPgsIterations;
+    worldProxy.integrationParameters.allowedLinearError = allowedLinearError;
+    worldProxy.integrationParameters.minIslandSize = minIslandSize;
+    worldProxy.integrationParameters.maxCcdSubsteps = maxCcdSubsteps;
     worldProxy.integrationParameters.predictionDistance = predictionDistance;
     worldProxy.integrationParameters.erp = erp;
-  }, [worldProxy, ...gravity, maxStabilizationIterations, maxVelocityIterations, maxVelocityFrictionIterations, predictionDistance, erp]);
+  }, [worldProxy, ...gravity, numSolverIterations, numAdditionalFrictionIterations, numInternalPgsIterations, allowedLinearError, minIslandSize, maxCcdSubsteps, predictionDistance, erp]);
   const getSourceFromColliderHandle = React.useCallback(handle => {
     var _collider$parent;
 
@@ -1375,6 +1392,11 @@ const mutableRigidBodyOptions = {
   gravityScale: (rb, value) => {
     rb.setGravityScale(value, true);
   },
+
+  additionalSolverIterations(rb, value) {
+    rb.setAdditionalSolverIterations(value);
+  },
+
   linearDamping: (rb, value) => {
     rb.setLinearDamping(value);
   },
@@ -1733,7 +1755,7 @@ const useFixedJoint = (body1, body2, [body1Anchor, body1LocalFrame, body2Anchor,
   const {
     rapier
   } = useRapier();
-  return useImpulseJoint(body1, body2, rapier.JointData.fixed(vectorArrayToVector3(body1Anchor), tupleToObject(body1LocalFrame, ["x", "y", "z", "w"]), vectorArrayToVector3(body2Anchor), tupleToObject(body2LocalFrame, ["x", "y", "z", "w"])));
+  return useImpulseJoint(body1, body2, rapier.JointData.fixed(vector3ToRapierVector(body1Anchor), quaternionToRapierQuaternion(body1LocalFrame), vector3ToRapierVector(body2Anchor), quaternionToRapierQuaternion(body2LocalFrame)));
 };
 /**
  * The spherical joint ensures that two points on the local-spaces of two rigid-bodies always coincide (it prevents any relative
@@ -1748,7 +1770,7 @@ const useSphericalJoint = (body1, body2, [body1Anchor, body2Anchor]) => {
   const {
     rapier
   } = useRapier();
-  return useImpulseJoint(body1, body2, rapier.JointData.spherical(vectorArrayToVector3(body1Anchor), vectorArrayToVector3(body2Anchor)));
+  return useImpulseJoint(body1, body2, rapier.JointData.spherical(vector3ToRapierVector(body1Anchor), vector3ToRapierVector(body2Anchor)));
 };
 /**
  * The revolute joint prevents any relative movement between two rigid-bodies, except for relative
@@ -1762,7 +1784,7 @@ const useRevoluteJoint = (body1, body2, [body1Anchor, body2Anchor, axis, limits]
   const {
     rapier
   } = useRapier();
-  const params = rapier.JointData.revolute(vectorArrayToVector3(body1Anchor), vectorArrayToVector3(body2Anchor), vectorArrayToVector3(axis));
+  const params = rapier.JointData.revolute(vector3ToRapierVector(body1Anchor), vector3ToRapierVector(body2Anchor), vector3ToRapierVector(axis));
 
   if (limits) {
     params.limitsEnabled = true;
@@ -1783,7 +1805,7 @@ const usePrismaticJoint = (body1, body2, [body1Anchor, body2Anchor, axis, limits
   const {
     rapier
   } = useRapier();
-  const params = rapier.JointData.prismatic(vectorArrayToVector3(body1Anchor), vectorArrayToVector3(body2Anchor), vectorArrayToVector3(axis));
+  const params = rapier.JointData.prismatic(vector3ToRapierVector(body1Anchor), vector3ToRapierVector(body2Anchor), vector3ToRapierVector(axis));
 
   if (limits) {
     params.limitsEnabled = true;
@@ -1792,6 +1814,34 @@ const usePrismaticJoint = (body1, body2, [body1Anchor, body2Anchor, axis, limits
 
   return useImpulseJoint(body1, body2, params);
 };
+/**
+ * The rope joint limits the max distance between two bodies.
+ * @category Hooks - Joints
+ */
+
+const useRopeJoint = (body1, body2, [body1Anchor, body2Anchor, length]) => {
+  const {
+    rapier
+  } = useRapier();
+  const vBody1Anchor = vector3ToRapierVector(body1Anchor);
+  const vBody2Anchor = vector3ToRapierVector(body2Anchor);
+  const params = rapier.JointData.rope(length, vBody1Anchor, vBody2Anchor);
+  return useImpulseJoint(body1, body2, params);
+};
+/**
+ * The spring joint applies a force proportional to the distance between two objects.
+ * @category Hooks - Joints
+ */
+
+const useSpringJoint = (body1, body2, [body1Anchor, body2Anchor, restLength, stiffness, damping]) => {
+  const {
+    rapier
+  } = useRapier();
+  const vBody1Anchor = vector3ToRapierVector(body1Anchor);
+  const vBody2Anchor = vector3ToRapierVector(body2Anchor);
+  const params = rapier.JointData.spring(restLength, stiffness, damping, vBody1Anchor, vBody2Anchor);
+  return useImpulseJoint(body1, body2, params);
+};
 
 /**
  * Calculates an InteractionGroup bitmask for use in the `collisionGroups` or `solverGroups`
@@ -1867,5 +1917,7 @@ exports.useImpulseJoint = useImpulseJoint;
 exports.usePrismaticJoint = usePrismaticJoint;
 exports.useRapier = useRapier;
 exports.useRevoluteJoint = useRevoluteJoint;
+exports.useRopeJoint = useRopeJoint;
 exports.useSphericalJoint = useSphericalJoint;
+exports.useSpringJoint = useSpringJoint;
 exports.vec3 = vec3;

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

@@ -85,18 +85,29 @@ const vectorArrayToVector3 = arr => {
   const [x, y, z] = arr;
   return new three.Vector3(x, y, z);
 };
-const tupleToObject = (tuple, keys) => {
-  return keys.reduce((obj, key, i) => {
-    obj[key] = tuple[i];
-    return obj;
-  }, {});
-};
 const rapierQuaternionToQuaternion = ({
   x,
   y,
   z,
   w
 }) => _quaternion.set(x, y, z, w);
+const vector3ToRapierVector = v => {
+  if (Array.isArray(v)) {
+    return new rapier3dCompat.Vector3(v[0], v[1], v[2]);
+  } else if (typeof v === "number") {
+    return new rapier3dCompat.Vector3(v, v, v);
+  } else {
+    const threeVector3 = v;
+    return new rapier3dCompat.Vector3(threeVector3.x, threeVector3.y, threeVector3.z);
+  }
+};
+const quaternionToRapierQuaternion = v => {
+  if (Array.isArray(v)) {
+    return new rapier3dCompat.Quaternion(v[0], v[1], v[2], v[3]);
+  } else {
+    return new rapier3dCompat.Quaternion(v.x, v.y, v.z, v.w);
+  }
+};
 const rigidBodyTypeMap = {
   fixed: 1,
   dynamic: 0,
@@ -744,10 +755,13 @@ const Physics = props => {
     updateLoop = "follow",
     debug = false,
     gravity = [0, -9.81, 0],
-    maxStabilizationIterations = 1,
-    maxVelocityFrictionIterations = 8,
-    maxVelocityIterations = 4,
+    allowedLinearError = 0.001,
     predictionDistance = 0.002,
+    numSolverIterations = 4,
+    numAdditionalFrictionIterations = 4,
+    numInternalPgsIterations = 1,
+    minIslandSize = 128,
+    maxCcdSubsteps = 1,
     erp = 0.8
   } = props;
   const rapier = useAsset.useAsset(importRapier);
@@ -780,13 +794,16 @@ const Physics = props => {
   }, []); // Update mutable props
 
   React.useEffect(() => {
-    worldProxy.gravity = vectorArrayToVector3(gravity);
-    worldProxy.integrationParameters.maxStabilizationIterations = maxStabilizationIterations;
-    worldProxy.integrationParameters.maxVelocityFrictionIterations = maxVelocityFrictionIterations;
-    worldProxy.integrationParameters.maxVelocityIterations = maxVelocityIterations;
+    worldProxy.gravity = vector3ToRapierVector(gravity);
+    worldProxy.integrationParameters.numSolverIterations = numSolverIterations;
+    worldProxy.integrationParameters.numAdditionalFrictionIterations = numAdditionalFrictionIterations;
+    worldProxy.integrationParameters.numInternalPgsIterations = numInternalPgsIterations;
+    worldProxy.integrationParameters.allowedLinearError = allowedLinearError;
+    worldProxy.integrationParameters.minIslandSize = minIslandSize;
+    worldProxy.integrationParameters.maxCcdSubsteps = maxCcdSubsteps;
     worldProxy.integrationParameters.predictionDistance = predictionDistance;
     worldProxy.integrationParameters.erp = erp;
-  }, [worldProxy, ...gravity, maxStabilizationIterations, maxVelocityIterations, maxVelocityFrictionIterations, predictionDistance, erp]);
+  }, [worldProxy, ...gravity, numSolverIterations, numAdditionalFrictionIterations, numInternalPgsIterations, allowedLinearError, minIslandSize, maxCcdSubsteps, predictionDistance, erp]);
   const getSourceFromColliderHandle = React.useCallback(handle => {
     var _collider$parent;
 
@@ -1375,6 +1392,11 @@ const mutableRigidBodyOptions = {
   gravityScale: (rb, value) => {
     rb.setGravityScale(value, true);
   },
+
+  additionalSolverIterations(rb, value) {
+    rb.setAdditionalSolverIterations(value);
+  },
+
   linearDamping: (rb, value) => {
     rb.setLinearDamping(value);
   },
@@ -1733,7 +1755,7 @@ const useFixedJoint = (body1, body2, [body1Anchor, body1LocalFrame, body2Anchor,
   const {
     rapier
   } = useRapier();
-  return useImpulseJoint(body1, body2, rapier.JointData.fixed(vectorArrayToVector3(body1Anchor), tupleToObject(body1LocalFrame, ["x", "y", "z", "w"]), vectorArrayToVector3(body2Anchor), tupleToObject(body2LocalFrame, ["x", "y", "z", "w"])));
+  return useImpulseJoint(body1, body2, rapier.JointData.fixed(vector3ToRapierVector(body1Anchor), quaternionToRapierQuaternion(body1LocalFrame), vector3ToRapierVector(body2Anchor), quaternionToRapierQuaternion(body2LocalFrame)));
 };
 /**
  * The spherical joint ensures that two points on the local-spaces of two rigid-bodies always coincide (it prevents any relative
@@ -1748,7 +1770,7 @@ const useSphericalJoint = (body1, body2, [body1Anchor, body2Anchor]) => {
   const {
     rapier
   } = useRapier();
-  return useImpulseJoint(body1, body2, rapier.JointData.spherical(vectorArrayToVector3(body1Anchor), vectorArrayToVector3(body2Anchor)));
+  return useImpulseJoint(body1, body2, rapier.JointData.spherical(vector3ToRapierVector(body1Anchor), vector3ToRapierVector(body2Anchor)));
 };
 /**
  * The revolute joint prevents any relative movement between two rigid-bodies, except for relative
@@ -1762,7 +1784,7 @@ const useRevoluteJoint = (body1, body2, [body1Anchor, body2Anchor, axis, limits]
   const {
     rapier
   } = useRapier();
-  const params = rapier.JointData.revolute(vectorArrayToVector3(body1Anchor), vectorArrayToVector3(body2Anchor), vectorArrayToVector3(axis));
+  const params = rapier.JointData.revolute(vector3ToRapierVector(body1Anchor), vector3ToRapierVector(body2Anchor), vector3ToRapierVector(axis));
 
   if (limits) {
     params.limitsEnabled = true;
@@ -1783,7 +1805,7 @@ const usePrismaticJoint = (body1, body2, [body1Anchor, body2Anchor, axis, limits
   const {
     rapier
   } = useRapier();
-  const params = rapier.JointData.prismatic(vectorArrayToVector3(body1Anchor), vectorArrayToVector3(body2Anchor), vectorArrayToVector3(axis));
+  const params = rapier.JointData.prismatic(vector3ToRapierVector(body1Anchor), vector3ToRapierVector(body2Anchor), vector3ToRapierVector(axis));
 
   if (limits) {
     params.limitsEnabled = true;
@@ -1792,6 +1814,34 @@ const usePrismaticJoint = (body1, body2, [body1Anchor, body2Anchor, axis, limits
 
   return useImpulseJoint(body1, body2, params);
 };
+/**
+ * The rope joint limits the max distance between two bodies.
+ * @category Hooks - Joints
+ */
+
+const useRopeJoint = (body1, body2, [body1Anchor, body2Anchor, length]) => {
+  const {
+    rapier
+  } = useRapier();
+  const vBody1Anchor = vector3ToRapierVector(body1Anchor);
+  const vBody2Anchor = vector3ToRapierVector(body2Anchor);
+  const params = rapier.JointData.rope(length, vBody1Anchor, vBody2Anchor);
+  return useImpulseJoint(body1, body2, params);
+};
+/**
+ * The spring joint applies a force proportional to the distance between two objects.
+ * @category Hooks - Joints
+ */
+
+const useSpringJoint = (body1, body2, [body1Anchor, body2Anchor, restLength, stiffness, damping]) => {
+  const {
+    rapier
+  } = useRapier();
+  const vBody1Anchor = vector3ToRapierVector(body1Anchor);
+  const vBody2Anchor = vector3ToRapierVector(body2Anchor);
+  const params = rapier.JointData.spring(restLength, stiffness, damping, vBody1Anchor, vBody2Anchor);
+  return useImpulseJoint(body1, body2, params);
+};
 
 /**
  * Calculates an InteractionGroup bitmask for use in the `collisionGroups` or `solverGroups`
@@ -1867,5 +1917,7 @@ exports.useImpulseJoint = useImpulseJoint;
 exports.usePrismaticJoint = usePrismaticJoint;
 exports.useRapier = useRapier;
 exports.useRevoluteJoint = useRevoluteJoint;
+exports.useRopeJoint = useRopeJoint;
 exports.useSphericalJoint = useSphericalJoint;
+exports.useSpringJoint = useSpringJoint;
 exports.vec3 = vec3;

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

@@ -1,4 +1,4 @@
-import { ActiveEvents, ColliderDesc, EventQueue, RigidBodyDesc } from '@dimforge/rapier3d-compat';
+import { Vector3 as Vector3$1, Quaternion as Quaternion$1, ActiveEvents, ColliderDesc, EventQueue, RigidBodyDesc } from '@dimforge/rapier3d-compat';
 export { CoefficientCombineRule, Collider as RapierCollider, RigidBody as RapierRigidBody } from '@dimforge/rapier3d-compat';
 import { useFrame, useThree } from '@react-three/fiber';
 import React, { useRef, useEffect, memo, useMemo, useContext, useState, createContext, useCallback, forwardRef, Fragment } from 'react';
@@ -60,18 +60,29 @@ const vectorArrayToVector3 = arr => {
   const [x, y, z] = arr;
   return new Vector3(x, y, z);
 };
-const tupleToObject = (tuple, keys) => {
-  return keys.reduce((obj, key, i) => {
-    obj[key] = tuple[i];
-    return obj;
-  }, {});
-};
 const rapierQuaternionToQuaternion = ({
   x,
   y,
   z,
   w
 }) => _quaternion.set(x, y, z, w);
+const vector3ToRapierVector = v => {
+  if (Array.isArray(v)) {
+    return new Vector3$1(v[0], v[1], v[2]);
+  } else if (typeof v === "number") {
+    return new Vector3$1(v, v, v);
+  } else {
+    const threeVector3 = v;
+    return new Vector3$1(threeVector3.x, threeVector3.y, threeVector3.z);
+  }
+};
+const quaternionToRapierQuaternion = v => {
+  if (Array.isArray(v)) {
+    return new Quaternion$1(v[0], v[1], v[2], v[3]);
+  } else {
+    return new Quaternion$1(v.x, v.y, v.z, v.w);
+  }
+};
 const rigidBodyTypeMap = {
   fixed: 1,
   dynamic: 0,
@@ -719,10 +730,13 @@ const Physics = props => {
     updateLoop = "follow",
     debug = false,
     gravity = [0, -9.81, 0],
-    maxStabilizationIterations = 1,
-    maxVelocityFrictionIterations = 8,
-    maxVelocityIterations = 4,
+    allowedLinearError = 0.001,
     predictionDistance = 0.002,
+    numSolverIterations = 4,
+    numAdditionalFrictionIterations = 4,
+    numInternalPgsIterations = 1,
+    minIslandSize = 128,
+    maxCcdSubsteps = 1,
     erp = 0.8
   } = props;
   const rapier = useAsset(importRapier);
@@ -755,13 +769,16 @@ const Physics = props => {
   }, []); // Update mutable props
 
   useEffect(() => {
-    worldProxy.gravity = vectorArrayToVector3(gravity);
-    worldProxy.integrationParameters.maxStabilizationIterations = maxStabilizationIterations;
-    worldProxy.integrationParameters.maxVelocityFrictionIterations = maxVelocityFrictionIterations;
-    worldProxy.integrationParameters.maxVelocityIterations = maxVelocityIterations;
+    worldProxy.gravity = vector3ToRapierVector(gravity);
+    worldProxy.integrationParameters.numSolverIterations = numSolverIterations;
+    worldProxy.integrationParameters.numAdditionalFrictionIterations = numAdditionalFrictionIterations;
+    worldProxy.integrationParameters.numInternalPgsIterations = numInternalPgsIterations;
+    worldProxy.integrationParameters.allowedLinearError = allowedLinearError;
+    worldProxy.integrationParameters.minIslandSize = minIslandSize;
+    worldProxy.integrationParameters.maxCcdSubsteps = maxCcdSubsteps;
     worldProxy.integrationParameters.predictionDistance = predictionDistance;
     worldProxy.integrationParameters.erp = erp;
-  }, [worldProxy, ...gravity, maxStabilizationIterations, maxVelocityIterations, maxVelocityFrictionIterations, predictionDistance, erp]);
+  }, [worldProxy, ...gravity, numSolverIterations, numAdditionalFrictionIterations, numInternalPgsIterations, allowedLinearError, minIslandSize, maxCcdSubsteps, predictionDistance, erp]);
   const getSourceFromColliderHandle = useCallback(handle => {
     var _collider$parent;
 
@@ -1350,6 +1367,11 @@ const mutableRigidBodyOptions = {
   gravityScale: (rb, value) => {
     rb.setGravityScale(value, true);
   },
+
+  additionalSolverIterations(rb, value) {
+    rb.setAdditionalSolverIterations(value);
+  },
+
   linearDamping: (rb, value) => {
     rb.setLinearDamping(value);
   },
@@ -1708,7 +1730,7 @@ const useFixedJoint = (body1, body2, [body1Anchor, body1LocalFrame, body2Anchor,
   const {
     rapier
   } = useRapier();
-  return useImpulseJoint(body1, body2, rapier.JointData.fixed(vectorArrayToVector3(body1Anchor), tupleToObject(body1LocalFrame, ["x", "y", "z", "w"]), vectorArrayToVector3(body2Anchor), tupleToObject(body2LocalFrame, ["x", "y", "z", "w"])));
+  return useImpulseJoint(body1, body2, rapier.JointData.fixed(vector3ToRapierVector(body1Anchor), quaternionToRapierQuaternion(body1LocalFrame), vector3ToRapierVector(body2Anchor), quaternionToRapierQuaternion(body2LocalFrame)));
 };
 /**
  * The spherical joint ensures that two points on the local-spaces of two rigid-bodies always coincide (it prevents any relative
@@ -1723,7 +1745,7 @@ const useSphericalJoint = (body1, body2, [body1Anchor, body2Anchor]) => {
   const {
     rapier
   } = useRapier();
-  return useImpulseJoint(body1, body2, rapier.JointData.spherical(vectorArrayToVector3(body1Anchor), vectorArrayToVector3(body2Anchor)));
+  return useImpulseJoint(body1, body2, rapier.JointData.spherical(vector3ToRapierVector(body1Anchor), vector3ToRapierVector(body2Anchor)));
 };
 /**
  * The revolute joint prevents any relative movement between two rigid-bodies, except for relative
@@ -1737,7 +1759,7 @@ const useRevoluteJoint = (body1, body2, [body1Anchor, body2Anchor, axis, limits]
   const {
     rapier
   } = useRapier();
-  const params = rapier.JointData.revolute(vectorArrayToVector3(body1Anchor), vectorArrayToVector3(body2Anchor), vectorArrayToVector3(axis));
+  const params = rapier.JointData.revolute(vector3ToRapierVector(body1Anchor), vector3ToRapierVector(body2Anchor), vector3ToRapierVector(axis));
 
   if (limits) {
     params.limitsEnabled = true;
@@ -1758,7 +1780,7 @@ const usePrismaticJoint = (body1, body2, [body1Anchor, body2Anchor, axis, limits
   const {
     rapier
   } = useRapier();
-  const params = rapier.JointData.prismatic(vectorArrayToVector3(body1Anchor), vectorArrayToVector3(body2Anchor), vectorArrayToVector3(axis));
+  const params = rapier.JointData.prismatic(vector3ToRapierVector(body1Anchor), vector3ToRapierVector(body2Anchor), vector3ToRapierVector(axis));
 
   if (limits) {
     params.limitsEnabled = true;
@@ -1767,6 +1789,34 @@ const usePrismaticJoint = (body1, body2, [body1Anchor, body2Anchor, axis, limits
 
   return useImpulseJoint(body1, body2, params);
 };
+/**
+ * The rope joint limits the max distance between two bodies.
+ * @category Hooks - Joints
+ */
+
+const useRopeJoint = (body1, body2, [body1Anchor, body2Anchor, length]) => {
+  const {
+    rapier
+  } = useRapier();
+  const vBody1Anchor = vector3ToRapierVector(body1Anchor);
+  const vBody2Anchor = vector3ToRapierVector(body2Anchor);
+  const params = rapier.JointData.rope(length, vBody1Anchor, vBody2Anchor);
+  return useImpulseJoint(body1, body2, params);
+};
+/**
+ * The spring joint applies a force proportional to the distance between two objects.
+ * @category Hooks - Joints
+ */
+
+const useSpringJoint = (body1, body2, [body1Anchor, body2Anchor, restLength, stiffness, damping]) => {
+  const {
+    rapier
+  } = useRapier();
+  const vBody1Anchor = vector3ToRapierVector(body1Anchor);
+  const vBody2Anchor = vector3ToRapierVector(body2Anchor);
+  const params = rapier.JointData.spring(restLength, stiffness, damping, vBody1Anchor, vBody2Anchor);
+  return useImpulseJoint(body1, body2, params);
+};
 
 /**
  * Calculates an InteractionGroup bitmask for use in the `collisionGroups` or `solverGroups`
@@ -1804,4 +1854,4 @@ const interactionGroups = (memberships, filters) => (bitmask(memberships) << 16)
 
 const bitmask = groups => [groups].flat().reduce((acc, layer) => acc | 1 << layer, 0);
 
-export { AnyCollider, BallCollider, CapsuleCollider, ConeCollider, ConvexHullCollider, CuboidCollider, CylinderCollider, HeightfieldCollider, InstancedRigidBodies, MeshCollider, Physics, RigidBody, RoundConeCollider, RoundCuboidCollider, RoundCylinderCollider, TrimeshCollider, euler, interactionGroups, quat, useAfterPhysicsStep, useBeforePhysicsStep, useFixedJoint, useImpulseJoint, usePrismaticJoint, useRapier, useRevoluteJoint, useSphericalJoint, vec3 };
+export { AnyCollider, BallCollider, CapsuleCollider, ConeCollider, ConvexHullCollider, CuboidCollider, CylinderCollider, HeightfieldCollider, InstancedRigidBodies, MeshCollider, Physics, RigidBody, RoundConeCollider, RoundCuboidCollider, RoundCylinderCollider, TrimeshCollider, euler, interactionGroups, quat, useAfterPhysicsStep, useBeforePhysicsStep, useFixedJoint, useImpulseJoint, usePrismaticJoint, useRapier, useRevoluteJoint, useRopeJoint, useSphericalJoint, useSpringJoint, vec3 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@react-three/rapier",
-  "version": "1.2.1",
+  "version": "1.3.0",
   "source": "src/index.ts",
   "main": "dist/react-three-rapier.cjs.js",
   "module": "dist/react-three-rapier.esm.js",
@@ -29,7 +29,7 @@
     "three": ">=0.139.0"
   },
   "dependencies": {
-    "@dimforge/rapier3d-compat": "0.11.2",
+    "@dimforge/rapier3d-compat": "0.12.0",
     "three-stdlib": "2.23.9",
     "use-asset": "1.0.4"
   },

package/readme.md

@@ -78,6 +78,8 @@ For full API outline and documentation, see 🧩 [API Docs](https://pmndrs.githu
   - [Spherical Joint](#spherical-joint)
   - [Revolute Joint](#revolute-joint)
   - [Prismatic Joint](#prismatic-joint)
+  - [Rope Joint](#rope-joint)
+  - [Spring Joint](#spring-joint)
   - [🖼 Joints Example](#-joints-example)
 - [Advanced hooks usage](#advanced-hooks-usage)
   - [Manual stepping](#manual-stepping)
@@ -623,12 +625,14 @@ Joints can be made between two `RigidBodies` to provide a way to restrict a moti
 
 Joints are available in `r3/rapier` as hooks.
 
-There are 4 different joint types available:
+There are 6 different joint types available:
 
 - Fixed (two bodies are fixed together)
 - Spherical (two bodies are connected by a ball and socket, for things like arms or chains)
 - Revolute (two bodies are connected by a hinge, for things like doors or wheels)
 - Prismatic (two bodies are connected by a sliding joint, for things like pistons or sliders)
+- Rope (limits the max distance between two bodies)
+- Spring (applies a force proportional to the distance between two bodies)
 
 Each joint hook returns a RefObject containing the raw reference to the joint instance.
 
@@ -658,6 +662,9 @@ A fixed joint ensures that two rigid-bodies don't move relative to each other. F
 
 ```tsx
 const JointedThing = () => {
+  const bodyA = useRef<RapierRigidBody>(null);
+  const bodyB = useRef<RapierRigidBody>(null);
+
   const joint = useFixedJoint(bodyA, bodyB, [
     // Position of the joint in bodyA's local space
     [0, 0, 0],
@@ -690,6 +697,9 @@ The spherical joint ensures that two points on the local-spaces of two rigid-bod
 
 ```tsx
 const JointedThing = () => {
+  const bodyA = useRef<RapierRigidBody>(null);
+  const bodyB = useRef<RapierRigidBody>(null);
+
   const joint = useSphericalJoint(bodyA, bodyB, [
     // Position of the joint in bodyA's local space
     [0, 0, 0],
@@ -718,6 +728,9 @@ The revolute joint prevents any relative movement between two rigid-bodies, exce
 
 ```tsx
 const JointedThing = () => {
+  const bodyA = useRef<RapierRigidBody>(null);
+  const bodyB = useRef<RapierRigidBody>(null);
+  
   const joint = useRevoluteJoint(bodyA, bodyB, [
     // Position of the joint in bodyA's local space
     [0, 0, 0],
@@ -749,6 +762,9 @@ The prismatic joint prevents any relative movement between two rigid-bodies, exc
 
 ```tsx
 const JointedThing = () => {
+  const bodyA = useRef<RapierRigidBody>(null);
+  const bodyB = useRef<RapierRigidBody>(null);
+
   const joint = usePrismaticJoint(bodyA, bodyB, [
     // Position of the joint in bodyA's local space
     [0, 0, 0],
@@ -772,6 +788,83 @@ const JointedThing = () => {
 };
 ```
 
+### Rope Joint
+
+The rope joint limits the max distance between two bodies.
+
+🧩 See [RopeJoint docs](https://pmndrs.github.io/react-three-rapier/functions/useRopeJoint.html) for available options.
+
+```tsx
+const JointedThing = () => {
+  const bodyA = useRef<RapierRigidBody>(null);
+  const bodyB = useRef<RapierRigidBody>(null);
+
+  const joint = useRopeJoint(bodyA, bodyB, [
+    // Position of the joint in bodyA's local space
+    [0, 0, 0],
+    // Position of the joint in bodyB's local space
+    [0, 0, 0],
+    // The max distance between the two bodies / length of the rope
+    1
+  ]);
+
+  return (
+    <group>
+      <RigidBody ref={bodyA}>
+        <mesh />
+      </RigidBody>
+      <RigidBody ref={bodyB}>
+        <mesh />
+      </RigidBody>
+    </group>
+  );
+};
+```
+
+### Spring Joint
+
+The spring joint applies a force proportional to the distance between two bodies.
+
+🧩 See [SpringJoint docs](https://pmndrs.github.io/react-three-rapier/functions/useSpringJoint.html) for available options.
+
+```tsx
+const JointedThing = () => {
+  const bodyA = useRef<RapierRigidBody>(null);
+  const bodyB = useRef<RapierRigidBody>(null);
+
+  const mass = 1;
+  const springRestLength = 0;
+  const stiffness = 1.0e3;
+  const criticalDamping = 2.0 * Math.sqrt(stiffness * mass);
+  const dampingRatio = props.jointNum / (props.total / 2);
+  const damping = dampingRatio * criticalDamping;
+
+  const joint = useSpringJoint(bodyA, bodyB, [
+    // Position of the joint in bodyA's local space
+    [0, 0, 0],
+    // Position of the joint in bodyB's local space
+    [0, 0, 0],
+    // Spring rest length
+    springRestLength,
+    // Spring stiffness
+    stiffness,
+    // Spring damping
+    damping
+  ]);
+
+  return (
+    <group>
+      <RigidBody ref={bodyA}>
+        <mesh />
+      </RigidBody>
+      <RigidBody ref={bodyB}>
+        <mesh />
+      </RigidBody>
+    </group>
+  );
+};
+```
+
 ### 🖼 Joints Example
 
 <a href="https://codesandbox.io/s/react-three-rapier-joints-mhhbd4"><img src="https://raw.githubusercontent.com/pmndrs/react-three-rapier/HEAD/packages/react-three-rapier/misc/example-joints.jpg" width="240" /></a>