@react-three/rapier 0.6.8 → 0.7.0

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

@@ -1,16 +1,29 @@
-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;
 };
-export declare const CuboidCollider: (props: UseColliderOptionsRequiredArgs<CuboidArgs>) => JSX.Element;
-export declare const RoundCuboidCollider: (props: UseColliderOptionsRequiredArgs<RoundCuboidArgs>) => JSX.Element;
-export declare const BallCollider: (props: UseColliderOptionsRequiredArgs<BallArgs>) => JSX.Element;
-export declare const CapsuleCollider: (props: UseColliderOptionsRequiredArgs<CapsuleArgs>) => JSX.Element;
-export declare const HeightfieldCollider: (props: UseColliderOptionsRequiredArgs<HeightfieldArgs>) => JSX.Element;
-export declare const TrimeshCollider: (props: UseColliderOptionsRequiredArgs<TrimeshArgs>) => JSX.Element;
-export declare const ConeCollider: (props: UseColliderOptionsRequiredArgs<ConeArgs>) => JSX.Element;
-export declare const CylinderCollider: (props: UseColliderOptionsRequiredArgs<CylinderArgs>) => JSX.Element;
-export declare const ConvexHullCollider: (props: UseColliderOptionsRequiredArgs<ConvexHullArgs>) => JSX.Element;
+export declare type CuboidColliderProps = UseColliderOptionsRequiredArgs<CuboidArgs>;
+export declare type RoundCuboidColliderProps = UseColliderOptionsRequiredArgs<RoundCuboidArgs>;
+export declare type BallColliderProps = UseColliderOptionsRequiredArgs<BallArgs>;
+export declare type CapsuleColliderProps = UseColliderOptionsRequiredArgs<CapsuleArgs>;
+export declare type HeightfieldColliderProps = UseColliderOptionsRequiredArgs<HeightfieldArgs>;
+export declare type TrimeshColliderProps = UseColliderOptionsRequiredArgs<TrimeshArgs>;
+export declare type ConeColliderProps = UseColliderOptionsRequiredArgs<ConeArgs>;
+export declare type CylinderColliderProps = UseColliderOptionsRequiredArgs<CylinderArgs>;
+export declare type ConvexHullColliderProps = UseColliderOptionsRequiredArgs<ConvexHullArgs>;
+export declare const CuboidCollider: (props: CuboidColliderProps) => JSX.Element;
+export declare const RoundCuboidCollider: (props: RoundCuboidColliderProps) => JSX.Element;
+export declare const BallCollider: (props: BallColliderProps) => JSX.Element;
+export declare const CapsuleCollider: (props: CapsuleColliderProps) => JSX.Element;
+export declare const HeightfieldCollider: (props: HeightfieldColliderProps) => JSX.Element;
+export declare const TrimeshCollider: (props: TrimeshColliderProps) => JSX.Element;
+export declare const ConeCollider: (props: ConeColliderProps) => JSX.Element;
+export declare const CylinderCollider: (props: CylinderColliderProps) => JSX.Element;
+export declare const ConvexHullCollider: (props: ConvexHullColliderProps) => JSX.Element;
 export {};

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

@@ -2,9 +2,9 @@ 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[];
 }
-export declare const InstancedRigidBodies: React.ForwardRefExoticComponent<Pick<InstancedRigidBodiesProps, "type" | "canSleep" | "linearDamping" | "angularDamping" | "linearVelocity" | "angularVelocity" | "gravityScale" | "ccd" | "colliders" | "friction" | "restitution" | "onSleep" | "onWake" | "lockRotations" | "lockTranslations" | "enabledRotations" | "enabledTranslations" | "children" | "quaternion" | "attach" | "args" | "key" | "onUpdate" | "up" | "scale" | "matrix" | "layers" | "dispose" | "id" | "uuid" | "name" | "parent" | "modelViewMatrix" | "normalMatrix" | "matrixWorld" | "matrixAutoUpdate" | "matrixWorldNeedsUpdate" | "visible" | "castShadow" | "receiveShadow" | "frustumCulled" | "renderOrder" | "animations" | "userData" | "customDepthMaterial" | "customDistanceMaterial" | "isObject3D" | "onBeforeRender" | "onAfterRender" | "applyMatrix4" | "applyQuaternion" | "setRotationFromAxisAngle" | "setRotationFromEuler" | "setRotationFromMatrix" | "setRotationFromQuaternion" | "rotateOnAxis" | "rotateOnWorldAxis" | "rotateX" | "rotateY" | "rotateZ" | "translateOnAxis" | "translateX" | "translateY" | "translateZ" | "localToWorld" | "worldToLocal" | "lookAt" | "add" | "remove" | "removeFromParent" | "clear" | "getObjectById" | "getObjectByName" | "getObjectByProperty" | "getWorldPosition" | "getWorldQuaternion" | "getWorldScale" | "getWorldDirection" | "raycast" | "traverse" | "traverseVisible" | "traverseAncestors" | "updateMatrix" | "updateMatrixWorld" | "updateWorldMatrix" | "toJSON" | "clone" | "copy" | "addEventListener" | "hasEventListener" | "removeEventListener" | "dispatchEvent" | "onClick" | "onContextMenu" | "onDoubleClick" | "onPointerUp" | "onPointerDown" | "onPointerOver" | "onPointerOut" | "onPointerEnter" | "onPointerLeave" | "onPointerMove" | "onPointerMissed" | "onPointerCancel" | "onWheel" | "positions" | "rotations" | "scales"> & React.RefAttributes<InstancedRigidBodyApi>>;
+export declare const InstancedRigidBodies: React.ForwardRefExoticComponent<InstancedRigidBodiesProps & React.RefAttributes<InstancedRigidBodyApi>>;

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,37 +1,51 @@
 import React, { FC, ReactNode } from "react";
 import type Rapier from "@dimforge/rapier3d-compat";
