@react-three/rapier 0.12.2 → 0.13.0

package/dist/declarations/src/{AnyCollider.d.ts → components/AnyCollider.d.ts}

@@ -1,10 +1,14 @@
 import { Collider } from "@dimforge/rapier3d-compat";
 import React, { ReactNode } from "react";
-import { ColliderOptions, CuboidArgs, RoundCuboidArgs, BallArgs, CapsuleArgs, HeightfieldArgs, TrimeshArgs, ConeArgs, CylinderArgs, ConvexHullArgs } from "./types";
+import { ColliderOptions, CuboidArgs, RoundCuboidArgs, BallArgs, CapsuleArgs, HeightfieldArgs, TrimeshArgs, ConeArgs, CylinderArgs, ConvexHullArgs } from "../types";
 export interface ColliderProps extends ColliderOptions<any> {
     children?: ReactNode;
 }
-export declare const AnyCollider: React.MemoExoticComponent<React.ForwardRefExoticComponent<ColliderProps & React.RefAttributes<Collider[]>>>;
+/**
+ * A collider is a shape that can be attached to a rigid body to define its physical properties.
+ * @internal
+ */
+export declare const AnyCollider: React.MemoExoticComponent<React.ForwardRefExoticComponent<ColliderProps & React.RefAttributes<Collider>>>;
 export declare type ColliderOptionsRequiredArgs<T extends unknown[]> = Omit<ColliderOptions<T>, "args"> & {
     args: T;
     children?: ReactNode;
@@ -18,39 +22,75 @@ export declare type TrimeshColliderProps = ColliderOptionsRequiredArgs<TrimeshAr
 export declare type ConeColliderProps = ColliderOptionsRequiredArgs<ConeArgs>;
 export declare type CylinderColliderProps = ColliderOptionsRequiredArgs<CylinderArgs>;
 export declare type ConvexHullColliderProps = ColliderOptionsRequiredArgs<ConvexHullArgs>;
+/**
+ * A cuboid collider shape
+ * @category Colliders
+ */
 export declare const CuboidCollider: React.ForwardRefExoticComponent<Omit<ColliderOptions<CuboidArgs>, "args"> & {
     args: CuboidArgs;
     children?: ReactNode;
-} & React.RefAttributes<Collider[]>>;
+} & React.RefAttributes<Collider>>;
+/**
+ * A round cuboid collider shape
+ * @category Colliders
+ */
 export declare const RoundCuboidCollider: React.ForwardRefExoticComponent<Omit<ColliderOptions<RoundCuboidArgs>, "args"> & {
     args: RoundCuboidArgs;
     children?: ReactNode;
-} & React.RefAttributes<Collider[]>>;
+} & React.RefAttributes<Collider>>;
+/**
+ * A ball collider shape
+ * @category Colliders
+ */
 export declare const BallCollider: React.ForwardRefExoticComponent<Omit<ColliderOptions<BallArgs>, "args"> & {
     args: BallArgs;
     children?: ReactNode;
-} & React.RefAttributes<Collider[]>>;
+} & React.RefAttributes<Collider>>;
+/**
+ * A capsule collider shape
+ * @category Colliders
+ */
 export declare const CapsuleCollider: React.ForwardRefExoticComponent<Omit<ColliderOptions<CapsuleArgs>, "args"> & {
     args: CapsuleArgs;
     children?: ReactNode;
-} & React.RefAttributes<Collider[]>>;
+} & React.RefAttributes<Collider>>;
+/**
+ * A heightfield collider shape
+ * @category Colliders
+ */
 export declare const HeightfieldCollider: React.ForwardRefExoticComponent<Omit<ColliderOptions<HeightfieldArgs>, "args"> & {
     args: HeightfieldArgs;
     children?: ReactNode;
-} & React.RefAttributes<Collider[]>>;
+} & React.RefAttributes<Collider>>;
+/**
+ * A trimesh collider shape
+ * @category Colliders
+ */
 export declare const TrimeshCollider: React.ForwardRefExoticComponent<Omit<ColliderOptions<TrimeshArgs>, "args"> & {
     args: TrimeshArgs;
     children?: ReactNode;
-} & React.RefAttributes<Collider[]>>;
+} & React.RefAttributes<Collider>>;
+/**
+ * A cone collider shape
+ * @category Colliders
+ */
 export declare const ConeCollider: React.ForwardRefExoticComponent<Omit<ColliderOptions<ConeArgs>, "args"> & {
     args: ConeArgs;
     children?: ReactNode;
-} & React.RefAttributes<Collider[]>>;
+} & React.RefAttributes<Collider>>;
+/**
+ * A cylinder collider shape
+ * @category Colliders
+ */
 export declare const CylinderCollider: React.ForwardRefExoticComponent<Omit<ColliderOptions<CylinderArgs>, "args"> & {
     args: CylinderArgs;
     children?: ReactNode;
-} & React.RefAttributes<Collider[]>>;
+} & React.RefAttributes<Collider>>;
+/**
+ * A convex hull collider shape
+ * @category Colliders
+ */
 export declare const ConvexHullCollider: React.ForwardRefExoticComponent<Omit<ColliderOptions<ConvexHullArgs>, "args"> & {
     args: ConvexHullArgs;
     children?: ReactNode;
-} & React.RefAttributes<Collider[]>>;
+} & React.RefAttributes<Collider>>;

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

