@react-three/rapier 0.1.1 → 0.3.0

package/CHANGELOG.md

@@ -1,5 +1,29 @@
 # @react-three/rapier
 
+## 0.3.0
+
+### Minor Changes
+
+- 7e36172: Add collision and sleep/awake events
+
+## 0.2.0
+
+### Minor Changes
+
+- 584ce08: Expose joint api, however no joint is returned when created (rapier bug?)
+
+### Patch Changes
+
+- 584ce08: All parts now uses a more rigid initiation process
+- 584ce08: Apply bounding box offset for auto colliders
+- 584ce08: Use single update loop instead of individual rigid body callbacks
+
+## 0.1.2
+
+### Patch Changes
+
+- 4f7440c: fix: make global colliders setting progate to children
+
 ## 0.1.1
 
 ### Patch Changes

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

@@ -1,12 +1,31 @@
 import React, { FC, ReactNode } from "react";
 import type Rapier from "@dimforge/rapier3d-compat";
-import { RigidBodyAutoCollider, Vector3Array } from "./types";
+import { RigidBodyAutoCollider, Vector3Array, WorldApi } from "./types";
+import { ColliderHandle, RigidBody, RigidBodyHandle, TempContactManifold } from "@dimforge/rapier3d-compat";
+import { Object3D } from "three";
 export interface RapierContext {
-    RAPIER: typeof Rapier;
-    world: Rapier.World;
-    stepFuncs: Array<() => void>;
+    rapier: typeof Rapier;
+    world: WorldApi;
+    colliderMeshes: Map<ColliderHandle, Object3D>;
+    rigidBodyMeshes: Map<ColliderHandle, Object3D>;
+    physicsOptions: {
+        colliders: RigidBodyAutoCollider;
+    };
+    rigidBodyEvents: EventMap;
 }
 export declare const RapierContext: React.Context<RapierContext | undefined>;
