react-three-rapier-unified 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,1191 @@
+import { ActiveCollisionTypes } from '@dimforge/rapier3d-compat';
+import { CoefficientCombineRule } from '@dimforge/rapier3d-compat';
+import { ColliderHandle } from '@dimforge/rapier3d-compat';
+import { default as default_2 } from 'react';
+import { default as default_3 } from '@dimforge/rapier3d-compat';
+import { Euler } from 'three';
+import { FC } from 'react';
+import { FixedImpulseJoint } from '@dimforge/rapier3d-compat';
+import { ImpulseJoint } from '@dimforge/rapier3d-compat';
+import { InteractionGroups } from '@dimforge/rapier3d-compat';
+import { JSX } from 'react/jsx-runtime';
+import { Matrix4 } from 'three';
+import { Object3D } from 'three';
+import { PrismaticImpulseJoint } from '@dimforge/rapier3d-compat';
+import { Quaternion } from '@react-three/fiber';
+import { Quaternion as Quaternion_2 } from 'three';
+import { Collider as RapierCollider } from '@dimforge/rapier3d-compat';
+import { RigidBody as RapierRigidBody } from '@dimforge/rapier3d-compat';
+import { ReactNode } from 'react';
+import { Ref } from 'react';
+import { RefObject } from 'react';
+import { RevoluteImpulseJoint } from '@dimforge/rapier3d-compat';
+import { RigidBodyHandle } from '@dimforge/rapier3d-compat';
+import { RopeImpulseJoint } from '@dimforge/rapier3d-compat';
+import { Rotation } from '@dimforge/rapier3d-compat';
+import { SolverFlags } from '@dimforge/rapier3d-compat';
+import { SphericalImpulseJoint } from '@dimforge/rapier3d-compat';
+import { SpringImpulseJoint } from '@dimforge/rapier3d-compat';
+import { TempContactManifold } from '@dimforge/rapier3d-compat';
+import { ThreeElements } from '@react-three/fiber';
+import { Vector } from '@dimforge/rapier3d-compat';
+import { Vector3 } from 'three';
+import { Vector3 as Vector3_2 } from '@react-three/fiber';
+import { World } from '@dimforge/rapier3d-compat';
+
+/* Excluded from this release type: AnyCollider */
+
+export declare const applyAttractorForceOnRigidBody: (rigidBody: RapierRigidBody, { object, strength, range, gravitationalConstant, collisionGroups, type }: AttractorState & {
+    object: Object3D;
+}) => void;
+
+export declare const Attractor: FC<AttractorProps>;
+
+export declare const AttractorDebugHelper: (props: AttractorState & {
+    object: RefObject<Object3D>;
+}) => any;
+
+export declare type AttractorGravityType = "static" | "linear" | "newtonian";
+
+export declare interface AttractorProps {
+    /**
+     * The relative position of this attractor
+     */
+    position?: Object3DProps["position"];
+    /**
+     * The strength of the attractor.
+     * Positive values attract, negative values repel.
+     *
+     * @defaultValue 1
+     */
+    strength?: number;
+    /**
+     * The range of the attractor. Will not affect objects outside of this range.
+     *
+     * @defaultValue 10
+     * @min 0
+     */
+    range?: number;
+    /**
+     * The type of gravity to use.
+     * - static: The gravity is constant and does not change over time.
+     * - linear: The gravity is linearly interpolated the closer the object is to the attractor.
+     * - newtonian: The gravity is calculated using the newtonian gravity formula.
+     * @defaultValue "static"
+     */
+    type?: AttractorGravityType;
+    /**
+     * The mass of the attractor. Used when type is `newtonian`.
+     * @defaultValue 6.673e-11
+     */
+    gravitationalConstant?: number;
+    /**
+     * The collision groups that this attractor will apply effects to. If a RigidBody contains one or more colliders that are in one of the mask group, it will be affected by this attractor.
+     * If not specified, the attractor will apply effects to all RigidBodies.
+     */
+    collisionGroups?: InteractionGroups;
+}
+
+export declare interface AttractorState extends Required<Omit<AttractorProps, "position" | "collisionGroups">> {
+    collisionGroups?: InteractionGroups;
+}
+
+export declare type BallArgs = [radius: number];
+
+/**
+ * A ball collider shape
+ * @category Colliders
+ */
+export declare const BallCollider: default_2.ForwardRefExoticComponent<Omit<ColliderOptions<BallArgs>, "args"> & {
+    args: BallArgs;
+    children?: ReactNode;
+} & default_2.RefAttributes<RapierCollider>>;
+
+export declare type BallColliderProps = ColliderOptionsRequiredArgs<BallArgs>;
+
+export declare type Boolean3Tuple = [x: boolean, y: boolean, z: boolean];
+
+export declare type CapsuleArgs = [halfHeight: number, radius: number];
+
+/**
+ * A capsule collider shape
+ * @category Colliders
+ */
+export declare const CapsuleCollider: default_2.ForwardRefExoticComponent<Omit<ColliderOptions<CapsuleArgs>, "args"> & {
+    args: CapsuleArgs;
+    children?: ReactNode;
+} & default_2.RefAttributes<RapierCollider>>;
+
+export declare type CapsuleColliderProps = ColliderOptionsRequiredArgs<CapsuleArgs>;
+
+export { CoefficientCombineRule }
+
+export declare interface ColliderOptions<ColliderArgs extends Array<unknown>> {
+    /**
+     * The optional name passed to THREE's Object3D
+     */
+    name?: string;
+    /**
+     * The shape of your collider
+     */
+    shape?: ColliderShape;
+    /**
+     * Arguments to pass to the collider
+     */
+    args?: ColliderArgs;
+    /**
+     * Principal angular inertia of this rigid body
+     */
+    principalAngularInertia?: Vector3Tuple;
+    /**
+     * 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?: ThreeElements["object3D"]["position"];
+    /**
+     * The rotation of this collider relative to the rigid body
+     */
+    rotation?: ThreeElements["object3D"]["rotation"];
+    /**
+     * The rotation, as a Quaternion, of this collider relative to the rigid body
+     */
+    quaternion?: ThreeElements["object3D"]["quaternion"];
+    /**
+     * The scale of this collider relative to the rigid body
+     */
+    scale?: ThreeElements["object3D"]["scale"];
+    /**
+     * Callback when this collider collideas with another collider.
+     */
+    onCollisionEnter?: CollisionEnterHandler;
+    /**
+     * Callback when this collider stops colliding with another collider.
+     */
+    onCollisionExit?: CollisionExitHandler;
+    /**
+     * Callback when this collider, or another collider starts intersecting, and at least one of them is a `sensor`.
+     */
+    onIntersectionEnter?: IntersectionEnterHandler;
+    /**
+     * Callback when this, or another collider stops intersecting, and at least one of them is a `sensor`.
+     */
+    onIntersectionExit?: IntersectionExitHandler;
+    /**
+     * Callback when this, or another collider triggers a contact force event
+     */
+    onContactForce?: ContactForceHandler;
+    /**
+     * The bit mask configuring the groups and mask for collision handling.
+     */
+    collisionGroups?: InteractionGroups;
+    /**
+     * The bit mask configuring the groups and mask for solver handling.
+     */
+    solverGroups?: InteractionGroups;
+    /**
+     * The collision types active for this collider.
+     *
+     * Use `ActiveCollisionTypes` to specify which collision types should be active for this collider.
+     *
+     * @see https://rapier.rs/javascript3d/classes/Collider.html#setActiveCollisionTypes
+     * @see https://rapier.rs/javascript3d/enums/ActiveCollisionTypes.html
+     */
+    activeCollisionTypes?: ActiveCollisionTypes;
+    /**
+     * Sets the uniform density of this collider.
+     * If this is set, other mass-properties like the angular inertia tensor are computed
+     * automatically from the collider's shape.
+     * Cannot be used at the same time as the mass or massProperties values.
+     * More info https://rapier.rs/docs/user_guides/javascript/colliders#mass-properties
+     */
+    density?: number;
+    /**
+     * The mass of this collider.
+     * Generally, it's not recommended to adjust the mass properties as it could lead to
+     * unexpected behaviors.
+     * Cannot be used at the same time as the density or massProperties values.
+     * More info https://rapier.rs/docs/user_guides/javascript/colliders#mass-properties
+     */
+    mass?: number;
+    /**
+     * The mass properties of this rigid body.
+     * Cannot be used at the same time as the density or mass values.
+     */
+    massProperties?: {
+        mass: number;
+        centerOfMass: Vector;
+        principalAngularInertia: Vector;
+        angularInertiaLocalFrame: Rotation;
+    };
+    /**
+     * The contact skin of the collider.
+     *
+     * The contact skin acts as if the collider was enlarged with a skin of width contactSkin around it, keeping objects further apart when colliding.
+     *
+     * A non-zero contact skin can increase performance, and in some cases, stability.
+     * However it creates a small gap between colliding object (equal to the sum of their skin).
+     * If the skin is sufficiently small, this might not be visually significant or can be hidden by the rendering assets.
+     *
+     * @defaultValue 0
+     */
+    contactSkin?: number;
+    /**
+     * Sets whether or not this collider is a sensor.
+     */
+    sensor?: boolean;
+}
+
+export declare type ColliderOptionsRequiredArgs<T extends unknown[]> = Omit<ColliderOptions<T>, "args"> & {
+    args: T;
+    children?: ReactNode;
+};
+
+export declare interface ColliderProps extends ColliderOptions<any> {
+    children?: ReactNode;
+    ref?: Ref<RapierCollider>;
+}
+
+export declare type ColliderShape = "cuboid" | "trimesh" | "ball" | "capsule" | "convexHull" | "heightfield" | "polyline" | "roundCuboid" | "cylinder" | "roundCylinder" | "cone" | "roundCone" | "convexMesh" | "roundConvexHull" | "roundConvexMesh";
+
+declare interface ColliderState {
+    collider: RapierCollider;
+    object: Object3D;
+    /**
+     * The parent of which this collider needs to base its
+     * world position on, can be empty
+     */
+    worldParent?: Object3D;
+}
+
+declare type ColliderStateMap = Map<RapierCollider["handle"], ColliderState>;
+
+export declare type CollisionEnterHandler = (payload: CollisionEnterPayload) => void;
+
+export declare type CollisionEnterPayload = CollisionPayload & {
+    manifold: TempContactManifold;
+    flipped: boolean;
+};
+
+export declare type CollisionExitHandler = (payload: CollisionExitPayload) => void;
+
+export declare type CollisionExitPayload = CollisionPayload;
+
+export declare type CollisionPayload = {
+    /** the object firing the event */
+    target: CollisionTarget;
+    /** the other object involved in the event */
+    other: CollisionTarget;
+    /** deprecated use `payload.other.rigidBody` instead */
+    rigidBody?: RapierRigidBody;
+    /** deprecated use `payload.other.collider` instead */
+    collider: RapierCollider;
+    /** deprecated use `payload.other.rigidBodyObject` instead */
+    rigidBodyObject?: Object3D;
+    /** deprecated use `payload.other.colliderObject` instead */
+    colliderObject?: Object3D;
+};
+
+export declare type CollisionTarget = {
+    rigidBody?: RapierRigidBody;
+    collider: RapierCollider;
+    rigidBodyObject?: Object3D;
+    colliderObject?: Object3D;
+};
+
+export declare type ConeArgs = [halfHeight: number, radius: number];
+
+/**
+ * A cone collider shape
+ * @category Colliders
+ */
+export declare const ConeCollider: default_2.ForwardRefExoticComponent<Omit<ColliderOptions<ConeArgs>, "args"> & {
+    args: ConeArgs;
+    children?: ReactNode;
+} & default_2.RefAttributes<RapierCollider>>;
+
+export declare type ConeColliderProps = ColliderOptionsRequiredArgs<ConeArgs>;
+
+export declare type ContactForceHandler = (payload: ContactForcePayload) => void;
+
+export declare type ContactForcePayload = CollisionPayload & {
+    totalForce: Vector;
+    totalForceMagnitude: number;
+    maxForceDirection: Vector;
+    maxForceMagnitude: number;
+};
+
+export declare type ConvexHullArgs = [vertices: ArrayLike<number>];
+
+/**
+ * A convex hull collider shape
+ * @category Colliders
+ */
+export declare const ConvexHullCollider: default_2.ForwardRefExoticComponent<Omit<ColliderOptions<ConvexHullArgs>, "args"> & {
+    args: ConvexHullArgs;
+    children?: ReactNode;
+} & default_2.RefAttributes<RapierCollider>>;
+
+export declare type ConvexHullColliderProps = ColliderOptionsRequiredArgs<ConvexHullArgs>;
+
+export declare type ConvexMeshArgs = [
+vertices: ArrayLike<number>,
+indices: ArrayLike<number>
+];
+
+export declare type CuboidArgs = [
+halfWidth: number,
+halfHeight: number,
+halfDepth: number
+];
+
+/**
+ * A cuboid collider shape
+ * @category Colliders
+ */
+export declare const CuboidCollider: default_2.ForwardRefExoticComponent<Omit<ColliderOptions<CuboidArgs>, "args"> & {
+    args: CuboidArgs;
+    children?: ReactNode;
+} & default_2.RefAttributes<RapierCollider>>;
+
+export declare type CuboidColliderProps = ColliderOptionsRequiredArgs<CuboidArgs>;
+
+export declare type CylinderArgs = [halfHeight: number, radius: number];
+
+/**
+ * A cylinder collider shape
+ * @category Colliders
+ */
+export declare const CylinderCollider: default_2.ForwardRefExoticComponent<Omit<ColliderOptions<CylinderArgs>, "args"> & {
+    args: CylinderArgs;
+    children?: ReactNode;
+} & default_2.RefAttributes<RapierCollider>>;
+
+export declare type CylinderColliderProps = ColliderOptionsRequiredArgs<CylinderArgs>;
+
+/**
+ * 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;
+
+declare type EventMap = Map<ColliderHandle | RigidBodyHandle, EventMapValue>;
+
+declare type EventMapValue = {
+    onSleep?(): void;
+    onWake?(): void;
+    onCollisionEnter?: CollisionEnterHandler;
+    onCollisionExit?: CollisionExitHandler;
+    onIntersectionEnter?: IntersectionEnterHandler;
+    onIntersectionExit?: IntersectionExitHandler;
+    onContactForce?: ContactForceHandler;
+};
+
+export declare type FilterContactPairCallback = (collider1: ColliderHandle, collider2: ColliderHandle, body1: RigidBodyHandle, body2: RigidBodyHandle) => SolverFlags | null;
+
+declare type FilterContactPairCallbackSet = Set<{
+    current: FilterContactPairCallback;
+}>;
+
+export declare type FilterIntersectionPairCallback = (collider1: ColliderHandle, collider2: ColliderHandle, body1: RigidBodyHandle, body2: RigidBodyHandle) => boolean;
+
+declare type FilterIntersectionPairCallbackSet = Set<{
+    current: FilterIntersectionPairCallback;
+}>;
+
+export declare type FixedJointParams = [
+body1Anchor: Vector3_2,
+body1LocalFrame: Quaternion,
+body2Anchor: Vector3_2,
+body2LocalFrame: Quaternion
+];
+
+export declare type HeightfieldArgs = [
+width: number,
+height: number,
+heights: number[],
+scale: {
+    x: number;
+    y: number;
+    z: number;
+}
+];
+
+/**
+ * A heightfield collider shape
+ * @category Colliders
+ */
+export declare const HeightfieldCollider: default_2.ForwardRefExoticComponent<Omit<ColliderOptions<HeightfieldArgs>, "args"> & {
+    args: HeightfieldArgs;
+    children?: ReactNode;
+} & default_2.RefAttributes<RapierCollider>>;
+
+export declare type HeightfieldColliderProps = ColliderOptionsRequiredArgs<HeightfieldArgs>;
+
+export declare const InstancedRigidBodies: default_2.MemoExoticComponent<({ ref, ...props }: InstancedRigidBodiesProps) => JSX.Element>;
+
+export declare interface InstancedRigidBodiesProps extends Omit<RigidBodyProps, "ref"> {
+    instances: InstancedRigidBodyProps[];
+    colliderNodes?: ReactNode[];
+    children: ReactNode;
+    ref?: default_2.Ref<(RapierRigidBody | null)[] | null>;
+}
+
+export declare type InstancedRigidBodyProps = RigidBodyProps & {
+    key: string | number;
+};
+
+/**
+ * Calculates an InteractionGroup bitmask for use in the `collisionGroups` or `solverGroups`
+ * properties of RigidBody or Collider components. The first argument represents a list of
+ * groups the entity is in (expressed as numbers from 0 to 15). The second argument is a list
+ * of groups that will be filtered against. When it is omitted, all groups are filtered against.
+ *
+ * @example
+ * A RigidBody that is member of group 0 and will collide with everything from groups 0 and 1:
+ *
+ * ```tsx
+ * <RigidBody collisionGroups={interactionGroups([0], [0, 1])} />
+ * ```
+ *
+ * A RigidBody that is member of groups 0 and 1 and will collide with everything else:
+ *
+ * ```tsx
+ * <RigidBody collisionGroups={interactionGroups([0, 1])} />
+ * ```
+ *
+ * A RigidBody that is member of groups 0 and 1 and will not collide with anything:
+ *
+ * ```tsx
+ * <RigidBody collisionGroups={interactionGroups([0, 1], [])} />
+ * ```
+ *
+ * Please note that Rapier needs interaction filters to evaluate to true between _both_ colliding
+ * entities for collision events to trigger.
+ *
+ * @param memberships Groups the collider is a member of. (Values can range from 0 to 15.)
+ * @param filters Groups the interaction group should filter against. (Values can range from 0 to 15.)
+ * @returns An InteractionGroup bitmask.
+ */
+export declare const interactionGroups: (memberships: number | number[], filters?: number | number[]) => InteractionGroups;
+
+export declare type IntersectionEnterHandler = (payload: IntersectionEnterPayload) => void;
+
+export declare type IntersectionEnterPayload = CollisionPayload;
+
+export declare type IntersectionExitHandler = (payload: IntersectionExitPayload) => void;
+
+export declare type IntersectionExitPayload = CollisionPayload;
+
+/**
+ * A mesh collider is a collider that is automatically generated from the geometry of the children.
+ * @category Colliders
+ */
+export declare const MeshCollider: default_2.MemoExoticComponent<(props: MeshColliderProps) => JSX.Element>;
+
+export declare interface MeshColliderProps {
+    children: ReactNode;
+    type: RigidBodyAutoCollider;
+}
+
+declare type Object3DProps = ThreeElements["object3D"];
+
+/**
+ * The main physics component used to create a physics world.
+ * @category Components
+ */
+export declare const Physics: FC<PhysicsProps>;
+
+export declare interface PhysicsProps {
+    children: ReactNode;
+    /**
+     * Set the gravity of the physics world
+     * @defaultValue [0, -9.81, 0]
+     */
+    gravity?: Vector3Tuple;
+    /**
+     * Amount of penetration the engine wont attempt to correct
+     * @defaultValue 0.001
+     */
+    allowedLinearError?: number;
+    /**
+     * The number of solver iterations run by the constraints solver for calculating forces.
+     * The greater this value is, the most rigid and realistic the physics simulation will be.
+     * However a greater number of iterations is more computationally intensive.
+     *
+     * @defaultValue 4
+     */
+    numSolverIterations?: number;
+    /**
+     * Number of internal Project Gauss Seidel (PGS) iterations run at each solver iteration.
+     * Increasing this parameter will improve stability of the simulation. It will have a lesser effect than
+     * increasing `numSolverIterations` but is also less computationally expensive.
+     *
+     * @defaultValue 1
+     */
+    numInternalPgsIterations?: number;
+    /**
+     * The maximal distance separating two objects that will generate predictive contacts
+     *
+     * @defaultValue 0.002
+     *
+     */
+    predictionDistance?: number;
+    /**
+     * Minimum number of dynamic bodies in each active island
+     *
+     * @defaultValue 128
+     */
+    minIslandSize?: number;
+    /**
+     * Maximum number of substeps performed by the solver
+     *
+     * @defaultValue 1
+     */
+    maxCcdSubsteps?: number;
+    /**
+     * Directly affects the `erp` (Error Reduction Parameter) which is the proportion (0 to 1) of the positional error to be corrected at each time step.
+     * The higher this value is, the more the physics engine will try to correct errors.
+     *
+     * This prop is currently undocumented in the Rapier documentation.
+     *
+     * @see https://github.com/dimforge/rapier/pull/651 where this change was made to Rapier
+     * @defaultValue 30
+     */
+    contactNaturalFrequency?: number;
+    /**
+     * The approximate size of most dynamic objects in the scene.
+     *
+     * This value is used internally to estimate some length-based tolerance.
+     * This value can be understood as the number of units-per-meter in your physical world compared to a human-sized world in meter.
+     *
+     * @defaultValue 1
+     */
+    lengthUnit?: number;
+    /**
+     * 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;
+    /**
+     * Set the timestep for the simulation.
+     * Setting this to a number (eg. 1/60) will run the
+     * simulation at that framerate. Alternatively, you can set this to
+     * "vary", which will cause the simulation to always synchronize with
+     * the current frame delta times.
+     *
+     * @defaultValue 1/60
+     */
+    timeStep?: number | "vary";
+    /**
+     * Pause the physics simulation
+     *
+     * @defaultValue false
+     */
+    paused?: boolean;
+    /**
+     * Interpolate the world transform using the frame delta times.
+     * Has no effect if timeStep is set to "vary".
+     *
+     * @defaultValue true
+     **/
+    interpolate?: boolean;
+    /**
+     * The update priority at which the physics simulation should run.
+     * Only used when `updateLoop` is set to "follow".
+     *
+     * @see https://docs.pmnd.rs/react-three-fiber/api/hooks#taking-over-the-render-loop
+     * @defaultValue undefined
+     */
+    updatePriority?: number;
+    /**
+     * Set the update loop strategy for the physics world.
+     *
+     * If set to "follow", the physics world will be stepped
+     * in a `useFrame` callback, managed by @react-three/fiber.
+     * You can use `updatePriority` prop to manage the scheduling.
+     *
+     * If set to "independent", the physics world will be stepped
+     * in a separate loop, not tied to the render loop.
+     * This is useful when using the "demand" `frameloop` strategy for the
+     * @react-three/fiber `<Canvas />`.
+     *
+     * @see https://docs.pmnd.rs/react-three-fiber/advanced/scaling-performance#on-demand-rendering
+     * @defaultValue "follow"
+     */
+    updateLoop?: "follow" | "independent";
+    /**
+     * Enable debug rendering of the physics world.
+     * @defaultValue false
+     */
+    debug?: boolean;
+}
+
+export declare type PolylineArgs = [vertices: Float32Array, indices: Uint32Array];
+
+export declare type PrismaticJointParams = [
+body1Anchor: Vector3_2,
+body2Anchor: Vector3_2,
+axis: Vector3_2,
+limits?: [min: number, max: number]
+];
+
+/**
+ * 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_2;
+
+export { RapierCollider }
+
+export declare interface RapierContext {
+    /* Excluded from this release type: rigidBodyStates */
+    /* Excluded from this release type: colliderStates */
+    /* Excluded from this release type: rigidBodyEvents */
+    /* Excluded from this release type: colliderEvents */
+    /* Excluded from this release type: physicsOptions */
+    /* Excluded from this release type: beforeStepCallbacks */
+    /* Excluded from this release type: afterStepCallbacks */
+    /* Excluded from this release type: filterContactPairHooks */
+    /* Excluded from this release type: filterIntersectionPairHooks */
+    /**
+     * Direct access to the Rapier instance
+     */
+    rapier: typeof default_3;
+    /**
+     * The Rapier physics world
+     */
+    world: World;
+    /**
+     * Can be used to overwrite the current World. Useful when working with snapshots.
+     *
+     * @example
+     * ```tsx
+     * import { useRapier } from '@react-three/rapier';
+     *
+     * const SnapshottingComponent = () => {
+     *   const { world, setWorld, rapier } = useRapier();
+     *   const worldSnapshot = useRef<Uint8Array>();
+     *
+     *   // Store the snapshot
+     *   const takeSnapshot = () => {
+     *     const snapshot = world.takeSnapshot()
+     *     worldSnapshot.current = snapshot
+     *   }
+     *
+     *   // Create a new World from the snapshot, and replace the current one
+     *   const restoreSnapshot = () => {
+     *     setWorld(rapier.World.restoreSnapshot(worldSnapshot.current))
+     *   }
+     *
+     *   return <>
+     *     <Rigidbody>...</RigidBody>
+     *     <Rigidbody>...</RigidBody>
+     *     <Rigidbody>...</RigidBody>
+     *     <Rigidbody>...</RigidBody>
+     *     <Rigidbody>...</RigidBody>
+     *   </>
+     * }
+     * ```
+     */
+    setWorld: (world: World) => void;
+    /**
+     * If the physics simulation is paused
+     */
+    isPaused: boolean;
+    /**
+     * Step the physics world one step
+     *
+     * @param deltaTime The delta time to step the world with
+     *
+     * @example
+     * ```
+     * step(1/60)
+     * ```
+     */
+    step: (deltaTime: number) => void;
+    /**
+     * Is debug mode enabled
+     */
+    isDebug: boolean;
+}
+
+export { RapierRigidBody }
+
+export declare type RefGetter<T> = RefObject<() => T | undefined>;
+
+export declare type RevoluteJointParams = [
+body1Anchor: Vector3_2,
+body2Anchor: Vector3_2,
+axis: Vector3_2,
+limits?: [min: number, max: number]
+];
+
+/**
+ * A rigid body is a physical object that can be simulated by the physics engine.
+ * @category Components
+ */
+export declare const RigidBody: default_2.MemoExoticComponent<(props: RigidBodyProps) => JSX.Element>;
+
+export declare type RigidBodyAutoCollider = "ball" | "cuboid" | "hull" | "trimesh" | false;
+
+export declare interface RigidBodyOptions extends Omit<ColliderProps, "ref"> {
+    /**
+     * Specify the type of this rigid body
+     */
+    type?: RigidBodyTypeString;
+    /**
+     * Whether or not this body can sleep.
+     * @defaultValue true
+     */
+    canSleep?: boolean;
+    /** The linear damping coefficient of this rigid-body.*/
+    linearDamping?: number;
+    /** The angular damping coefficient of this rigid-body.*/
+    angularDamping?: number;
+    /**
+     * The initial linear velocity of this body.
+     * @defaultValue [0,0,0]
+     */
+    linearVelocity?: Vector3Tuple;
+    /**
+     * The initial angular velocity of this body.
+     * @defaultValue [0,0,0]
+     */
+    angularVelocity?: Vector3Tuple;
+    /**
+     * The scaling factor applied to the gravity affecting the rigid-body.
+     * @defaultValue 1.0
+     */
+    gravityScale?: number;
+    /**
+     * The dominance group of this RigidBody. If a rigid body has a higher domiance group,
+     * on collision it will be immune to forces originating from the other bodies.
+     * https://rapier.rs/docs/user_guides/javascript/rigid_bodies#dominance
+     * Default: 0
+     */
+    dominanceGroup?: 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
+     * @defaultValue false
+     */
+    ccd?: boolean;
+    /**
+     * The maximum prediction distance Soft Continuous Collision-Detection.
+     *
+     * When set to 0, soft-CCD is disabled.
+     *
+     * Soft-CCD helps prevent tunneling especially of slow-but-thin to moderately fast objects.
+     * The soft CCD prediction distance indicates how far in the object’s path the CCD algorithm is allowed to inspect.
+     * Large values can impact performance badly by increasing the work needed from the broad-phase.
+     *
+     * It is a generally cheaper variant of regular CCD since it relies on predictive constraints instead of shape-cast and substeps.
+     *
+     * @defaultValue 0
+     */
+    softCcdPrediction?: number;
+    /**
+     * Initial position of the RigidBody
+     */
+    position?: ThreeElements["object3D"]["position"];
+    /**
+     * Initial rotation of the RigidBody
+     */
+    rotation?: ThreeElements["object3D"]["rotation"];
+    /**
+     * 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;
+    /**
+     * Set the friction of auto-generated colliders.
+     * This does not affect any non-automatic child collider-components.
+     */
+    friction?: number;
+    /**
+     * Set the restitution (bounciness) of auto-generated colliders.
+     * This does not affect any non-automatic child collider-components.
+     */
+    restitution?: number;
+    /**
+     * Sets the number of additional solver iterations that will be run for this
+     * rigid-body and everything that interacts with it directly or indirectly
+     * through contacts or joints.
+     *
+     * Compared to increasing the global `World.numSolverIteration`, setting this
+     * value lets you increase accuracy on only a subset of the scene, resulting in reduced
+     * performance loss.
+     */
+    additionalSolverIterations?: number;
+    /**
+     * The default collision groups bitmask for all colliders in this rigid body.
+     * Can be customized per-collider.
+     */
+    collisionGroups?: InteractionGroups;
+    /**
+     * The default solver groups bitmask for all colliders in this rigid body.
+     * Can be customized per-collider.
+     */
+    solverGroups?: InteractionGroups;
+    /**
+     * The default active collision types for all colliders in this rigid body.
+     * Can be customized per-collider.
+     *
+     * Use `ActiveCollisionTypes` to specify which collision types should be active for this collider.
+     *
+     * @see https://rapier.rs/javascript3d/classes/Collider.html#setActiveCollisionTypes
+     * @see https://rapier.rs/javascript3d/enums/ActiveCollisionTypes.html
+     */
+    activeCollisionTypes?: ActiveCollisionTypes;
+    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?: Boolean3Tuple;
+    /**
+     * Allow translation of this rigid-body only along specific axes.
+     */
+    enabledTranslations?: Boolean3Tuple;
+    /**
+     * Passed down to the object3d representing this collider.
+     */
+    userData?: ThreeElements["object3D"]["userData"];
+    /**
+     * Include invisible objects on the collider creation estimation.
+     */
+    includeInvisible?: boolean;
+    /* Excluded from this release type: transformState */
+}
+
+export declare interface RigidBodyProps extends RigidBodyOptions {
+    children?: ReactNode;
+    ref?: Ref<RapierRigidBody>;
+}
+
+declare interface RigidBodyState {
+    meshType: "instancedMesh" | "mesh";
+    rigidBody: RapierRigidBody;
+    object: Object3D;
+    invertedWorldMatrix: Matrix4;
+    setMatrix: (matrix: Matrix4) => void;
+    getMatrix: (matrix: Matrix4) => Matrix4;
+    /**
+     * Required for instanced rigid bodies.
+     */
+    scale: Vector3;
+    isSleeping: boolean;
+}
+
+declare type RigidBodyStateMap = Map<RapierRigidBody["handle"], RigidBodyState>;
+
+export declare type RigidBodyTypeString = "fixed" | "dynamic" | "kinematicPosition" | "kinematicVelocity";
+
+export declare type RopeJointParams = [
+body1Anchor: Vector3_2,
+body2Anchor: Vector3_2,
+length: number
+];
+
+export declare type RoundConeArgs = [
+halfHeight: number,
+radius: number,
+borderRadius: number
+];
+
+/**
+ * A round cylinder collider shape
+ * @category Colliders
+ */
+export declare const RoundConeCollider: default_2.ForwardRefExoticComponent<Omit<ColliderOptions<RoundConeArgs>, "args"> & {
+    args: RoundConeArgs;
+    children?: ReactNode;
+} & default_2.RefAttributes<RapierCollider>>;
+
+export declare type RoundConeColliderProps = ColliderOptionsRequiredArgs<RoundConeArgs>;
+
+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 RoundCuboidArgs = [
+halfWidth: number,
+halfHeight: number,
+halfDepth: number,
+borderRadius: number
+];
+
+/**
+ * A round cuboid collider shape
+ * @category Colliders
+ */
+export declare const RoundCuboidCollider: default_2.ForwardRefExoticComponent<Omit<ColliderOptions<RoundCuboidArgs>, "args"> & {
+    args: RoundCuboidArgs;
+    children?: ReactNode;
+} & default_2.RefAttributes<RapierCollider>>;
+
+export declare type RoundCuboidColliderProps = ColliderOptionsRequiredArgs<RoundCuboidArgs>;
+
+export declare type RoundCylinderArgs = [
+halfHeight: number,
+radius: number,
+borderRadius: number
+];
+
+/**
+ * A round cylinder collider shape
+ * @category Colliders
+ */
+export declare const RoundCylinderCollider: default_2.ForwardRefExoticComponent<Omit<ColliderOptions<RoundConeArgs>, "args"> & {
+    args: RoundConeArgs;
+    children?: ReactNode;
+} & default_2.RefAttributes<RapierCollider>>;
+
+export declare type RoundCylinderColliderProps = ColliderOptionsRequiredArgs<RoundCylinderArgs>;
+
+export declare type SphericalJointParams = [body1Anchor: Vector3_2, body2Anchor: Vector3_2];
+
+export declare type SpringJointParams = [
+body1Anchor: Vector3_2,
+body2Anchor: Vector3_2,
+restLength: number,
+stiffness: number,
+damping: number
+];
+
+export declare type TrimeshArgs = [
+vertices: ArrayLike<number>,
+indices: ArrayLike<number>
+];
+
+/**
+ * A trimesh collider shape
+ * @category Colliders
+ */
+export declare const TrimeshCollider: default_2.ForwardRefExoticComponent<Omit<ColliderOptions<TrimeshArgs>, "args"> & {
+    args: TrimeshArgs;
+    children?: ReactNode;
+} & default_2.RefAttributes<RapierCollider>>;
+
+export declare type TrimeshColliderProps = ColliderOptionsRequiredArgs<TrimeshArgs>;
+
+/**
+ * Registers a callback to be called after the physics step
+ * @category Hooks
+ */
+export declare const useAfterPhysicsStep: (callback: WorldStepCallback) => void;
+
+/**
+ * Registers a callback to be called before the physics step
+ * @category Hooks
+ */
+export declare const useBeforePhysicsStep: (callback: WorldStepCallback) => void;
+
+export declare type UseBodyOptions = Omit<RigidBodyOptions, "shape">;
+
+/**
+ * Registers a callback to filter contact pairs.
+ *
+ * The callback determines if contact computation should happen between two colliders,
+ * and how the constraints solver should behave for these contacts.
+ *
+ * This will only be executed if at least one of the involved colliders contains the
+ * `ActiveHooks.FILTER_CONTACT_PAIR` flag in its active hooks.
+ *
+ * @param callback - Function that returns:
+ *   - `SolverFlags.COMPUTE_IMPULSE` (1) - Process the collision normally (compute impulses and resolve penetration)
+ *   - `SolverFlags.EMPTY` (0) - Skip computing impulses for this collision pair (colliders pass through each other)
+ *   - `null` - Skip this hook; let the next registered hook decide, or use Rapier's default behavior if no hook handles it
+ *
+ * When multiple hooks are registered, they are called in order until one returns a non-null value.
+ * That value is then passed to Rapier's physics engine.
+ *
+ * @category Hooks
+ *
+ * @example
+ * ```tsx
+ * import { useFilterContactPair } from '@react-three/rapier';
+ * import { SolverFlags } from '@dimforge/rapier3d-compat';
+ *
+ * useFilterContactPair((collider1, collider2, body1, body2) => {
+ *   // Only process collisions for specific bodies
+ *   if (body1 === myBodyHandle) {
+ *     return SolverFlags.COMPUTE_IMPULSE;
+ *   }
+ *   // Let other hooks or default behavior handle it
+ *   return null;
+ * });
+ * ```
+ */
+export declare const useFilterContactPair: (callback: (collider1: number, collider2: number, body1: number, body2: number) => number | null) => void;
+
+/**
+ * Registers a callback to filter intersection pairs.
+ *
+ * The callback determines if intersection computation should happen between two colliders
+ * (where at least one is a sensor).
+ *
+ * This will only be executed if at least one of the involved colliders contains the
+ * `ActiveHooks.FILTER_INTERSECTION_PAIR` flag in its active hooks.
+ *
+ * @param callback - Function that returns:
+ *   - `true` - Allow the intersection to be detected (trigger intersection events)
+ *   - `false` - Block the intersection (no intersection events will fire)
+ *
+ * When multiple hooks are registered, the **first hook that returns `false` blocks** the intersection.
+ * If all hooks return `true`, the intersection is allowed.
+ *
+ * @category Hooks
+ *
+ * @example
+ * ```tsx
+ * import { useFilterIntersectionPair } from '@react-three/rapier';
+ *
+ * useFilterIntersectionPair((collider1, collider2, body1, body2) => {
+ *   // Block intersections for specific body pairs
+ *   if (body1 === myBodyHandle && body2 === otherBodyHandle) {
+ *     return false;
+ *   }
+ *   // Allow all other intersections
+ *   return true;
+ * });
+ * ```
+ */
+export declare const useFilterIntersectionPair: (callback: (collider1: number, collider2: number, body1: number, body2: number) => boolean) => 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.
+ *
+ * @category Hooks - Joints
+ */
+export declare const useFixedJoint: UseImpulseJoint<FixedJointParams, FixedImpulseJoint>;
+
+export declare interface UseImpulseJoint<JointParams, JointType extends ImpulseJoint> {
+    (body1: RefObject<RapierRigidBody>, body2: RefObject<RapierRigidBody>, params: JointParams): RefObject<JointType | undefined>;
+}
+
+/* Excluded from this release type: useImpulseJoint */
+
+/**
+ * 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, PrismaticImpulseJoint>;
+
+/**
+ * Exposes the Rapier context, and world
+ * @category Hooks
+ */
+export declare const useRapier: () => RapierContext;
+
+/**
+ * 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, RevoluteImpulseJoint>;
+
+/**
+ * The rope joint limits the max distance between two bodies.
+ * @category Hooks - Joints
+ */
+export declare const useRopeJoint: UseImpulseJoint<RopeJointParams, RopeImpulseJoint>;
+
+/**
+ * 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, SphericalImpulseJoint>;
+
+/**
+ * The spring joint applies a force proportional to the distance between two objects.
+ * @category Hooks - Joints
+ */
+export declare const useSpringJoint: UseImpulseJoint<SpringJointParams, SpringImpulseJoint>;
+
+/**
+ * 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;
+
+export declare type Vector3Object = {
+    x: number;
+    y: number;
+    z: number;
+};
+
+export declare type Vector3Tuple = [x: number, y: number, z: number];
+
+export declare type Vector4Tuple = [x: number, y: number, z: number, w: number];
+
+export declare type WorldStepCallback = (world: World) => void;
+
+declare type WorldStepCallbackSet = Set<{
+    current: WorldStepCallback;
+}>;
+
+export { }