@@ -0,0 +1,12 @@
+import React, { ReactNode } from "react";
+import { RigidBodyProps } from "./RigidBody";
+import { RapierRigidBody } from "../types";
+export declare type InstancedRigidBodyProps = RigidBodyProps & {
+    key: string | number;
+};
+export interface InstancedRigidBodiesProps extends RigidBodyProps {
+    instances: InstancedRigidBodyProps[];
+    colliderNodes?: ReactNode[];
+    children: ReactNode;
+}
+export declare const InstancedRigidBodies: React.MemoExoticComponent<React.ForwardRefExoticComponent<InstancedRigidBodiesProps & React.RefAttributes<(RapierRigidBody | null)[]>>>;

package/dist/declarations/src/{MeshCollider.d.ts → components/MeshCollider.d.ts}

@@ -1,7 +1,11 @@
 import React, { ReactNode } from "react";
-import { RigidBodyAutoCollider } from "./types";
+import { RigidBodyAutoCollider } from "../types";
 export interface MeshColliderProps {
     children: ReactNode;
     type: RigidBodyAutoCollider;
 }
+/**
+ * A mesh collider is a collider that is automatically generated from the geometry of the children.
+ * @category Colliders
+ */
 export declare const MeshCollider: React.MemoExoticComponent<(props: MeshColliderProps) => JSX.Element>;

package/dist/declarations/src/{Physics.d.ts → components/Physics.d.ts}

@@ -2,10 +2,11 @@ import type Rapier from "@dimforge/rapier3d-compat";
 import { Collider, ColliderHandle, RigidBody, RigidBodyHandle } from "@dimforge/rapier3d-compat";
 import React, { FC, ReactNode } from "react";
 import { Matrix4, Object3D, Vector3 } from "three";