+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;
+}>;
 interface RapierWorldProps {
     gravity?: Vector3Array;
     colliders?: RigidBodyAutoCollider;

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

@@ -0,0 +1,33 @@
+import { Collider, ColliderDesc, ImpulseJoint, JointData, RigidBody, RigidBodyDesc, World } from "@dimforge/rapier3d-compat";
+import { Quaternion, Vector3 } from "three";
+import { RefGetter } from "./types";
+export declare const createRigidBodyApi: (ref: RefGetter<RigidBody>) => {
+    raw: () => RigidBody | undefined;
+    readonly handle: number;
+    applyImpulse({ x, y, z }: Vector3): void;
+    applyTorqueImpulse({ x, y, z }: Vector3): void;
+    translation(): Vector3;
+    rotation(): Quaternion;
+};
+export declare const createColliderApi: (ref: RefGetter<Collider>) => {
+    raw: () => Collider | undefined;
+    readonly handle: number;
+};
+export declare const createWorldApi: (ref: RefGetter<World>) => {
+    raw: () => World | undefined;
+    getCollider: (handle: number) => Collider;
+    getRigidBody: (handle: number) => RigidBody;
+    createRigidBody: (desc: RigidBodyDesc) => RigidBody;
+    createCollider: (desc: ColliderDesc, rigidBodyHandle: number) => Collider;
+    removeRigidBody: (rigidBody: RigidBody) => void;
+    removeCollider: (collider: Collider) => void;
+    createImpulseJoint: (params: JointData, rigidBodyA: RigidBody, rigidBodyB: RigidBody) => ImpulseJoint;
+    removeImpulseJoint: (joint: ImpulseJoint) => void;
+    forEachCollider: (callback: (collider: Collider) => void) => void;
+};
+export declare const createJointApi: (ref: RefGetter<ImpulseJoint>) => {
+    raw: () => ImpulseJoint | undefined;
+    readonly handle: number;
+    configureMotorPosition: (targetPos: number, stiffness: number, damping: number) => void;
+    configureMotorVelocity: (targetVel: number, damping: number) => void;
+};

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

@@ -1,13 +1,21 @@
 import React from "react";
 import { ReactNode } from "react";
-import { BallArgs, CapsuleArgs, ConeArgs, ConvexHullArgs, CuboidArgs, CylinderArgs, HeightfieldArgs, RapierRigidBody, RigidBodyAutoCollider, RoundCuboidArgs, TrimeshArgs, UseColliderOptions, UseRigidBodyOptions } from "./types";
+import { Vector3 } from "three";
+import { BallArgs, CapsuleArgs, ConeArgs, ConvexHullArgs, CuboidArgs, CylinderArgs, HeightfieldArgs, RoundCuboidArgs, TrimeshArgs, UseColliderOptions, UseRigidBodyOptions } from "./types";
 interface RigidBodyProps extends UseRigidBodyOptions {
     children?: ReactNode;
-    colliders?: RigidBodyAutoCollider | false;
 }
-export declare const RigidBody: React.ForwardRefExoticComponent<RigidBodyProps & React.RefAttributes<RapierRigidBody>>;
+export declare const RigidBody: React.ForwardRefExoticComponent<RigidBodyProps & React.RefAttributes<{
+    raw: () => import("@dimforge/rapier3d-compat/dynamics/rigid_body").RigidBody | undefined;
+    readonly handle: number;
+    applyImpulse({ x, y, z }: Vector3): void;
+    applyTorqueImpulse({ x, y, z }: Vector3): void;
+    translation(): Vector3;
+    rotation(): import("three").Quaternion;
+}>>;
 declare type UseColliderOptionsRequiredArgs<T> = 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;

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

@@ -1,17 +1,62 @@
 import React, { MutableRefObject } from "react";
 import { RapierContext } from "./Physics";
-import { Mesh, Object3D } from "three";
+import { Mesh, Object3D, Quaternion, Vector3 } from "three";
 import type Rapier from "@dimforge/rapier3d-compat";
 export declare const useRapier: () => RapierContext;
-import { BallArgs, CapsuleArgs, ConeArgs, ConvexHullArgs, CuboidArgs, CylinderArgs, HeightfieldArgs, PolylineArgs, RoundConvexHullArgs, RoundCuboidArgs, RoundCylinderArgs, TrimeshArgs, UseBodyOptions, UseRigidBodyOptions, UseImpulseJoint, SphericalJointParams, FixedJointParams, PrismaticJointParams, RevoluteJointParams, UseColliderOptions, RapierRigidBody, ConvexMeshArgs, RoundConvexMeshArgs } from "./types";
+import { BallArgs, CapsuleArgs, ConeArgs, ConvexHullArgs, CuboidArgs, CylinderArgs, HeightfieldArgs, PolylineArgs, RoundConvexHullArgs, RoundCuboidArgs, RoundCylinderArgs, TrimeshArgs, UseBodyOptions, UseRigidBodyOptions, UseImpulseJoint, SphericalJointParams, FixedJointParams, PrismaticJointParams, RevoluteJointParams, UseColliderOptions, RapierRigidBody, ConvexMeshArgs, RoundConvexMeshArgs, RigidBodyApi } from "./types";
 import { RoundCone } from "@dimforge/rapier3d-compat";
-export declare const useCollider: <A>(body: RapierRigidBody, options?: UseColliderOptions<A>) => Rapier.Collider[];
-export declare const useRigidBody: <O extends Object3D<import("three").Event>>(options?: UseRigidBodyOptions | undefined) => [React.MutableRefObject<O>, Rapier.RigidBody];
-export declare const useRigidBodyWithCollider: <A, O extends Object3D<import("three").Event> = Object3D<import("three").Event>>(rigidBodyOptions?: UseRigidBodyOptions | undefined, colliderOptions?: UseColliderOptions<A> | undefined) => [ref: React.MutableRefObject<O>, rigidBody: Rapier.RigidBody];
-export declare const useCuboid: <T extends Object3D<import("three").Event>>(rigidBodyOptions?: UseBodyOptions, colliderOptions?: UseColliderOptions<CuboidArgs>) => [ref: React.MutableRefObject<T>, rigidBody: Rapier.RigidBody];
-export declare const useBall: <T extends Object3D<import("three").Event>>(rigidBodyOptions?: UseBodyOptions, colliderOptions?: UseColliderOptions<BallArgs>) => [ref: React.MutableRefObject<T>, rigidBody: Rapier.RigidBody];
-export declare const useCapsule: <T extends Object3D<import("three").Event>>(rigidBodyOptions?: UseBodyOptions, colliderOptions?: UseColliderOptions<CapsuleArgs>) => [ref: React.MutableRefObject<T>, rigidBody: Rapier.RigidBody];
-export declare const useHeightfield: <T extends Object3D<import("three").Event>>(rigidBodyOptions?: UseBodyOptions, colliderOptions?: UseColliderOptions<HeightfieldArgs>) => [ref: React.MutableRefObject<T>, rigidBody: Rapier.RigidBody];
+export declare const useRigidBody: <O extends Object3D<import("three").Event>>(options?: UseRigidBodyOptions) => [React.MutableRefObject<O>, {
+    raw: () => Rapier.RigidBody | undefined;
+    readonly handle: number;
+    applyImpulse({ x, y, z }: Vector3): void;
+    applyTorqueImpulse({ x, y, z }: Vector3): void;
+    translation(): Vector3;
+    rotation(): Quaternion;
+}];
+export declare const useCollider: <A>(body: RigidBodyApi, options?: UseColliderOptions<A>) => (React.MutableRefObject<Object3D<import("three").Event> | undefined> | {
+    raw: () => Rapier.Collider | undefined;
+    readonly handle: number;
+})[];
+export declare const useRigidBodyWithCollider: <A, O extends Object3D<import("three").Event> = Object3D<import("three").Event>>(rigidBodyOptions?: UseRigidBodyOptions | undefined, colliderOptions?: UseColliderOptions<A> | undefined) => [ref: React.MutableRefObject<O>, rigidBody: {
+    raw: () => Rapier.RigidBody | undefined;
+    readonly handle: number;
+    applyImpulse({ x, y, z }: Vector3): void;
+    applyTorqueImpulse({ x, y, z }: Vector3): void;
+    translation(): Vector3;
+    rotation(): Quaternion;
+}];
+export declare const useCuboid: <T extends Object3D<import("three").Event>>(rigidBodyOptions?: UseBodyOptions, colliderOptions?: UseColliderOptions<CuboidArgs>) => [ref: React.MutableRefObject<T>, rigidBody: {
+    raw: () => Rapier.RigidBody | undefined;
+    readonly handle: number;
+    applyImpulse({ x, y, z }: Vector3): void;
+    applyTorqueImpulse({ x, y, z }: Vector3): void;
+    translation(): Vector3;
+    rotation(): Quaternion;
+}];
+export declare const useBall: <T extends Object3D<import("three").Event>>(rigidBodyOptions?: UseBodyOptions, colliderOptions?: UseColliderOptions<BallArgs>) => [ref: React.MutableRefObject<T>, rigidBody: {
+    raw: () => Rapier.RigidBody | undefined;
+    readonly handle: number;
+    applyImpulse({ x, y, z }: Vector3): void;
+    applyTorqueImpulse({ x, y, z }: Vector3): void;
+    translation(): Vector3;
+    rotation(): Quaternion;
+}];
+export declare const useCapsule: <T extends Object3D<import("three").Event>>(rigidBodyOptions?: UseBodyOptions, colliderOptions?: UseColliderOptions<CapsuleArgs>) => [ref: React.MutableRefObject<T>, rigidBody: {
+    raw: () => Rapier.RigidBody | undefined;
+    readonly handle: number;
+    applyImpulse({ x, y, z }: Vector3): void;
+    applyTorqueImpulse({ x, y, z }: Vector3): void;
+    translation(): Vector3;
+    rotation(): Quaternion;
+}];
+export declare const useHeightfield: <T extends Object3D<import("three").Event>>(rigidBodyOptions?: UseBodyOptions, colliderOptions?: UseColliderOptions<HeightfieldArgs>) => [ref: React.MutableRefObject<T>, rigidBody: {
+    raw: () => Rapier.RigidBody | undefined;
+    readonly handle: number;
+    applyImpulse({ x, y, z }: Vector3): void;
+    applyTorqueImpulse({ x, y, z }: Vector3): void;
+    translation(): Vector3;
+    rotation(): Quaternion;
+}];
 /**
  * Create a trimesh collider and rigid body.
  * Note that Trimeshes don't have mass unless provided.
@@ -19,26 +64,129 @@ export declare const useHeightfield: <T extends Object3D<import("three").Event>>
  * for available properties.
  */
 export declare const useTrimesh: {
-    <T extends Object3D<import("three").Event>>(rigidBodyOptions?: UseBodyOptions, colliderOptions?: UseColliderOptions<TrimeshArgs>): [ref: React.MutableRefObject<T>, rigidBody: Rapier.RigidBody];
-    fromMesh<T_1 extends Object3D<import("three").Event>>(mesh: Mesh, rigidBodyOptions?: UseBodyOptions, colliderOptions?: UseColliderOptions<TrimeshArgs>): [ref: React.MutableRefObject<T_1>, rigidBody: Rapier.RigidBody];
+    <T extends Object3D<import("three").Event>>(rigidBodyOptions?: UseBodyOptions, colliderOptions?: UseColliderOptions<TrimeshArgs>): [ref: React.MutableRefObject<T>, rigidBody: {
+        raw: () => Rapier.RigidBody | undefined;
+        readonly handle: number;
+        applyImpulse({ x, y, z }: Vector3): void;
+        applyTorqueImpulse({ x, y, z }: Vector3): void;
+        translation(): Vector3;
+        rotation(): Quaternion;
+    }];
+    fromMesh<T_1 extends Object3D<import("three").Event>>(mesh: Mesh, rigidBodyOptions?: UseBodyOptions, colliderOptions?: UseColliderOptions<TrimeshArgs>): [ref: React.MutableRefObject<T_1>, rigidBody: {
+        raw: () => Rapier.RigidBody | undefined;
+        readonly handle: number;
+        applyImpulse({ x, y, z }: Vector3): void;
+        applyTorqueImpulse({ x, y, z }: Vector3): void;
+        translation(): Vector3;
+        rotation(): Quaternion;
+    }];
 };
-export declare const usePolyline: <T extends Object3D<import("three").Event>>(rigidBodyOptions?: UseBodyOptions, colliderOptions?: UseColliderOptions<PolylineArgs>) => [ref: React.MutableRefObject<T>, rigidBody: Rapier.RigidBody];
-export declare const useRoundCuboid: <T extends Object3D<import("three").Event>>(rigidBodyOptions?: UseBodyOptions, colliderOptions?: UseColliderOptions<RoundCuboidArgs>) => [ref: React.MutableRefObject<T>, rigidBody: Rapier.RigidBody];
-export declare const useCylinder: <T extends Object3D<import("three").Event>>(rigidBodyOptions?: UseBodyOptions, colliderOptions?: UseColliderOptions<CylinderArgs>) => [ref: React.MutableRefObject<T>, rigidBody: Rapier.RigidBody];
-export declare const useRoundCylinder: <T extends Object3D<import("three").Event>>(rigidBodyOptions?: UseBodyOptions, colliderOptions?: UseColliderOptions<RoundCylinderArgs>) => [ref: React.MutableRefObject<T>, rigidBody: Rapier.RigidBody];
-export declare const useCone: <T extends Object3D<import("three").Event>>(rigidBodyOptions?: UseBodyOptions, colliderOptions?: UseColliderOptions<ConeArgs>) => [ref: React.MutableRefObject<T>, rigidBody: Rapier.RigidBody];
-export declare const useRoundCone: <T extends Object3D<import("three").Event>>(rigidBodyOptions?: UseBodyOptions, colliderOptions?: UseColliderOptions<RoundCone>) => [ref: React.MutableRefObject<T>, rigidBody: Rapier.RigidBody];
+export declare const usePolyline: <T extends Object3D<import("three").Event>>(rigidBodyOptions?: UseBodyOptions, colliderOptions?: UseColliderOptions<PolylineArgs>) => [ref: React.MutableRefObject<T>, rigidBody: {
+    raw: () => Rapier.RigidBody | undefined;
+    readonly handle: number;
+    applyImpulse({ x, y, z }: Vector3): void;
+    applyTorqueImpulse({ x, y, z }: Vector3): void;
+    translation(): Vector3;
+    rotation(): Quaternion;
+}];
+export declare const useRoundCuboid: <T extends Object3D<import("three").Event>>(rigidBodyOptions?: UseBodyOptions, colliderOptions?: UseColliderOptions<RoundCuboidArgs>) => [ref: React.MutableRefObject<T>, rigidBody: {
+    raw: () => Rapier.RigidBody | undefined;
+    readonly handle: number;
+    applyImpulse({ x, y, z }: Vector3): void;
+    applyTorqueImpulse({ x, y, z }: Vector3): void;
+    translation(): Vector3;
+    rotation(): Quaternion;
+}];
+export declare const useCylinder: <T extends Object3D<import("three").Event>>(rigidBodyOptions?: UseBodyOptions, colliderOptions?: UseColliderOptions<CylinderArgs>) => [ref: React.MutableRefObject<T>, rigidBody: {
+    raw: () => Rapier.RigidBody | undefined;
+    readonly handle: number;
+    applyImpulse({ x, y, z }: Vector3): void;
+    applyTorqueImpulse({ x, y, z }: Vector3): void;
+    translation(): Vector3;
+    rotation(): Quaternion;
+}];
+export declare const useRoundCylinder: <T extends Object3D<import("three").Event>>(rigidBodyOptions?: UseBodyOptions, colliderOptions?: UseColliderOptions<RoundCylinderArgs>) => [ref: React.MutableRefObject<T>, rigidBody: {
+    raw: () => Rapier.RigidBody | undefined;
+    readonly handle: number;
+    applyImpulse({ x, y, z }: Vector3): void;
+    applyTorqueImpulse({ x, y, z }: Vector3): void;
+    translation(): Vector3;
+    rotation(): Quaternion;
+}];
+export declare const useCone: <T extends Object3D<import("three").Event>>(rigidBodyOptions?: UseBodyOptions, colliderOptions?: UseColliderOptions<ConeArgs>) => [ref: React.MutableRefObject<T>, rigidBody: {
+    raw: () => Rapier.RigidBody | undefined;
+    readonly handle: number;
+    applyImpulse({ x, y, z }: Vector3): void;
+    applyTorqueImpulse({ x, y, z }: Vector3): void;
+    translation(): Vector3;
+    rotation(): Quaternion;
+}];
+export declare const useRoundCone: <T extends Object3D<import("three").Event>>(rigidBodyOptions?: UseBodyOptions, colliderOptions?: UseColliderOptions<RoundCone>) => [ref: React.MutableRefObject<T>, rigidBody: {
+    raw: () => Rapier.RigidBody | undefined;
+    readonly handle: number;
+    applyImpulse({ x, y, z }: Vector3): void;
+    applyTorqueImpulse({ x, y, z }: Vector3): void;
+    translation(): Vector3;
+    rotation(): Quaternion;
+}];
 export declare const useConvexHull: {
-    <T extends Object3D<import("three").Event>>(rigidBodyOptions?: UseBodyOptions, colliderOptions?: UseColliderOptions<ConvexHullArgs>): [ref: React.MutableRefObject<T>, rigidBody: Rapier.RigidBody];
-    fromMesh<T_1 extends Object3D<import("three").Event>>(mesh: Mesh, rigidBodyOptions?: UseBodyOptions, colliderOptions?: Omit<UseColliderOptions<ConvexHullArgs>, "colliderArgs">): [ref: React.MutableRefObject<T_1>, rigidBody: Rapier.RigidBody];
+    <T extends Object3D<import("three").Event>>(rigidBodyOptions?: UseBodyOptions, colliderOptions?: UseColliderOptions<ConvexHullArgs>): [ref: React.MutableRefObject<T>, rigidBody: {
+        raw: () => Rapier.RigidBody | undefined;
+        readonly handle: number;
+        applyImpulse({ x, y, z }: Vector3): void;
+        applyTorqueImpulse({ x, y, z }: Vector3): void;
+        translation(): Vector3;
+        rotation(): Quaternion;
+    }];
+    fromMesh<T_1 extends Object3D<import("three").Event>>(mesh: Mesh, rigidBodyOptions?: UseBodyOptions, colliderOptions?: Omit<UseColliderOptions<ConvexHullArgs>, "colliderArgs">): [ref: React.MutableRefObject<T_1>, rigidBody: {
+        raw: () => Rapier.RigidBody | undefined;
+        readonly handle: number;
+        applyImpulse({ x, y, z }: Vector3): void;
+        applyTorqueImpulse({ x, y, z }: Vector3): void;
+        translation(): Vector3;
+        rotation(): Quaternion;
+    }];
 };
-export declare const useRoundConvexHull: <T extends Object3D<import("three").Event>>(rigidBodyOptions?: UseBodyOptions, colliderOptions?: UseColliderOptions<RoundConvexHullArgs>) => [ref: React.MutableRefObject<T>, rigidBody: Rapier.RigidBody];
+export declare const useRoundConvexHull: <T extends Object3D<import("three").Event>>(rigidBodyOptions?: UseBodyOptions, colliderOptions?: UseColliderOptions<RoundConvexHullArgs>) => [ref: React.MutableRefObject<T>, rigidBody: {
+    raw: () => Rapier.RigidBody | undefined;
+    readonly handle: number;
+    applyImpulse({ x, y, z }: Vector3): void;
+    applyTorqueImpulse({ x, y, z }: Vector3): void;
+    translation(): Vector3;
+    rotation(): Quaternion;
+}];
 export declare const useConvexMesh: {
-    <T extends Object3D<import("three").Event>>(rigidBodyOptions?: UseBodyOptions, colliderOptions?: UseColliderOptions<ConvexMeshArgs>): [ref: React.MutableRefObject<Object3D<import("three").Event>>, rigidBody: Rapier.RigidBody];
-    fromMesh<T_1 extends Object3D<import("three").Event>>(mesh: Mesh, rigidBodyOptions?: UseBodyOptions, colliderOptions?: Omit<UseColliderOptions<ConvexMeshArgs>, "colliderArgs">): [ref: React.MutableRefObject<Object3D<import("three").Event>>, rigidBody: Rapier.RigidBody];
+    <T extends Object3D<import("three").Event>>(rigidBodyOptions?: UseBodyOptions, colliderOptions?: UseColliderOptions<ConvexMeshArgs>): [ref: React.MutableRefObject<Object3D<import("three").Event>>, rigidBody: {
+        raw: () => Rapier.RigidBody | undefined;
+        readonly handle: number;
+        applyImpulse({ x, y, z }: Vector3): void;
+        applyTorqueImpulse({ x, y, z }: Vector3): void;
+        translation(): Vector3;
+        rotation(): Quaternion;
+    }];
+    fromMesh<T_1 extends Object3D<import("three").Event>>(mesh: Mesh, rigidBodyOptions?: UseBodyOptions, colliderOptions?: Omit<UseColliderOptions<ConvexMeshArgs>, "colliderArgs">): [ref: React.MutableRefObject<Object3D<import("three").Event>>, rigidBody: {
+        raw: () => Rapier.RigidBody | undefined;
+        readonly handle: number;
+        applyImpulse({ x, y, z }: Vector3): void;
+        applyTorqueImpulse({ x, y, z }: Vector3): void;
+        translation(): Vector3;
+        rotation(): Quaternion;
+    }];
+};
+export declare const useRoundConvexMesh: <T extends Object3D<import("three").Event>>(rigidBodyOptions?: UseBodyOptions, colliderOptions?: UseColliderOptions<RoundConvexMeshArgs>) => [ref: React.MutableRefObject<Object3D<import("three").Event>>, rigidBody: {
+    raw: () => Rapier.RigidBody | undefined;
+    readonly handle: number;
+    applyImpulse({ x, y, z }: Vector3): void;
+    applyTorqueImpulse({ x, y, z }: Vector3): void;
+    translation(): Vector3;
+    rotation(): Quaternion;
+}];
+export declare const useImpulseJoint: <T extends Rapier.ImpulseJoint>(body1: MutableRefObject<RapierRigidBody | undefined | null> | RigidBodyApi, body2: MutableRefObject<RapierRigidBody | undefined | null> | RigidBodyApi, params: Rapier.JointData) => {
+    raw: () => Rapier.ImpulseJoint | undefined;
+    readonly handle: number;
+    configureMotorPosition: (targetPos: number, stiffness: number, damping: number) => void;
+    configureMotorVelocity: (targetVel: number, damping: number) => void;
 };
-export declare const useRoundConvexMesh: <T extends Object3D<import("three").Event>>(rigidBodyOptions?: UseBodyOptions, colliderOptions?: UseColliderOptions<RoundConvexMeshArgs>) => [ref: React.MutableRefObject<Object3D<import("three").Event>>, rigidBody: Rapier.RigidBody];
-export declare const useImpulseJoint: <T extends Rapier.ImpulseJoint>(body1: MutableRefObject<RapierRigidBody | undefined | null>, body2: MutableRefObject<RapierRigidBody | undefined | null>, params: Rapier.JointData) => void;
 /**
  *
  * A fixed joint ensures that two rigid-bodies don't move relative to each other.

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

@@ -1,5 +1,5 @@
 export { Physics } from "./Physics";
 export * from "./hooks";
-export * from "./types";
 export * from "./components";
 export * from "./Debug";
+export * from "./types";

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

@@ -1,7 +1,9 @@
 import { MutableRefObject } from "react";
-import { CoefficientCombineRule, RigidBody as RapierRigidBody, Collider as RapierCollider } from "@dimforge/rapier3d-compat";
+import { CoefficientCombineRule, RigidBody as RapierRigidBody, Collider as RapierCollider, TempContactManifold } from "@dimforge/rapier3d-compat";
+import { createColliderApi, createJointApi, createRigidBodyApi, createWorldApi } from "./api";
 export { RapierRigidBody, RapierCollider };
 export { CoefficientCombineRule as CoefficientCombineRule, } from "@dimforge/rapier3d-compat";
+export declare type RefGetter<T> = MutableRefObject<() => T | undefined>;
 export declare type RigidBodyAutoCollider = 'ball' | 'cuboid' | 'hull' | 'trimesh' | false;
 export interface UseRigidBodyAPI {
     rigidBody: RapierRigidBody;
@@ -160,6 +162,22 @@ export interface UseRigidBodyOptions {
      * Setting this to false will disable automatic colliders.
      */
     colliders?: RigidBodyAutoCollider | false;
+    /**
+     * Callback when this rigidbody collides with another rigidbody
+     */
+    onCollisionEnter?({}: {
+        target: RapierRigidBody;
+        manifold: TempContactManifold;
+        flipped: boolean;
+    }): void;
+    /**
+     * Callback when this rigidbody stops colliding with another rigidbody
+     */
+    onCollisionExit?({}: {
+        target: RapierRigidBody;
+    }): void;
+    onSleep?(): void;
+    onWake?(): void;
 }
 export declare type SphericalJointParams = [
     body1Anchor: Vector3Array,
@@ -184,5 +202,9 @@ export declare type RevoluteJointParams = [
     body2LocalFrame: Vector3Array
 ];
 export interface UseImpulseJoint<P> {
-    (body1: MutableRefObject<RapierRigidBody | undefined | null>, body2: MutableRefObject<RapierRigidBody | undefined | null>, params: P): void;
+    (body1: MutableRefObject<RapierRigidBody | undefined | null>, body2: MutableRefObject<RapierRigidBody | undefined | null>, params: P): JointApi;
 }
+export declare type RigidBodyApi = ReturnType<typeof createRigidBodyApi>;
+export declare type ColliderApi = ReturnType<typeof createColliderApi>;
+export declare type WorldApi = ReturnType<typeof createWorldApi>;
+export declare type JointApi = ReturnType<typeof createJointApi>;

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

@@ -1,6 +1,6 @@
-import { Collider, World } from "@dimforge/rapier3d-compat";
+import { Collider } from "@dimforge/rapier3d-compat";
 import { Object3D, Vector3 } from "three";
-import { RapierRigidBody, RigidBodyAutoCollider, RigidBodyShape, RigidBodyTypeString, UseColliderOptions, Vector3Array } from "./types";
+import { RapierRigidBody, RigidBodyAutoCollider, RigidBodyShape, RigidBodyTypeString, UseColliderOptions, Vector3Array, WorldApi } from "./types";
 export declare const vectorArrayToObject: (arr: Vector3Array) => {
     x: number;
     y: number;
@@ -8,10 +8,10 @@ export declare const vectorArrayToObject: (arr: Vector3Array) => {
 };
 export declare const rigidBodyTypeFromString: (type: RigidBodyTypeString) => number;
 export declare const scaleColliderArgs: (shape: RigidBodyShape, args: (number | ArrayLike<number>)[], scale: Vector3) => (number | ArrayLike<number>)[];
-export declare const createColliderFromOptions: <A>(options: UseColliderOptions<A>, world: World, body: RapierRigidBody, scale?: {
+export declare const createColliderFromOptions: <A>(options: UseColliderOptions<A>, world: WorldApi, rigidBodyHandle: number, scale?: {
     x: number;
     y: number;
     z: number;
-}) => Collider;
-export declare const createCollidersFromChildren: (object: Object3D, rigidBody: RapierRigidBody, type: RigidBodyAutoCollider, world: World) => Collider[];
+}, hasCollisionEvents?: boolean) => Collider;
+export declare const createCollidersFromChildren: (object: Object3D, rigidBody: RapierRigidBody, type: RigidBodyAutoCollider, world: WorldApi, hasCollisionEvents?: boolean) => Collider[];
 export declare const scaleVertices: (vertices: ArrayLike<number>, scale: Vector3) => number[];