@react-three/rapier 0.6.9 → 0.7.1

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

@@ -1,6 +1,10 @@
-import { ReactNode } from "react";
+import React, { ReactNode } from "react";
 import { UseColliderOptions, CuboidArgs, RoundCuboidArgs, BallArgs, CapsuleArgs, HeightfieldArgs, TrimeshArgs, ConeArgs, CylinderArgs, ConvexHullArgs } from "./types";
-declare type UseColliderOptionsRequiredArgs<T> = Omit<UseColliderOptions<T>, "args"> & {
+export interface ColliderProps extends UseColliderOptions<any> {
+    children?: ReactNode;
+}
+export declare const AnyCollider: React.MemoExoticComponent<(props: ColliderProps) => JSX.Element>;
+declare type UseColliderOptionsRequiredArgs<T extends unknown[]> = Omit<UseColliderOptions<T>, "args"> & {
     args: T;
     children?: ReactNode;
 };

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

@@ -2,7 +2,7 @@ import React from "react";
 import { InstancedRigidBodyApi } from "./api";
 import { RigidBodyProps } from "./RigidBody";
 import { Vector3Array } from "./types";
-export interface InstancedRigidBodiesProps extends Omit<RigidBodyProps, "position" | "rotation" | "onCollisionEnter" | "onCollisionExit"> {
+export interface InstancedRigidBodiesProps extends Omit<RigidBodyProps, "position" | "rotation"> {
     positions?: Vector3Array[];
     rotations?: Vector3Array[];
     scales?: Vector3Array[];

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

@@ -4,5 +4,5 @@ interface MeshColliderProps {
     children: ReactNode;
     type: RigidBodyAutoCollider;
 }
-export declare const MeshCollider: ({ children, type }: MeshColliderProps) => JSX.Element;
+export declare const MeshCollider: (props: MeshColliderProps) => JSX.Element;
 export {};

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

@@ -1,32 +1,51 @@
 import React, { FC, ReactNode } from "react";
 import type Rapier from "@dimforge/rapier3d-compat";
-import { CollisionEnterHandler, CollisionExitHandler, RigidBodyAutoCollider, Vector3Array, WorldApi } from "./types";
-import { ColliderHandle, RigidBodyHandle } from "@dimforge/rapier3d-compat";
+import { CollisionEnterHandler, CollisionExitHandler, IntersectionEnterHandler, IntersectionExitHandler, RigidBodyAutoCollider, Vector3Array, WorldApi } from "./types";
+import { Collider, ColliderHandle, RigidBody, RigidBodyHandle } from "@dimforge/rapier3d-compat";
 import { Matrix4, Object3D, Vector3 } from "three";
+export interface RigidBodyState {
+    rigidBody: RigidBody;
+    object: Object3D;
+    invertedWorldMatrix: Matrix4;
+    setMatrix: (matrix: Matrix4) => void;
+    getMatrix: (matrix: Matrix4) => Matrix4;
+    /**
+     * Required for instanced rigid bodies.
+     */
+    scale: Vector3;
+    isSleeping: boolean;
+}
+export declare type RigidBodyStateMap = Map<RigidBody['handle'], RigidBodyState>;
+export interface ColliderState {
+    collider: Collider;
+    object: Object3D;
+    /**
+     * The parent of which this collider needs to base its
+     * world position on
+     */
+    worldParent: Object3D;
+}
+export declare type ColliderStateMap = Map<Collider['handle'], ColliderState>;
 export interface RapierContext {
     rapier: typeof Rapier;
     world: WorldApi;
-    rigidBodyStates: Map<RigidBodyHandle, {
-        mesh: Object3D;
-        isSleeping: boolean;
-        setMatrix(mat: Matrix4): void;
-        getMatrix(): Matrix4;
-        worldScale: Vector3;
-        invertedMatrixWorld: Matrix4;
-    }>;
+    rigidBodyStates: RigidBodyStateMap;
+    colliderStates: ColliderStateMap;
+    rigidBodyEvents: EventMap;
+    colliderEvents: EventMap;
     physicsOptions: {
         colliders: RigidBodyAutoCollider;
     };
-    rigidBodyEvents: EventMap;
-    colliderEvents: EventMap;
     isPaused: boolean;
 }
 export declare const RapierContext: React.Context<RapierContext | undefined>;
-declare type EventMap = Map<ColliderHandle | RigidBodyHandle, {
+export declare type EventMap = Map<ColliderHandle | RigidBodyHandle, {
     onSleep?(): void;
     onWake?(): void;
     onCollisionEnter?: CollisionEnterHandler;
     onCollisionExit?: CollisionExitHandler;
+    onIntersectionEnter?: IntersectionEnterHandler;
+    onIntersectionExit?: IntersectionExitHandler;
 }>;
 interface RapierWorldProps {
     children: ReactNode;
@@ -49,12 +68,6 @@ interface RapierWorldProps {
      * @defaultValue 1/60
      */
     timeStep?: number;
-    /**
-     * Maximum number of fixed steps to take per function call.
-     *
-     * @defaultValue 10
-     */
-    maxSubSteps?: number;
     /**
      * Pause the physics simulation
      *

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

@@ -7,13 +7,11 @@ import { RigidBodyApi, UseRigidBodyOptions } from "./types";
 export declare const RigidBodyContext: React.Context<{
     ref: RefObject<Object3D> | MutableRefObject<Object3D>;
     api: RigidBodyApi | InstancedRigidBodyApi;
-    hasCollisionEvents: boolean;
     options: UseRigidBodyOptions | InstancedRigidBodiesProps;
 }>;
 export declare const useRigidBodyContext: () => {
     ref: RefObject<Object3D> | MutableRefObject<Object3D>;
     api: RigidBodyApi | InstancedRigidBodyApi;
-    hasCollisionEvents: boolean;
     options: UseRigidBodyOptions | InstancedRigidBodiesProps;
 };
 export interface RigidBodyProps extends UseRigidBodyOptions {

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

@@ -4,7 +4,9 @@ import { Object3D } from "three";
 import type Rapier from "@dimforge/rapier3d-compat";
 export declare const useRapier: () => RapierContext;
 import { UseRigidBodyOptions, UseImpulseJoint, SphericalJointParams, FixedJointParams, PrismaticJointParams, RevoluteJointParams, RigidBodyApi, RigidBodyApiRef } from "./types";
-export declare const useRigidBody: <O extends Object3D<import("three").Event>>(options?: UseRigidBodyOptions) => [React.MutableRefObject<O>, import("./api").RigidBodyApi];
+import { ColliderProps, RigidBodyProps } from ".";
+export declare const useChildColliderProps: <O extends Object3D<import("three").Event>>(ref: React.MutableRefObject<O | null | undefined>, options: RigidBodyProps, ignoreMeshColliders?: boolean) => ColliderProps[];
+export declare const useRigidBody: <O extends Object3D<import("three").Event>>(options?: UseRigidBodyOptions) => [React.MutableRefObject<O>, import("./api").RigidBodyApi, ColliderProps[]];
 export declare const useImpulseJoint: <T extends Rapier.ImpulseJoint>(body1: RigidBodyApiRef, body2: RigidBodyApiRef, params: Rapier.JointData) => {
     raw: () => Rapier.ImpulseJoint | undefined;
     readonly handle: number;

package/dist/declarations/src/shared-objects.d.ts

@@ -4,3 +4,6 @@ export declare const _euler: Euler;
 export declare const _vector3: Vector3;
 export declare const _object3d: Object3D<import("three").Event>;
 export declare const _matrix4: Matrix4;
+export declare const _position: Vector3;
+export declare const _rotation: Quaternion;
+export declare const _scale: Vector3;

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

@@ -1,6 +1,9 @@
 import { MutableRefObject } from "react";
 import { CoefficientCombineRule, Collider as RapierCollider, InteractionGroups, RigidBody as RapierRigidBody, TempContactManifold } from "@dimforge/rapier3d-compat";
 import { createColliderApi, createJointApi, createRigidBodyApi, createWorldApi } from "./api";
+import { ColliderProps } from ".";
+import { Object3DProps } from "@react-three/fiber";
+import { Object3D } from "three";
 export { CoefficientCombineRule as CoefficientCombineRule } from "@dimforge/rapier3d-compat";
 export { RapierRigidBody, RapierCollider };
 export declare type RefGetter<T> = MutableRefObject<() => T | undefined>;
@@ -66,20 +69,20 @@ export declare type RoundConvexMeshArgs = [
 ];
 export declare type UseBodyOptions = Omit<UseRigidBodyOptions, "shape">;
 export declare type RigidBodyTypeString = "fixed" | "dynamic" | "kinematicPosition" | "kinematicVelocity";
-export declare type RigidBodyShape = "cuboid" | "trimesh" | "ball" | "capsule" | "convexHull" | "heightfield" | "polyline" | "roundCuboid" | "cylinder" | "roundCylinder" | "cone" | "roundCone" | "convexMesh" | "roundConvexHull" | "roundConvexMesh";
+export declare type ColliderShape = "cuboid" | "trimesh" | "ball" | "capsule" | "convexHull" | "heightfield" | "polyline" | "roundCuboid" | "cylinder" | "roundCylinder" | "cone" | "roundCone" | "convexMesh" | "roundConvexHull" | "roundConvexMesh";
 export declare type Vector3Array = [x: number, y: number, z: number];
 export declare type Boolean3Array = [x: boolean, y: boolean, z: boolean];
-export interface UseColliderOptions<ColliderArgs> {
+export interface UseColliderOptions<ColliderArgs extends Array<unknown>> {
     /**
      * The shape of your collider
      */
-    shape?: RigidBodyShape;
+    shape?: ColliderShape;
     /**
      * Arguments to pass to the collider
      */
     args?: ColliderArgs;
     /**
-     * The mass of this rigid body.
+     * The mass of this collider.
      * The mass and density is automatically calculated based on the shape of the collider.
      * Generally, it's not recommended to adjust the mass properties as it could lead to
      * unexpected behaviors.
@@ -120,6 +123,14 @@ export interface UseColliderOptions<ColliderArgs> {
      * The rotation of this collider relative to the rigid body
      */
     rotation?: Vector3Array;
+    /**
+     * The rotation, as a Quaternion, of this collider relative to the rigid body
+     */
+    quaternion?: Object3DProps['quaternion'];
+    /**
+     * The scale of this collider relative to the rigid body
+     */
+    scale?: Object3DProps['scale'];
     /**
      * Callback when this collider collides with another collider.
      */
@@ -128,6 +139,14 @@ export interface UseColliderOptions<ColliderArgs> {
      * Callback when this collider stops colliding with another collider.
      */
     onCollisionExit?: CollisionExitHandler;
+    /**
+     * Callback when this collider, or another collider starts intersecting, and at least one of them is a `sensor`.
+     */
+    onIntersectionEnter?: IntersectionEnterHandler;
+    /**
+     * Callback when this, or another collider stops intersecting, and at least one of them is a `sensor`.
+     */
+    onIntersectionExit?: IntersectionExitHandler;
     /**
      * The bit mask configuring the groups and mask for collision handling.
      */
@@ -136,20 +155,36 @@ export interface UseColliderOptions<ColliderArgs> {
      * The bit mask configuring the groups and mask for solver handling.
      */
     solverGroups?: InteractionGroups;
+    /**
+     * Sets the uniform density of this collider.
+     */
+    density?: number;
+    /**
+     * Sets whether or not this collider is a sensor.
+     */
+    sensor?: boolean;
 }
 export declare type CollisionEnterPayload = {
-    target: RapierRigidBody;
+    rigidBody?: RapierRigidBody;
     collider: RapierCollider;
     manifold: TempContactManifold;
     flipped: boolean;
+    rigidBodyObject?: Object3D;
+    colliderObject?: Object3D;
 };
 export declare type CollisionExitPayload = {
-    target: RapierRigidBody;
+    rigidBody?: RapierRigidBody;
     collider: RapierCollider;
+    rigidBodyObject?: Object3D;
+    colliderObject?: Object3D;
 };
+export declare type IntersectionEnterPayload = CollisionExitPayload;
+export declare type IntersectionExitPayload = CollisionExitPayload;
 export declare type CollisionEnterHandler = (payload: CollisionEnterPayload) => void;
 export declare type CollisionExitHandler = (payload: CollisionExitPayload) => void;
-export interface UseRigidBodyOptions {
+export declare type IntersectionEnterHandler = (payload: IntersectionEnterPayload) => void;
+export declare type IntersectionExitHandler = (payload: IntersectionExitPayload) => void;
+export interface UseRigidBodyOptions extends ColliderProps {
     /**
      * Specify the type of this rigid body
      */
@@ -162,11 +197,11 @@ export interface UseRigidBodyOptions {
     linearDamping?: number;
     /** The angular damping coefficient of this rigid-body.*/
     angularDamping?: number;
-    /** The linear velocity of this body.
+    /** The initial linear velocity of this body.
      * default: zero velocity
      */
     linearVelocity?: Vector3Array;
-    /** The angular velocity of this body.
+    /** The initial angular velocity of this body.
      * Default: zero velocity.
      */
     angularVelocity?: Vector3Array;
@@ -209,14 +244,6 @@ export interface UseRigidBodyOptions {
      * This does not affect any non-automatic child collider-components.
      */
     restitution?: number;
-    /**
-     * Callback when this rigidbody collides with another rigidbody
-     */
-    onCollisionEnter?: CollisionEnterHandler;
-    /**
-     * Callback when this rigidbody stops colliding with another rigidbody
-     */
-    onCollisionExit?: CollisionExitHandler;
     /**
      * The default collision groups bitmask for all colliders in this rigid body.
      * Can be customized per-collider.
@@ -245,6 +272,10 @@ export interface UseRigidBodyOptions {
      * Allow rotation of this rigid-body only along specific axes.
      */
     enabledTranslations?: Boolean3Array;
+    /**
+     * Passed down to the object3d representing this collider.
+     */
+    userData?: Object3DProps['userData'];
 }
 export declare type SphericalJointParams = [
     body1Anchor: Vector3Array,

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

@@ -0,0 +1,36 @@
+import { Collider, RigidBody } from "@dimforge/rapier3d-compat";
+import { MutableRefObject } from "react";
+import { Vector3, Object3D, BufferGeometry } from "three";
+import { ColliderProps, RigidBodyProps } from ".";
+import { WorldApi } from "./api";
+import { ColliderState, ColliderStateMap, EventMap } from "./Physics";
+import { ColliderShape, RigidBodyAutoCollider } from "./types";
+export declare const scaleColliderArgs: (shape: ColliderShape, args: (number | ArrayLike<number> | {
+    x: number;
+    y: number;
+    z: number;
+})[], scale: Vector3) => (number | ArrayLike<number> | {
+    x: number;
+    y: number;
+    z: number;
+})[];
+export declare const createColliderFromOptions: (options: ColliderProps, world: WorldApi, scale: Vector3, rigidBody?: RigidBody | undefined) => Collider;
+declare type ImmutableColliderOptions = (keyof ColliderProps)[];
+export declare const immutableColliderOptions: ImmutableColliderOptions;
+export declare const setColliderOptions: (collider: Collider, options: ColliderProps, states: ColliderStateMap) => void;
+export declare const useUpdateColliderOptions: (collidersRef: MutableRefObject<Collider[]>, props: ColliderProps, states: ColliderStateMap) => void;
+export declare const createColliderState: (collider: Collider, object: Object3D, rigidBodyObject?: Object3D<import("three").Event> | null | undefined) => ColliderState;
+interface CreateColliderPropsFromChildren {
+    (options: {
+        object: Object3D;
+        ignoreMeshColliders: boolean;
+        options: RigidBodyProps;
+    }): ColliderProps[];
+}
+export declare const createColliderPropsFromChildren: CreateColliderPropsFromChildren;
+export declare const getColliderArgsFromGeometry: (geometry: BufferGeometry, colliders: RigidBodyAutoCollider) => {
+    args: unknown[];
+    offset: Vector3;
+};
+export declare const useColliderEvents: (collidersRef: MutableRefObject<Collider[] | undefined>, props: ColliderProps, events: EventMap) => void;
+export {};

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

@@ -0,0 +1,20 @@
+import { RigidBody, RigidBodyDesc } from "@dimforge/rapier3d-compat";
+import { MutableRefObject } from "react";
+import { Matrix4, Object3D, Vector3 } from "three";
+import { RigidBodyProps } from ".";
+import { EventMap, RigidBodyState, RigidBodyStateMap } from "./Physics";
+export declare const rigidBodyDescFromOptions: (options: RigidBodyProps) => RigidBodyDesc;
+interface CreateRigidBodyStateOptions {
+    object: Object3D;
+    rigidBody: RigidBody;
+    setMatrix?: (matrix: Matrix4) => void;
+    getMatrix?: (matrix: Matrix4) => Matrix4;
+    worldScale?: Vector3;
+}
+export declare const createRigidBodyState: ({ rigidBody, object, setMatrix, getMatrix, worldScale }: CreateRigidBodyStateOptions) => RigidBodyState;
+declare type ImmutableRigidBodyOptions = (keyof RigidBodyProps)[];
+export declare const immutableRigidBodyOptions: ImmutableRigidBodyOptions;
+export declare const setRigidBodyOptions: (rigidBody: RigidBody, options: RigidBodyProps, states: RigidBodyStateMap, updateTranslations?: boolean) => void;
+export declare const useUpdateRigidBodyOptions: (rigidBodyRef: MutableRefObject<RigidBody | RigidBody[] | undefined>, props: RigidBodyProps, states: RigidBodyStateMap, updateTranslations?: boolean) => void;
+export declare const useRigidBodyEvents: (rigidBodyRef: MutableRefObject<RigidBody | RigidBody[] | undefined>, props: RigidBodyProps, events: EventMap) => void;
+export {};

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

@@ -1,50 +1,9 @@
-import { Collider, ColliderDesc, Quaternion as RapierQuaternion, RigidBody, RigidBodyDesc, Vector3 as RapierVector3 } from "@dimforge/rapier3d-compat";
-import { BufferGeometry, Matrix4, Object3D, Quaternion, Vector3 } from "three";
-import { RigidBodyApi, RigidBodyAutoCollider, RigidBodyShape, RigidBodyTypeString, UseColliderOptions, UseRigidBodyOptions, Vector3Array, WorldApi } from "./types";
+import { Quaternion as RapierQuaternion, Vector3 as RapierVector3 } from "@dimforge/rapier3d-compat";
+import { Vector3 } from "three";
+import { RigidBodyTypeString, Vector3Array } from "./types";
 export declare const vectorArrayToVector3: (arr: Vector3Array) => Vector3;
-export declare const vector3ToQuaternion: (v: Vector3) => Quaternion;
+export declare const vector3ToQuaternion: (v: Vector3) => import("three").Quaternion;
 export declare const rapierVector3ToVector3: ({ x, y, z }: RapierVector3) => Vector3;
-export declare const rapierQuaternionToQuaternion: ({ x, y, z, w }: RapierQuaternion) => Quaternion;
+export declare const rapierQuaternionToQuaternion: ({ x, y, z, w }: RapierQuaternion) => import("three").Quaternion;
 export declare const rigidBodyTypeFromString: (type: RigidBodyTypeString) => number;
-export declare const decomposeMatrix4: (m: Matrix4) => {
-    position: Vector3;
-    rotation: Quaternion;
-    scale: Vector3;
-};
-export declare const scaleColliderArgs: (shape: RigidBodyShape, args: (number | ArrayLike<number> | {
-    x: number;
-    y: number;
-    z: number;
-})[], scale: Vector3) => (number | ArrayLike<number> | {
-    x: number;
-    y: number;
-    z: number;
-})[];
-interface CreateColliderFromOptions {
-    <ColliderArgs>(options: {
-        options: UseColliderOptions<ColliderArgs>;
-        world: WorldApi;
-        rigidBody?: RigidBody;
-        scale: {
-            x: number;
-            y: number;
-            z: number;
-        };
-        hasCollisionEvents: boolean;
-    }): Collider;
-}
-export declare const createColliderFromOptions: CreateColliderFromOptions;
-interface CreateCollidersFromChildren {
-    (options: {
-        object: Object3D;
-        rigidBody?: Pick<RigidBodyApi | RigidBody, "handle">;
-        options: UseRigidBodyOptions;
-        world: WorldApi;
-        ignoreMeshColliders: boolean;
-    }): Collider[];
-}
-export declare const createCollidersFromChildren: CreateCollidersFromChildren;
-export declare const colliderDescFromGeometry: (geometry: BufferGeometry, colliders: RigidBodyAutoCollider, scale: Vector3, hasCollisionEvents: boolean) => ColliderDesc;
 export declare const scaleVertices: (vertices: ArrayLike<number>, scale: Vector3) => number[];
-export declare const rigidBodyDescFromOptions: (options: UseRigidBodyOptions) => RigidBodyDesc;
-export {};