-import { CollisionEnterHandler, CollisionExitHandler, ContactForceHandler, IntersectionEnterHandler, IntersectionExitHandler, RigidBodyAutoCollider, Vector3Array } from "./types";
-import { WorldApi } from "./api";
+import { CollisionEnterHandler, CollisionExitHandler, ContactForceHandler, IntersectionEnterHandler, IntersectionExitHandler, RigidBodyAutoCollider, Vector3Array } from "../types";
+import { WorldApi } from "../utils/api";
 import { AttractorStateMap } from "./Attractor";
 export interface RigidBodyState {
+    meshType: "instancedMesh" | "mesh";
     rigidBody: RigidBody;
     object: Object3D;
     invertedWorldMatrix: Matrix4;
@@ -152,4 +153,8 @@ export interface PhysicsProps {
      **/
     interpolate?: boolean;
 }
+/**
+ * The main physics component used to create a physics world.
+ * @category Components
+ */
 export declare const Physics: FC<PhysicsProps>;

package/dist/declarations/src/{RigidBody.d.ts → components/RigidBody.d.ts}

@@ -1,20 +1,22 @@
 import React, { MutableRefObject, RefObject } from "react";
 import { ReactNode } from "react";
 import { Object3D } from "three";
-import { InstancedRigidBodyApi, RigidBodyApi } from "./api";
-import { InstancedRigidBodiesProps } from "./InstancedRigidBodies";
-import { RigidBodyOptions } from "./types";
+import { RapierRigidBody, RigidBodyOptions } from "../types";
 export declare const RigidBodyContext: React.Context<{
     ref: RefObject<Object3D> | MutableRefObject<Object3D>;
-    api: RigidBodyApi | InstancedRigidBodyApi;
-    options: RigidBodyOptions | InstancedRigidBodiesProps;
+    getRigidBody: () => RapierRigidBody;
+    options: RigidBodyOptions;
 }>;
 export declare const useRigidBodyContext: () => {
     ref: RefObject<Object3D> | MutableRefObject<Object3D>;
-    api: RigidBodyApi | InstancedRigidBodyApi;
-    options: RigidBodyOptions | InstancedRigidBodiesProps;
+    getRigidBody: () => RapierRigidBody;
+    options: RigidBodyOptions;
 };
 export interface RigidBodyProps extends RigidBodyOptions {
     children?: ReactNode;
 }
-export declare const RigidBody: React.MemoExoticComponent<React.ForwardRefExoticComponent<RigidBodyProps & React.RefAttributes<RigidBodyApi>>>;
+/**
+ * A rigid body is a physical object that can be simulated by the physics engine.
+ * @category Components
+ */
+export declare const RigidBody: React.MemoExoticComponent<React.ForwardRefExoticComponent<RigidBodyProps & React.RefAttributes<RapierRigidBody>>>;

package/dist/declarations/src/{hooks.d.ts → hooks/hooks.d.ts}

@@ -1,11 +1,23 @@
 import React, { MutableRefObject } from "react";
-import { RapierContext, WorldStepCallback } from "./Physics";
+import { RapierContext, WorldStepCallback } from "../components/Physics";
 import { Object3D } from "three";
-import { RigidBodyOptions } from "./types";
-import { ColliderProps, RigidBodyProps } from ".";
-import { RigidBodyApi } from "./api";
+import { ColliderProps, RigidBodyProps } from "..";
+/**
+ * Exposes the Rapier context, and world
+ * @category Hooks
+ */
 export declare const useRapier: () => RapierContext;
+/**
+ * Registers a callback to be called before the physics step
+ * @category Hooks
+ */
 export declare const useBeforePhysicsStep: (callback: WorldStepCallback) => void;
+/**
+ * Registers a callback to be called after the physics step
+ * @category Hooks
+ */
 export declare const useAfterPhysicsStep: (callback: WorldStepCallback) => void;
+/**
+ * @internal
+ */
 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?: RigidBodyOptions) => [React.MutableRefObject<O>, RigidBodyApi, ColliderProps[]];

package/dist/declarations/src/{joints.d.ts → hooks/joints.d.ts}

@@ -1,30 +1,41 @@
-import { ImpulseJoint } from "@dimforge/rapier3d-compat";
-import { RigidBodyApiRef, UseImpulseJoint, FixedJointParams, SphericalJointParams, RevoluteJointParams, PrismaticJointParams } from ".";
+import { ImpulseJoint, FixedImpulseJoint, SphericalImpulseJoint, RevoluteImpulseJoint, PrismaticImpulseJoint } from "@dimforge/rapier3d-compat";
+import React, { RefObject } from "react";
+import { RapierRigidBody, UseImpulseJoint, FixedJointParams, SphericalJointParams, RevoluteJointParams, PrismaticJointParams } from "..";
 import type Rapier from "@dimforge/rapier3d-compat";
-export declare const useImpulseJoint: <T extends ImpulseJoint>(body1: RigidBodyApiRef, body2: RigidBodyApiRef, params: Rapier.JointData) => import("./api").JointApi;
 /**
- *
+ * @internal
+ */
+export declare const useImpulseJoint: <JointType extends ImpulseJoint>(body1: RefObject<RapierRigidBody>, body2: RefObject<RapierRigidBody>, params: Rapier.JointData) => 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.
  * The fixed-joint makes these frames coincide in world-space.
+ *
+ * @category Hooks - Joints
  */
-export declare const useFixedJoint: UseImpulseJoint<FixedJointParams>;
+export declare const useFixedJoint: UseImpulseJoint<FixedJointParams, FixedImpulseJoint>;
 /**
  * The spherical joint ensures that two points on the local-spaces of two rigid-bodies always coincide (it prevents any relative
  * translational motion at this points). This is typically used to simulate ragdolls arms, pendulums, etc.
  * They are characterized by one local anchor on each rigid-body. Each anchor represents the location of the
  * points that need to coincide on the local-space of each rigid-body.
+ *
+ * @category Hooks - Joints
  */