-import { RigidBodyAutoCollider, Vector3Array, WorldApi } from "./types";
-import { ColliderHandle, RigidBody, RigidBodyHandle, TempContactManifold } 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;
     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?({ target, manifold, flipped, }: {
-        target: RigidBody;
-        manifold: TempContactManifold;
-        flipped: boolean;
-    }): void;
-    onCollisionExit?({ target }: {
-        target: RigidBody;
-    }): void;
+    onCollisionEnter?: CollisionEnterHandler;
+    onCollisionExit?: CollisionExitHandler;
+    onIntersectionEnter?: IntersectionEnterHandler;
+    onIntersectionExit?: IntersectionExitHandler;
 }>;
 interface RapierWorldProps {
     children: ReactNode;
@@ -54,18 +68,18 @@ 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
      *
      * @defaultValue false
      */
     paused?: boolean;
+    /**
+     * The update priority at which the physics simulation should run.
+     *
+     * @defaultValue undefined
+     */
+    updatePriority?: number;
 }
 export declare const Physics: FC<RapierWorldProps>;
 export {};

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

@@ -1,23 +1,20 @@
 import React, { MutableRefObject, RefObject } from "react";
 import { ReactNode } from "react";
 import { Object3D } from "three";
-import { Object3DProps } from "@react-three/fiber";
 import { InstancedRigidBodyApi } from "./api";
 import { InstancedRigidBodiesProps } from "./InstancedRigidBodies";
 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, Omit<Object3DProps, 'type' | 'position' | 'rotation'> {
+export interface RigidBodyProps extends UseRigidBodyOptions {
     children?: ReactNode;
 }
-export declare const RigidBody: React.ForwardRefExoticComponent<Pick<RigidBodyProps, "type" | "canSleep" | "linearDamping" | "angularDamping" | "linearVelocity" | "angularVelocity" | "gravityScale" | "ccd" | "position" | "rotation" | "colliders" | "friction" | "restitution" | "onCollisionEnter" | "onCollisionExit" | "onSleep" | "onWake" | "lockRotations" | "lockTranslations" | "enabledRotations" | "enabledTranslations" | "children" | "quaternion" | "attach" | "args" | "key" | "onUpdate" | "up" | "scale" | "matrix" | "layers" | "dispose" | "id" | "uuid" | "name" | "parent" | "modelViewMatrix" | "normalMatrix" | "matrixWorld" | "matrixAutoUpdate" | "matrixWorldNeedsUpdate" | "visible" | "castShadow" | "receiveShadow" | "frustumCulled" | "renderOrder" | "animations" | "userData" | "customDepthMaterial" | "customDistanceMaterial" | "isObject3D" | "onBeforeRender" | "onAfterRender" | "applyMatrix4" | "applyQuaternion" | "setRotationFromAxisAngle" | "setRotationFromEuler" | "setRotationFromMatrix" | "setRotationFromQuaternion" | "rotateOnAxis" | "rotateOnWorldAxis" | "rotateX" | "rotateY" | "rotateZ" | "translateOnAxis" | "translateX" | "translateY" | "translateZ" | "localToWorld" | "worldToLocal" | "lookAt" | "add" | "remove" | "removeFromParent" | "clear" | "getObjectById" | "getObjectByName" | "getObjectByProperty" | "getWorldPosition" | "getWorldQuaternion" | "getWorldScale" | "getWorldDirection" | "raycast" | "traverse" | "traverseVisible" | "traverseAncestors" | "updateMatrix" | "updateMatrixWorld" | "updateWorldMatrix" | "toJSON" | "clone" | "copy" | "addEventListener" | "hasEventListener" | "removeEventListener" | "dispatchEvent" | "onClick" | "onContextMenu" | "onDoubleClick" | "onPointerUp" | "onPointerDown" | "onPointerOver" | "onPointerOut" | "onPointerEnter" | "onPointerLeave" | "onPointerMove" | "onPointerMissed" | "onPointerCancel" | "onWheel"> & React.RefAttributes<import("./api").RigidBodyApi>>;
+export declare const RigidBody: React.ForwardRefExoticComponent<RigidBodyProps & React.RefAttributes<import("./api").RigidBodyApi>>;

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

@@ -0,0 +1,34 @@
+import { InteractionGroups } from "@dimforge/rapier3d-compat";
+/**
+ * Calculates an InteractionGroup bitmask for use in the `collisionGroups` or `solverGroups`
+ * properties of RigidBody or Collider components. The first argument represents a list of
+ * groups the entity is in (expressed as numbers from 0 to 15). The second argument is a list
+ * of groups that will be filtered against. When it is omitted, all groups are filtered against.
+ *
+ * @example
+ * A RigidBody that is member of group 0 and will collide with everything from groups 0 and 1:
+ *
+ * ```tsx
+ * <RigidBody collisionGroups={interactionGroups([0], [0, 1])} />
+ * ```
+ *
+ * A RigidBody that is member of groups 0 and 1 and will collide with everything else:
+ *
+ * ```tsx
+ * <RigidBody collisionGroups={interactionGroups([0, 1])} />
+ * ```
+ *
+ * A RigidBody that is member of groups 0 and 1 and will not collide with anything:
+ *
+ * ```tsx
+ * <RigidBody collisionGroups={interactionGroups([0, 1], [])} />
+ * ```
+ *
+ * Please note that Rapier needs interaction filters to evaluate to true between _both_ colliding
+ * entities for collision events to trigger.
+ *
+ * @param memberships Groups the collider is a member of. (Values can range from 0 to 15.)
+ * @param filters Groups the interaction group should filter against. (Values can range from 0 to 15.)
+ * @returns An InteractionGroup bitmask.
+ */
+export declare const interactionGroups: (memberships: number | number[], filters?: number | number[] | undefined) => InteractionGroups;

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/index.d.ts

@@ -1,5 +1,8 @@
 export * from "./types";
 export type { RigidBodyApi, WorldApi, InstancedRigidBodyApi } from "./api";
+export type { RigidBodyProps } from './RigidBody';
+export type { InstancedRigidBodiesProps } from './InstancedRigidBodies';
+export type { CylinderColliderProps, BallColliderProps, CapsuleColliderProps, ConeColliderProps, ConvexHullColliderProps, CuboidColliderProps, HeightfieldColliderProps, RoundCuboidColliderProps, TrimeshColliderProps } from './AnyCollider';
 export { Physics } from "./Physics";
 export { RigidBody } from "./RigidBody";
 export { MeshCollider } from "./MeshCollider";
@@ -7,3 +10,4 @@ export { Debug } from "./Debug";
 export { InstancedRigidBodies } from "./InstancedRigidBodies";
 export * from "./AnyCollider";
 export * from "./hooks";
+export * from "./bitmasks";

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, RigidBody as RapierRigidBody, TempContactManifold } from "@dimforge/rapier3d-compat";
+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,8 +123,68 @@ 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.
+     */
+    onCollisionEnter?: CollisionEnterHandler;
+    /**
+     * 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.
+     */
+    collisionGroups?: InteractionGroups;
+    /**
+     * 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 interface UseRigidBodyOptions {
+export declare type CollisionEnterPayload = {
+    rigidBody?: RapierRigidBody;
+    collider: RapierCollider;
+    manifold: TempContactManifold;
+    flipped: boolean;
+    rigidBodyObject?: Object3D;
+    colliderObject?: Object3D;
+};
+export declare type CollisionExitPayload = {
+    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 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
      */
@@ -134,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;
@@ -182,19 +245,15 @@ export interface UseRigidBodyOptions {
      */
     restitution?: number;
     /**
-     * Callback when this rigidbody collides with another rigidbody
+     * The default collision groups bitmask for all colliders in this rigid body.
+     * Can be customized per-collider.
      */
-    onCollisionEnter?({}: {
-        target: RapierRigidBody;
-        manifold: TempContactManifold;
-        flipped: boolean;
-    }): void;
+    collisionGroups?: InteractionGroups;
     /**
-     * Callback when this rigidbody stops colliding with another rigidbody
+    * The default solver groups bitmask for all colliders in this rigid body.
+    * Can be customized per-collider.
      */
-    onCollisionExit?({}: {
-        target: RapierRigidBody;
-    }): void;
+    solverGroups?: InteractionGroups;
     onSleep?(): void;
     onWake?(): void;
     /**
@@ -213,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) => void;
+export declare const useUpdateRigidBodyOptions: (rigidBodyRef: MutableRefObject<RigidBody | undefined>, props: RigidBodyProps, states: RigidBodyStateMap) => void;
+export declare const useRigidBodyEvents: (rigidBodyRef: MutableRefObject<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 {};