@react-three/rapier 0.1.0

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

@@ -0,0 +1,2 @@
+/// <reference types="react" />
+export declare const Debug: () => JSX.Element;

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

@@ -0,0 +1,16 @@
+import React, { FC, ReactNode } from "react";
+import type Rapier from "@dimforge/rapier3d-compat";
+import { RigidBodyAutoCollider, Vector3Array } from "./types";
+export interface RapierContext {
+    RAPIER: typeof Rapier;
+    world: Rapier.World;
+    stepFuncs: Array<() => void>;
+}
+export declare const RapierContext: React.Context<RapierContext | undefined>;
+interface RapierWorldProps {
+    gravity?: Vector3Array;
+    colliders?: RigidBodyAutoCollider;
+    children: ReactNode;
+}
+export declare const Physics: FC<RapierWorldProps>;
+export {};

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

@@ -0,0 +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";
+interface RigidBodyProps extends UseRigidBodyOptions {
+    children?: ReactNode;
+    colliders?: RigidBodyAutoCollider | false;
+}
+export declare const RigidBody: React.ForwardRefExoticComponent<RigidBodyProps & React.RefAttributes<RapierRigidBody>>;
+declare type UseColliderOptionsRequiredArgs<T> = Omit<UseColliderOptions<T>, "args"> & {
+    args: T;
+};
+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 {};

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

@@ -0,0 +1,67 @@
+import React, { MutableRefObject } from "react";
+import { RapierContext } from "./Physics";
+import { Mesh, 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 } 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];
+/**
+ * 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: 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];
+};
+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 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];
+};
+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 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];
+};
+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.
+ * 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.
+ */
+export declare const useFixedJoint: UseImpulseJoint<FixedJointParams>;
+/**
+ * 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.
+ */
+export declare const useSphericalJoint: UseImpulseJoint<SphericalJointParams>;
+/**
+ * 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.
+ */
+export declare const useRevoluteJoint: UseImpulseJoint<RevoluteJointParams>;
+/**
+ * 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.
+ */
+export declare const usePrismaticJoint: UseImpulseJoint<PrismaticJointParams>;

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

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

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