-export declare const useSphericalJoint: UseImpulseJoint<SphericalJointParams>;
+export declare const useSphericalJoint: UseImpulseJoint<SphericalJointParams, SphericalImpulseJoint>;
 /**
  * The revolute joint prevents any relative movement between two rigid-bodies, except for relative
  * rotations along one axis. This is typically used to simulate wheels, fans, etc.
  * They are characterized by one local anchor as well as one local axis on each rigid-body.
+ *
+ * @category Hooks - Joints
  */
-export declare const useRevoluteJoint: UseImpulseJoint<RevoluteJointParams>;
+export declare const useRevoluteJoint: UseImpulseJoint<RevoluteJointParams, RevoluteImpulseJoint>;
 /**
  * The prismatic joint prevents any relative movement between two rigid-bodies, except for relative translations along one axis.
  * It is characterized by one local anchor as well as one local axis on each rigid-body. In 3D, an optional
  * local tangent axis can be specified for each rigid-body.
+ *
+ * @category Hooks - Joints
  */
-export declare const usePrismaticJoint: UseImpulseJoint<PrismaticJointParams>;
+export declare const usePrismaticJoint: UseImpulseJoint<PrismaticJointParams, PrismaticImpulseJoint>;

package/dist/declarations/src/hooks/use-imperative-instance.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Initiate an instance and return a safe getter
+ */
+export declare const useImperativeInstance: <InstanceType_1>(createFn: () => InstanceType_1, destroyFn: (instance: InstanceType_1) => void) => () => InstanceType_1;

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

@@ -1,18 +1,19 @@
 export * from "./types";
-export type { RigidBodyProps } from "./RigidBody";
-export type { InstancedRigidBodiesProps } from "./InstancedRigidBodies";
-export type { CylinderColliderProps, BallColliderProps, CapsuleColliderProps, ConeColliderProps, ConvexHullColliderProps, CuboidColliderProps, HeightfieldColliderProps, RoundCuboidColliderProps, TrimeshColliderProps, ColliderOptionsRequiredArgs } from "./AnyCollider";
-export type { PhysicsProps, RapierContext, WorldStepCallback } from "./Physics";
-export type { MeshColliderProps } from "./MeshCollider";
-export type { AttractorProps, AttractorGravityType } from "./Attractor";
-export type { RigidBodyApi, InstancedRigidBodyApi, JointApi, WorldApi } from "./api";
-export { Physics } from "./Physics";
-export { RigidBody } from "./RigidBody";
-export { MeshCollider } from "./MeshCollider";
-export { Debug } from "./Debug";
-export { InstancedRigidBodies } from "./InstancedRigidBodies";
-export * from "./AnyCollider";
-export { Attractor } from "./Attractor";
-export * from "./joints";
-export { useRapier, useBeforePhysicsStep, useAfterPhysicsStep } from "./hooks";
-export * from "./interaction-groups";
+export type { RigidBodyProps } from "./components/RigidBody";
+export type { InstancedRigidBodiesProps, InstancedRigidBodyProps } from "./components/InstancedRigidBodies";
+export type { CylinderColliderProps, BallColliderProps, CapsuleColliderProps, ConeColliderProps, ConvexHullColliderProps, CuboidColliderProps, HeightfieldColliderProps, RoundCuboidColliderProps, TrimeshColliderProps, ColliderOptionsRequiredArgs } from "./components/AnyCollider";
+export type { PhysicsProps, RapierContext, WorldStepCallback } from "./components/Physics";
+export type { MeshColliderProps } from "./components/MeshCollider";
+export type { AttractorProps, AttractorGravityType } from "./components/Attractor";
+export type { WorldApi } from "./utils/api";
+export { Physics } from "./components/Physics";
+export { RigidBody } from "./components/RigidBody";
+export { MeshCollider } from "./components/MeshCollider";
+export { Debug } from "./components/Debug";
+export { InstancedRigidBodies } from "./components/InstancedRigidBodies";
+export * from "./components/AnyCollider";
+export { Attractor } from "./components/Attractor";
+export * from "./hooks/joints";
+export { useRapier, useBeforePhysicsStep, useAfterPhysicsStep } from "./hooks/hooks";
+export * from "./utils/interaction-groups";
+export * from "./utils/three-object-helpers";

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

