@react-three/rapier 0.4.3 → 0.5.2

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

@@ -27,9 +27,31 @@ declare type EventMap = Map<ColliderHandle | RigidBodyHandle, {
     }): void;
 }>;
 interface RapierWorldProps {
+    children: ReactNode;
+    /**
+     * Set the gravity of the physics world
+     * @defaultValue [0, -9.81, 0]
+     */
     gravity?: Vector3Array;
+    /**
+     * Set the base automatic colliders for this physics world
+     * All Meshes inside RigidBodies will generate a collider
+     * based on this value, if not overridden.
+     */
     colliders?: RigidBodyAutoCollider;
-    children: ReactNode;
+    /**
+     * Set the timestep for the simulation.
+     * Setting this to a number (eg. 1/60) will run the
+     * simulation at that framerate.
+     *
+     * "vary" will run the simulation at a delta-value based
+     * on the users current framerate. This ensures simulations
+     * run at the same percieved speed at all framerates, but
+     * can also lead to instability.
+     *
+     * @defaultValue "vary"
+     */
+    timeStep?: number | 'vary';
 }
 export declare const Physics: FC<RapierWorldProps>;
 export {};

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

@@ -101,6 +101,22 @@ export interface RigidBodyApi {
      * Resets to zero the user torques applied to this rigid-body.
      */
     resetTorques(): void;
+    /**
+     * Locks or unlocks the ability of this rigid-body to rotate.
+     */
+    lockRotations(locked: boolean): void;
+    /**
+     * Locks or unlocks the ability of this rigid-body to translate.
+     */
+    lockTranslations(locked: boolean): void;
+    /**
+     * Locks or unlocks the ability of this rigid-body to rotate along individual coordinate axes.
+     */
+    setEnabledRotations(x: boolean, y: boolean, z: boolean): void;
+    /**
+     * Locks or unlocks the ability of this rigid-body to translate along individual coordinate axes.
+     */
+    setEnabledTranslations(x: boolean, y: boolean, z: boolean): void;
 }
 export declare const createRigidBodyApi: (ref: RefGetter<RigidBody>) => RigidBodyApi;
 export declare const createColliderApi: (ref: RefGetter<Collider>) => {
@@ -112,12 +128,13 @@ export interface WorldApi {
     getCollider(handle: number): Collider | undefined;
     getRigidBody(handle: number): RigidBody | undefined;
     createRigidBody(desc: RigidBodyDesc): RigidBody;
-    createCollider(desc: ColliderDesc, rigidBody: RigidBody): Collider;
+    createCollider(desc: ColliderDesc, parent?: RigidBody): 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;
+    setGravity(gravity: Vector3): void;
 }
 export declare const createWorldApi: (ref: RefGetter<World>) => WorldApi;
 export declare const createJointApi: (ref: RefGetter<ImpulseJoint>) => {

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

@@ -1,10 +1,15 @@
 import React from "react";
 import { ReactNode } from "react";
-import { BallArgs, CapsuleArgs, ConeArgs, ConvexHullArgs, CuboidArgs, CylinderArgs, HeightfieldArgs, RoundCuboidArgs, TrimeshArgs, UseColliderOptions, UseRigidBodyOptions } from "./types";
+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;
 declare type UseColliderOptionsRequiredArgs<T> = Omit<UseColliderOptions<T>, "args"> & {
     args: T;
     children?: ReactNode;

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

@@ -1,47 +1,15 @@
 import React, { MutableRefObject } from "react";
 import { RapierContext } from "./Physics";
-import { Mesh, Object3D } from "three";
+import { Object3D } 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, RigidBodyApi } from "./types";
-import { RoundCone } from "@dimforge/rapier3d-compat";
+import { UseRigidBodyOptions, UseImpulseJoint, SphericalJointParams, FixedJointParams, PrismaticJointParams, RevoluteJointParams, UseColliderOptions, 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 useRigidBodyWithCollider: <A, O extends Object3D<import("three").Event> = Object3D<import("three").Event>>(rigidBodyOptions?: UseRigidBodyOptions | undefined, colliderOptions?: UseColliderOptions<A> | undefined) => [ref: React.MutableRefObject<O>, rigidBody: import("./api").RigidBodyApi];
-export declare const useCuboid: <T extends Object3D<import("three").Event>>(rigidBodyOptions?: UseBodyOptions, colliderOptions?: UseColliderOptions<CuboidArgs>) => [ref: React.MutableRefObject<T>, rigidBody: import("./api").RigidBodyApi];
-export declare const useBall: <T extends Object3D<import("three").Event>>(rigidBodyOptions?: UseBodyOptions, colliderOptions?: UseColliderOptions<BallArgs>) => [ref: React.MutableRefObject<T>, rigidBody: import("./api").RigidBodyApi];
-export declare const useCapsule: <T extends Object3D<import("three").Event>>(rigidBodyOptions?: UseBodyOptions, colliderOptions?: UseColliderOptions<CapsuleArgs>) => [ref: React.MutableRefObject<T>, rigidBody: import("./api").RigidBodyApi];
-export declare const useHeightfield: <T extends Object3D<import("three").Event>>(rigidBodyOptions?: UseBodyOptions, colliderOptions?: UseColliderOptions<HeightfieldArgs>) => [ref: React.MutableRefObject<T>, rigidBody: import("./api").RigidBodyApi];
-/**
- * Create a trimesh collider and rigid body.
- * Note that Trimeshes don't have mass unless provided.
- * See https://rapier.rs/docs/user_guides/javascript/rigid_bodies#mass-properties
- * for available properties.
- */
-export declare const useTrimesh: {
-    <T extends Object3D<import("three").Event>>(rigidBodyOptions?: UseBodyOptions, colliderOptions?: UseColliderOptions<TrimeshArgs>): [ref: React.MutableRefObject<T>, rigidBody: import("./api").RigidBodyApi];
-    fromMesh<T_1 extends Object3D<import("three").Event>>(mesh: Mesh, rigidBodyOptions?: UseBodyOptions, colliderOptions?: UseColliderOptions<TrimeshArgs>): [ref: React.MutableRefObject<T_1>, rigidBody: import("./api").RigidBodyApi];
-};
-export declare const usePolyline: <T extends Object3D<import("three").Event>>(rigidBodyOptions?: UseBodyOptions, colliderOptions?: UseColliderOptions<PolylineArgs>) => [ref: React.MutableRefObject<T>, rigidBody: import("./api").RigidBodyApi];
-export declare const useRoundCuboid: <T extends Object3D<import("three").Event>>(rigidBodyOptions?: UseBodyOptions, colliderOptions?: UseColliderOptions<RoundCuboidArgs>) => [ref: React.MutableRefObject<T>, rigidBody: import("./api").RigidBodyApi];
-export declare const useCylinder: <T extends Object3D<import("three").Event>>(rigidBodyOptions?: UseBodyOptions, colliderOptions?: UseColliderOptions<CylinderArgs>) => [ref: React.MutableRefObject<T>, rigidBody: import("./api").RigidBodyApi];
-export declare const useRoundCylinder: <T extends Object3D<import("three").Event>>(rigidBodyOptions?: UseBodyOptions, colliderOptions?: UseColliderOptions<RoundCylinderArgs>) => [ref: React.MutableRefObject<T>, rigidBody: import("./api").RigidBodyApi];
-export declare const useCone: <T extends Object3D<import("three").Event>>(rigidBodyOptions?: UseBodyOptions, colliderOptions?: UseColliderOptions<ConeArgs>) => [ref: React.MutableRefObject<T>, rigidBody: import("./api").RigidBodyApi];
-export declare const useRoundCone: <T extends Object3D<import("three").Event>>(rigidBodyOptions?: UseBodyOptions, colliderOptions?: UseColliderOptions<RoundCone>) => [ref: React.MutableRefObject<T>, rigidBody: import("./api").RigidBodyApi];
-export declare const useConvexHull: {
-    <T extends Object3D<import("three").Event>>(rigidBodyOptions?: UseBodyOptions, colliderOptions?: UseColliderOptions<ConvexHullArgs>): [ref: React.MutableRefObject<T>, rigidBody: import("./api").RigidBodyApi];
-    fromMesh<T_1 extends Object3D<import("three").Event>>(mesh: Mesh, rigidBodyOptions?: UseBodyOptions, colliderOptions?: Omit<UseColliderOptions<ConvexHullArgs>, "colliderArgs">): [ref: React.MutableRefObject<T_1>, rigidBody: import("./api").RigidBodyApi];
-};
-export declare const useRoundConvexHull: <T extends Object3D<import("three").Event>>(rigidBodyOptions?: UseBodyOptions, colliderOptions?: UseColliderOptions<RoundConvexHullArgs>) => [ref: React.MutableRefObject<T>, rigidBody: import("./api").RigidBodyApi];
-export declare const useConvexMesh: {
-    <T extends Object3D<import("three").Event>>(rigidBodyOptions?: UseBodyOptions, colliderOptions?: UseColliderOptions<ConvexMeshArgs>): [ref: React.MutableRefObject<Object3D<import("three").Event>>, rigidBody: import("./api").RigidBodyApi];
-    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: import("./api").RigidBodyApi];
-};
-export declare const useRoundConvexMesh: <T extends Object3D<import("three").Event>>(rigidBodyOptions?: UseBodyOptions, colliderOptions?: UseColliderOptions<RoundConvexMeshArgs>) => [ref: React.MutableRefObject<Object3D<import("three").Event>>, rigidBody: import("./api").RigidBodyApi];
-export declare const useImpulseJoint: <T extends Rapier.ImpulseJoint>(body1: MutableRefObject<RapierRigidBody | undefined | null> | RigidBodyApi, body2: MutableRefObject<RapierRigidBody | undefined | null> | RigidBodyApi, params: Rapier.JointData) => {
+export declare const useImpulseJoint: <T extends Rapier.ImpulseJoint>(body1: RigidBodyApiRef, body2: RigidBodyApiRef, params: Rapier.JointData) => {
     raw: () => Rapier.ImpulseJoint | undefined;
     readonly handle: number;
     configureMotorPosition: (targetPos: number, stiffness: number, damping: number) => void;

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;
@@ -64,7 +64,8 @@ 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 Vector3Array = [x: number, y: number, z: number];
-export interface UseColliderOptions<A> {
+export declare type Boolean3Array = [x: boolean, y: boolean, z: boolean];
+export interface UseColliderOptions<ColliderArgs> {
     /**
      * The shape of your collider
      */
@@ -72,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.
@@ -188,6 +189,22 @@ export interface UseRigidBodyOptions {
     }): void;
     onSleep?(): void;
     onWake?(): void;
+    /**
+     * Locks all rotations that would have resulted from forces on the created rigid-body.
+     */
+    lockRotations?: boolean;
+    /**
+     * Locks all translations that would have resulted from forces on the created rigid-body.
+     */
+    lockTranslations?: boolean;
+    /**
+     * Allow rotation of this rigid-body only along specific axes.
+     */
+    enabledRotations?: Boolean3Array;
+    /**
+     * Allow rotation of this rigid-body only along specific axes.
+     */
+    enabledTranslations?: Boolean3Array;
 }
 export declare type SphericalJointParams = [
     body1Anchor: Vector3Array,
@@ -207,12 +224,12 @@ export declare type PrismaticJointParams = [
 ];
 export declare type RevoluteJointParams = [
     body1Anchor: Vector3Array,
-    body1LocalFrame: Vector3Array,
     body2Anchor: Vector3Array,
-    body2LocalFrame: Vector3Array
+    axis: Vector3Array
 ];
+export declare type RigidBodyApiRef = MutableRefObject<undefined | null | RigidBodyApi>;
 export interface UseImpulseJoint<P> {
-    (body1: MutableRefObject<RapierRigidBody | undefined | null>, body2: MutableRefObject<RapierRigidBody | undefined | null>, params: P): JointApi;
+    (body1: RigidBodyApiRef, body2: RigidBodyApiRef, params: P): JointApi;
 }
 export declare type RigidBodyApi = ReturnType<typeof createRigidBodyApi>;
 export declare type ColliderApi = ReturnType<typeof createColliderApi>;

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

@@ -1,17 +1,28 @@
 import { Collider, RigidBody } from "@dimforge/rapier3d-compat";
-import { Object3D, Vector3 } from "three";
-import { RigidBodyShape, RigidBodyTypeString, UseColliderOptions, UseRigidBodyOptions, Vector3Array, WorldApi } from "./types";
+import { Object3D, Quaternion, Vector3 } from "three";
+import { RigidBodyApi, 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 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: WorldApi, rigidBody: RigidBody, scale?: {
-    x: number;
-    y: number;
-    z: number;
-}, hasCollisionEvents?: boolean) => Collider;
-export declare const createCollidersFromChildren: (object: Object3D, rigidBody: RigidBody, options: UseRigidBodyOptions, world: WorldApi) => 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, options: UseRigidBodyOptions, world: WorldApi, ignoreMeshColliders?: boolean) => Collider[];
 export declare const scaleVertices: (vertices: ArrayLike<number>, scale: Vector3) => number[];
+export {};