@@ -0,0 +1,188 @@
+import { MutableRefObject } from "react";
+import { CoefficientCombineRule, RigidBody as RapierRigidBody, Collider as RapierCollider } from "@dimforge/rapier3d-compat";
+export { RapierRigidBody, RapierCollider };
+export { CoefficientCombineRule as CoefficientCombineRule, } from "@dimforge/rapier3d-compat";
+export declare type RigidBodyAutoCollider = 'ball' | 'cuboid' | 'hull' | 'trimesh' | false;
+export interface UseRigidBodyAPI {
+    rigidBody: RapierRigidBody;
+    collider: RapierCollider;
+}
+export declare type CuboidArgs = [
+    halfWidth: number,
+    halfHeight: number,
+    halfDepth: number
+];
+export declare type BallArgs = [radius: number];
+export declare type CapsuleArgs = [radius: number, height: number];
+export declare type ConvexHullArgs = [vertices: ArrayLike<number>];
+export declare type HeightfieldArgs = [
+    width: number,
+    height: number,
+    heights: number[],
+    scale: number
+];
+export declare type TrimeshArgs = [
+    vertices: ArrayLike<number>,
+    indices: ArrayLike<number>
+];
+export declare type PolylineArgs = [vertices: Float32Array, indices: Uint32Array];
+export declare type RoundCuboidArgs = [
+    halfWidth: number,
+    halfHeight: number,
+    halfDepth: number,
+    borderRadius: number
+];
+export declare type CylinderArgs = [radius: number, height: number];
+export declare type RoundCylinderArgs = [
+    radius: number,
+    height: number,
+    borderRadius: number
+];
+export declare type ConeArgs = [radius: number, height: number];
+export declare type RoundConeArgs = [
+    radius: number,
+    height: number,
+    borderRadius: number
+];
+export declare type ConvexMeshArgs = [
+    vertices: ArrayLike<number>,
+    indices: ArrayLike<number>
+];
+export declare type RoundConvexHullArgs = [
+    vertices: ArrayLike<number>,
+    indices: ArrayLike<number>,
+    borderRadius: number
+];
+export declare type RoundConvexMeshArgs = [
+    vertices: ArrayLike<number>,
+    indices: ArrayLike<number>,
+    borderRadius: number
+];
+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> {
+    /**
+     * The shape of your collider
+     */
+    shape?: RigidBodyShape;
+    /**
+     * Arguments to pass to the collider
+     */
+    args?: A;
+    /**
+     * The mass of this rigid body.
+     * 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.
+     * More info https://rapier.rs/docs/user_guides/javascript/colliders#mass-properties
+     */
+    mass?: number;
+    /**
+     * The center of mass of this rigid body
+     */
+    centerOfMass?: Vector3Array;
+    /**
+     * Principal angular inertia of this rigid body
+     */
+    principalAngularInertia?: Vector3Array;
+    /**
+     * Restitution controls how elastic (aka. bouncy) a contact is. Le elasticity of a contact is controlled by the restitution coefficient
+     */
+    restitution?: number;
+    /**
+     * What happens when two bodies meet. See https://rapier.rs/docs/user_guides/javascript/colliders#friction.
+     */
+    restitutionCombineRule?: CoefficientCombineRule;
+    /**
+     * Friction is a force that opposes the relative tangential motion between two rigid-bodies with colliders in contact.
+     * A friction coefficient of 0 implies no friction at all (completely sliding contact) and a coefficient
+     * greater or equal to 1 implies a very strong friction. Values greater than 1 are allowed.
+     */
+    friction?: number;
+    /**
+     * What happens when two bodies meet. See https://rapier.rs/docs/user_guides/javascript/colliders#friction.
+     */
+    frictionCombineRule?: CoefficientCombineRule;
+    /**
+     * The position of this collider relative to the rigid body
+     */
+    position?: Vector3Array;
+    /**
+     * The rotation of this collider relative to the rigid body
+     */
+    rotation?: Vector3Array;
+}
+export interface UseRigidBodyOptions {
+    /**
+     * Specify the type of this rigid body
+     */
+    type?: RigidBodyTypeString;
+    /** Whether or not this body can sleep.
+     * default: true
+     */
+    canSleep?: boolean;
+    /** The linear velocity of this body.
+     * default: zero velocity
+     */
+    linearVelocity?: Vector3Array;
+    /** The angular velocity of this body.
+     * Default: zero velocity.
+     */
+    angularVelocity?: Vector3Array;
+    /**
+     * The scaling factor applied to the gravity affecting the rigid-body.
+     * Default: 1.0
+     */
+    gravityScale?: number;
+    /**
+     * Whether or not Continous Collision Detection is enabled for this rigid-body.
+     * https://rapier.rs/docs/user_guides/javascript/rigid_bodies#continuous-collision-detection
+     * @default false
+     */
+    ccd?: boolean;
+    /**
+     * Initial position of the RigidBody
+     */
+    position?: Vector3Array;
+    /**
+     * Initial rotation of the RigidBody
+     */
+    rotation?: Vector3Array;
+    /**
+     * Automatically generate colliders based on meshes inside this
+     * rigid body.
+     *
+     * You can change the default setting globally by setting the colliders
+     * prop on the <Physics /> component.
+     *
+     * Setting this to false will disable automatic colliders.
+     */
+    colliders?: RigidBodyAutoCollider | false;
+}
+export declare type SphericalJointParams = [
+    body1Anchor: Vector3Array,
+    body2Anchor: Vector3Array
+];
+export declare type FixedJointParams = [
+    body1Anchor: Vector3Array,
+    body1LocalFrame: Vector3Array,
+    body2Anchor: Vector3Array,
+    body2LocalFrame: Vector3Array
+];
+export declare type PrismaticJointParams = [
+    body1Anchor: Vector3Array,
+    body1LocalFrame: Vector3Array,
+    body2Anchor: Vector3Array,
+    body2LocalFrame: Vector3Array
+];
+export declare type RevoluteJointParams = [
+    body1Anchor: Vector3Array,
+    body1LocalFrame: Vector3Array,
+    body2Anchor: Vector3Array,
+    body2LocalFrame: Vector3Array
+];
+export interface UseImpulseJoint<P> {
+    (body1: MutableRefObject<RapierRigidBody | undefined | null>, body2: MutableRefObject<RapierRigidBody | undefined | null>, params: P): void;
+}

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

@@ -0,0 +1,17 @@
+import { Collider, World } from "@dimforge/rapier3d-compat";
+import { Object3D, Vector3 } from "three";
+import { RapierRigidBody, RigidBodyAutoCollider, RigidBodyShape, RigidBodyTypeString, UseColliderOptions, Vector3Array } from "./types";
+export declare const vectorArrayToObject: (arr: Vector3Array) => {
+    x: number;
+    y: number;
+    z: number;
+};
+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?: {
+    x: number;
+    y: number;
+    z: number;
+}) => Collider;
+export declare const createCollidersFromChildren: (object: Object3D, rigidBody: RapierRigidBody, type: RigidBodyAutoCollider, world: World) => Collider[];
+export declare const scaleVertices: (vertices: ArrayLike<number>, scale: Vector3) => number[];

package/dist/react-three-rapier.cjs.d.ts

@@ -0,0 +1 @@
+export * from "./declarations/src/index";