@@ -1,18 +1,14 @@
-import { MutableRefObject } from "react";
-import { CoefficientCombineRule, Collider as RapierCollider, InteractionGroups, RigidBody as RapierRigidBody, TempContactManifold } from "@dimforge/rapier3d-compat";
+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 { Object3D } from "three";
 import { ColliderProps } from ".";
-import { RigidBodyApi, JointApi } from "./api";
+import { RigidBodyState } from "./components/Physics";
 export { CoefficientCombineRule as CoefficientCombineRule } from "@dimforge/rapier3d-compat";
 export { RapierRigidBody, RapierCollider };
 export declare type RefGetter<T> = MutableRefObject<() => T | undefined>;
 export declare type RigidBodyAutoCollider = "ball" | "cuboid" | "hull" | "trimesh" | false;
-export interface UseRigidBodyAPI {
-    rigidBody: RapierRigidBody;
-    collider: RapierCollider;
-}
 export declare type CuboidArgs = [
     halfWidth: number,
     halfHeight: number,
@@ -323,6 +319,11 @@ export interface RigidBodyOptions extends ColliderProps {
      * Include invisible objects on the collider creation estimation.
      */
     includeInvisible?: boolean;
+    /**
+     * Transform the RigidBodyState
+     * @internal Do not use. Used internally by the InstancedRigidBodies to alter the RigidBody State
+     */
+    transformState?: (state: RigidBodyState) => RigidBodyState;
 }
 export declare type SphericalJointParams = [
     body1Anchor: Vector3Array,
@@ -347,7 +348,6 @@ export declare type RevoluteJointParams = [
     axis: Vector3Array,
     limits?: [min: number, max: number]
 ];
-export declare type RigidBodyApiRef = MutableRefObject<undefined | null | RigidBodyApi>;
-export interface UseImpulseJoint<P> {
-    (body1: RigidBodyApiRef, body2: RigidBodyApiRef, params: P): JointApi;
+export interface UseImpulseJoint<JointParams, JointType extends ImpulseJoint> {
+    (body1: RefObject<RapierRigidBody>, body2: RefObject<RapierRigidBody>, params: JointParams): RefObject<JointType | undefined>;
 }

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

@@ -0,0 +1,18 @@
+import { Collider, ColliderDesc, DebugRenderBuffers, ImpulseJoint, JointData, RigidBody, RigidBodyDesc, World } from "@dimforge/rapier3d-compat";
+import { Vector3 } from "three";
+import { RefGetter } from "../types";
+export interface WorldApi {
+    raw(): World;
+    getCollider(handle: number): Collider | undefined;
+    getRigidBody(handle: number): RigidBody | undefined;
+    createRigidBody(desc: RigidBodyDesc): RigidBody;
+    createCollider(desc: ColliderDesc, parent?: RigidBody): Collider;
+    removeRigidBody(rigidBody: RigidBody): void;
+    removeCollider(collider: Collider, wakeUp?: boolean): void;
+    createImpulseJoint(params: JointData, rigidBodyA: RigidBody, rigidBodyB: RigidBody, wakeUp?: boolean): ImpulseJoint;
+    removeImpulseJoint(joint: ImpulseJoint, wakeUp?: boolean): void;
+    forEachCollider(callback: (collider: Collider) => void): void;
+    setGravity(gravity: Vector3): void;
+    debugRender(): DebugRenderBuffers;
+}
+export declare const createWorldApi: (ref: RefGetter<World>) => WorldApi;

package/dist/declarations/src/utils/three-object-helpers.d.ts

@@ -0,0 +1,29 @@
+import { Euler, Quaternion, Vector3 } from "three";
+/**
+ * Takes an object resembling a Vector3 and returs a Three.Vector3
+ * @category Math helpers
+ */
+export declare const vec3: ({ x, y, z }?: {
+    x: number;
+    y: number;
+    z: number;
+}) => Vector3;
+/**
+ * Takes an object resembling a Quaternion and returs a Three.Quaternion
+ * @category Math helpers
+ */
+export declare const quat: ({ x, y, z, w }?: {
+    x: number;
+    y: number;
+    z: number;
+    w: number;
+}) => Quaternion;
+/**
+ * Takes an object resembling an Euler and returs a Three.Euler
+ * @category Math helpers
+ */
+export declare const euler: ({ x, y, z }?: {
+    x: number;
+    y: number;
+    z: number;
+}) => Euler;

package/dist/declarations/src/{utils-collider.d.ts → utils/utils-collider.d.ts}

@@ -1,10 +1,9 @@
 import { Collider, RigidBody } from "@dimforge/rapier3d-compat";
-import { MutableRefObject } from "react";
 import { BufferGeometry, Object3D, Vector3 } from "three";
-import { ColliderProps, RigidBodyProps } from ".";
+import { ColliderProps, RigidBodyProps } from "..";
 import { WorldApi } from "./api";
-import { ColliderState, ColliderStateMap, EventMap } from "./Physics";
-import { ColliderShape, RigidBodyAutoCollider } from "./types";
+import { ColliderState, ColliderStateMap, EventMap } from "../components/Physics";
+import { ColliderShape, RigidBodyAutoCollider } from "../types";
 export declare const scaleColliderArgs: (shape: ColliderShape, args: (number | ArrayLike<number> | {
     x: number;
     y: number;
@@ -14,11 +13,11 @@ export declare const scaleColliderArgs: (shape: ColliderShape, args: (number | A
     y: number;
     z: number;
 })[];
-export declare const createColliderFromOptions: (options: ColliderProps, world: WorldApi, scale: Vector3, rigidBody?: RigidBody) => Collider;
+export declare const createColliderFromOptions: (options: ColliderProps, world: WorldApi, scale: Vector3, getRigidBody?: () => RigidBody) => 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 useUpdateColliderOptions: (getCollider: () => Collider, props: ColliderProps, states: ColliderStateMap) => void;
 export declare const createColliderState: (collider: Collider, object: Object3D, rigidBodyObject?: Object3D | null) => ColliderState;
 interface CreateColliderPropsFromChildren {
     (options: {
@@ -32,5 +31,5 @@ export declare const getColliderArgsFromGeometry: (geometry: BufferGeometry, col
     args: unknown[];
     offset: Vector3;
 };
-export declare const useColliderEvents: (collidersRef: MutableRefObject<Collider[] | undefined>, props: ColliderProps, events: EventMap) => void;
+export declare const useColliderEvents: (getCollider: () => Collider, props: ColliderProps, events: EventMap) => void;
 export {};

package/dist/declarations/src/{utils-rigidbody.d.ts → utils/utils-rigidbody.d.ts}

@@ -1,8 +1,7 @@
 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";
+import { RigidBodyProps } from "..";
+import { EventMap, RigidBodyState, RigidBodyStateMap } from "../components/Physics";
 export declare const rigidBodyDescFromOptions: (options: RigidBodyProps) => RigidBodyDesc;
 interface CreateRigidBodyStateOptions {
     object: Object3D;
@@ -10,11 +9,12 @@ interface CreateRigidBodyStateOptions {
     setMatrix?: (matrix: Matrix4) => void;
     getMatrix?: (matrix: Matrix4) => Matrix4;
     worldScale?: Vector3;
+    meshType?: RigidBodyState["meshType"];
 }
-export declare const createRigidBodyState: ({ rigidBody, object, setMatrix, getMatrix, worldScale }: CreateRigidBodyStateOptions) => RigidBodyState;
+export declare const createRigidBodyState: ({ rigidBody, object, setMatrix, getMatrix, worldScale, meshType }: 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 declare const useUpdateRigidBodyOptions: (getRigidBody: () => RigidBody, props: RigidBodyProps, states: RigidBodyStateMap, updateTranslations?: boolean) => void;
+export declare const useRigidBodyEvents: (getRigidBody: () => RigidBody, props: RigidBodyProps, events: EventMap) => void;
 export {};

package/dist/declarations/src/{utils.d.ts → utils/utils.d.ts}

@@ -1,12 +1,12 @@
 import { Quaternion as RapierQuaternion, Vector3 as RapierVector3 } from "@dimforge/rapier3d-compat";
 import { Euler, Quaternion, Vector3 } from "three";
-import { RigidBodyTypeString, Vector3Array } from "./types";
+import { RigidBodyTypeString, Vector3Array } from "../types";
 export declare const vectorArrayToVector3: (arr: Vector3Array) => 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 rigidBodyTypeFromString: (type: RigidBodyTypeString) => number;
+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[];
 export declare function useConst<T>(initialValue: T | (() => T)): T;