@react-three/rapier 0.5.1 → 0.6.1

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

@@ -1,15 +1,5 @@
-import React from "react";
 import { ReactNode } from "react";
-import { BallArgs, CapsuleArgs, ConeArgs, ConvexHullArgs, CuboidArgs, CylinderArgs, HeightfieldArgs, RigidBodyAutoCollider, RoundCuboidArgs, TrimeshArgs, UseColliderOptions, UseRigidBodyOptions } from "./types";
-interface RigidBodyProps extends UseRigidBodyOptions {
-    children?: ReactNode;
-}
-export declare const RigidBody: React.ForwardRefExoticComponent<RigidBodyProps & React.RefAttributes<import("./api").RigidBodyApi>>;
-interface MeshColliderProps {
-    children: ReactNode;
-    type: RigidBodyAutoCollider;
-}
-export declare const MeshCollider: ({ children, type }: MeshColliderProps) => JSX.Element;
+import { UseColliderOptions, CuboidArgs, RoundCuboidArgs, BallArgs, CapsuleArgs, HeightfieldArgs, TrimeshArgs, ConeArgs, CylinderArgs, ConvexHullArgs } from "./types";
 declare type UseColliderOptionsRequiredArgs<T> = Omit<UseColliderOptions<T>, "args"> & {
     args: T;
     children?: ReactNode;

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

@@ -0,0 +1,10 @@
+import React from "react";
+import { InstancedRigidBodyApi } from "./api";
+import { RigidBodyProps } from "./RigidBody";
+import { Vector3Array } from "./types";
+interface InstancedRigidBodiesProps extends Omit<RigidBodyProps, "position" | "rotation" | "onCollisionEnter" | "onCollisionExit"> {
+    positions?: Vector3Array[];
+    rotations?: Vector3Array[];
+}
+export declare const InstancedRigidBodies: React.ForwardRefExoticComponent<InstancedRigidBodiesProps & React.RefAttributes<InstancedRigidBodyApi>>;
+export {};

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

@@ -0,0 +1,8 @@
+import { ReactNode } from "react";
+import { RigidBodyAutoCollider } from "./types";
+interface MeshColliderProps {
+    children: ReactNode;
+    type: RigidBodyAutoCollider;
+}
+export declare const MeshCollider: ({ children, type }: MeshColliderProps) => JSX.Element;
+export {};

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

@@ -2,12 +2,18 @@ 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 { Object3D } from "three";
+import { Matrix4, Object3D, Vector3 } from "three";
 export interface RapierContext {
     rapier: typeof Rapier;
     world: WorldApi;
     colliderMeshes: Map<ColliderHandle, Object3D>;
-    rigidBodyMeshes: Map<ColliderHandle, Object3D>;
+    rigidBodyStates: Map<RigidBodyHandle, {
+        mesh: Object3D;
+        isSleeping: boolean;
+        setMatrix: (mat: Matrix4) => void;
+        worldScale: Vector3;
+        invertedMatrixWorld: Matrix4;
+    }>;
     physicsOptions: {
         colliders: RigidBodyAutoCollider;
     };
@@ -17,7 +23,7 @@ export declare const RapierContext: React.Context<RapierContext | undefined>;
 declare type EventMap = Map<ColliderHandle | RigidBodyHandle, {
     onSleep?(): void;
     onWake?(): void;
-    onCollisionEnter?({ target, manifold, flipped }: {
+    onCollisionEnter?({ target, manifold, flipped, }: {
         target: RigidBody;
         manifold: TempContactManifold;
         flipped: boolean;
@@ -51,7 +57,7 @@ interface RapierWorldProps {
      *
      * @defaultValue "vary"
      */
-    timeStep?: number | 'vary';
+    timeStep?: number | "vary";
 }
 export declare const Physics: FC<RapierWorldProps>;
 export {};

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

@@ -0,0 +1,14 @@
+import React, { MutableRefObject } from "react";
+import { ReactNode } from "react";
+import { Object3D } from "three";
+import { RigidBodyApi, UseRigidBodyOptions } from "./types";
+export declare const useRigidBodyContext: () => {
+    ref: MutableRefObject<Object3D>;
+    api: RigidBodyApi;
+    hasCollisionEvents: boolean;
+    options: UseRigidBodyOptions;
+};
+export interface RigidBodyProps extends UseRigidBodyOptions {
+    children?: ReactNode;
+}
+export declare const RigidBody: React.ForwardRefExoticComponent<RigidBodyProps & React.RefAttributes<import("./api").RigidBodyApi>>;

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

@@ -119,6 +119,15 @@ export interface RigidBodyApi {
     setEnabledTranslations(x: boolean, y: boolean, z: boolean): void;
 }
 export declare const createRigidBodyApi: (ref: RefGetter<RigidBody>) => RigidBodyApi;
+export interface InstancedRigidBodyApi {
+    at(index: number): RigidBodyApi;
+    get count(): number;
+    forEach(callback: (body: RigidBodyApi, index: number, array: RigidBodyApi[]) => void): void;
+}
+export declare const createInstancedRigidBodiesApi: (bodiesGetter: RefGetter<{
+    rigidBody: RigidBody;
+    api: RigidBodyApi;
+}[]>) => InstancedRigidBodyApi;
 export declare const createColliderApi: (ref: RefGetter<Collider>) => {
     raw: () => Collider | undefined;
     readonly handle: number;

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

@@ -3,12 +3,8 @@ import { RapierContext } from "./Physics";
 import { Object3D } from "three";
 import type Rapier from "@dimforge/rapier3d-compat";
 export declare const useRapier: () => RapierContext;
-import { UseRigidBodyOptions, UseImpulseJoint, SphericalJointParams, FixedJointParams, PrismaticJointParams, RevoluteJointParams, UseColliderOptions, RigidBodyApi, RigidBodyApiRef } from "./types";
+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];
-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 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,9 @@
+export * from "./types";
+export type { RigidBodyApi, WorldApi, InstancedRigidBodyApi } 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 * from "./hooks";
-export * from "./components";
-export * from "./Debug";
-export * from "./types";

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

@@ -0,0 +1,6 @@
+import { Euler, Matrix4, Object3D, Quaternion, Vector3 } from "three";
+export declare const _quaternion: Quaternion;
+export declare const _euler: Euler;
+export declare const _vector3: Vector3;
+export declare const _object3d: Object3D<import("three").Event>;
+export declare const _matrix4: Matrix4;

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

@@ -2,9 +2,9 @@ import { MutableRefObject } from "react";
 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 { 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 declare type RigidBodyAutoCollider = "ball" | "cuboid" | "hull" | "trimesh" | false;
 export interface UseRigidBodyAPI {
     rigidBody: RapierRigidBody;
     collider: RapierCollider;
@@ -65,7 +65,7 @@ export declare type RigidBodyTypeString = "fixed" | "dynamic" | "kinematicPositi
 export declare type RigidBodyShape = "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<A> {
+export interface UseColliderOptions<ColliderArgs> {
     /**
      * The shape of your collider
      */
@@ -73,7 +73,7 @@ export interface UseColliderOptions<A> {
     /**
      * Arguments to pass to the collider
      */
-    args?: A;
+    args?: ColliderArgs;
     /**
      * The mass of this rigid body.
      * The mass and density is automatically calculated based on the shape of the collider.

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

@@ -1,18 +1,37 @@
-import { Collider, RigidBody } from "@dimforge/rapier3d-compat";
-import { Object3D, Quaternion, Vector3 } from "three";
-import { RigidBodyApi, RigidBodyShape, RigidBodyTypeString, UseColliderOptions, UseRigidBodyOptions, Vector3Array, WorldApi } from "./types";
+import { Collider, ColliderDesc, RigidBody, RigidBodyDesc, Vector3 as RapierVector3, Quaternion as RapierQuaternion } from "@dimforge/rapier3d-compat";
+import { BufferGeometry, Matrix4, Object3D, Quaternion, Vector3 } from "three";
+import { RigidBodyApi, RigidBodyAutoCollider, RigidBodyShape, RigidBodyTypeString, UseColliderOptions, UseRigidBodyOptions, Vector3Array, WorldApi } from "./types";
 export declare const vectorArrayToObject: (arr: Vector3Array) => {
     x: number;
     y: number;
     z: 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 decomposeMatrix4: (m: Matrix4) => {
+    position: Vector3;
+    rotation: Quaternion;
+    scale: Vector3;
+};
 export declare const scaleColliderArgs: (shape: RigidBodyShape, args: (number | ArrayLike<number>)[], scale: Vector3) => (number | ArrayLike<number>)[];
-export declare const createColliderFromOptions: <A>(options: UseColliderOptions<A>, world: WorldApi, rigidBody?: RigidBody | undefined, scale?: {
-    x: number;
-    y: number;
-    z: number;
-}, hasCollisionEvents?: boolean) => Collider;
-export declare const createCollidersFromChildren: (object: Object3D, rigidBody: RigidBodyApi, options: UseRigidBodyOptions, world: WorldApi, ignoreMeshColliders?: boolean) => Collider[];
+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;
+export declare const createCollidersFromChildren: (object: Object3D, rigidBody: RigidBodyApi | RigidBody, options: UseRigidBodyOptions, world: WorldApi, ignoreMeshColliders?: boolean) => Collider[];
+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 vector3ToQuaternion: (v: Vector3) => Quaternion;
+export declare const rigidBodyDescFromOptions: (options: UseRigidBodyOptions) => RigidBodyDesc;
+export {};