@react-three/rapier 0.8.2 → 0.10.0

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

@@ -0,0 +1,51 @@
+import { InteractionGroups, RigidBody } from "@dimforge/rapier3d-compat";
+import { FC } from "react";
+import { Object3D } from "three";
+import { Object3DProps } from "@react-three/fiber";
+declare type GravityType = "static" | "linear" | "newtonian";
+interface AttractorProps {
+    /**
+     * The relative position of this attractor
+     */
+    position?: Object3DProps["position"];
+    /**
+     * The strength of the attractor.
+     * Positive values attract, negative values repel.
+     *
+     * @default 1
+     */
+    strength?: number;
+    /**
+     * The range of the attractor. Will not affect objects outside of this range.
+     *
+     * @default 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.
+     * @default "static"
+     */
+    type?: GravityType;
+    /**
+     * The mass of the attractor. Used when type is `newtonian`.
+     * @default 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 interface AttractorState extends Required<Omit<AttractorProps, "position" | "collisionGroups">> {
+    object: Object3D;
+    collisionGroups?: InteractionGroups;
+}
+export declare type AttractorStateMap = Map<Object3D["uuid"], AttractorState>;
+export declare const applyAttractorForceOnRigidBody: (rigidBody: RigidBody, { object, strength, range, gravitationalConstant, collisionGroups, type }: AttractorState) => void;
+export declare const Attractor: FC<AttractorProps>;
+export {};

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

@@ -4,5 +4,8 @@ interface MeshColliderProps {
     children: ReactNode;
     type: RigidBodyAutoCollider;
 }
-export declare const MeshCollider: (props: MeshColliderProps) => JSX.Element;
+export declare const MeshCollider: {
+    (props: MeshColliderProps): JSX.Element;
+    displayName: string;
+};
 export {};

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

@@ -1,8 +1,9 @@
-import React, { FC, ReactNode } from "react";
 import type Rapier from "@dimforge/rapier3d-compat";
-import { CollisionEnterHandler, CollisionExitHandler, IntersectionEnterHandler, IntersectionExitHandler, RigidBodyAutoCollider, Vector3Array, WorldApi } from "./types";
 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, WorldApi } from "./types";
+import { AttractorStateMap } from "./Attractor";
 export interface RigidBodyState {
     rigidBody: RigidBody;
     object: Object3D;
@@ -21,32 +22,61 @@ export interface ColliderState {
     object: Object3D;
     /**
      * The parent of which this collider needs to base its
-     * world position on
+     * world position on, can be empty
      */
-    worldParent: Object3D;
+    worldParent?: Object3D;
 }
 export declare type ColliderStateMap = Map<Collider["handle"], ColliderState>;
 export interface RapierContext {
     rapier: typeof Rapier;
     world: WorldApi;
+    /**
+     * @internal
+     */
     rigidBodyStates: RigidBodyStateMap;
+    /**
+     * @internal
+     */
     colliderStates: ColliderStateMap;
+    /**
+     * @internal
+     */
     rigidBodyEvents: EventMap;
+    /**
+     * @internal
+     */
     colliderEvents: EventMap;
+    /**
+     * @internal
+     */
+    attractorStates: AttractorStateMap;
     physicsOptions: {
         colliders: RigidBodyAutoCollider;
     };
     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;
 }
 export declare const RapierContext: React.Context<RapierContext | undefined>;
-export declare type EventMap = Map<ColliderHandle | RigidBodyHandle, {
+export declare type EventMapValue = {
     onSleep?(): void;
     onWake?(): void;
     onCollisionEnter?: CollisionEnterHandler;
     onCollisionExit?: CollisionExitHandler;
     onIntersectionEnter?: IntersectionEnterHandler;
     onIntersectionExit?: IntersectionExitHandler;
-}>;
+    onContactForce?: ContactForceHandler;
+};
+export declare type EventMap = Map<ColliderHandle | RigidBodyHandle, EventMapValue>;
 interface RapierWorldProps {
     children: ReactNode;
     /**
@@ -82,6 +112,13 @@ interface RapierWorldProps {
      * @defaultValue undefined
      */
     updatePriority?: number;
+    /**
+     * Interpolate the world transform using the frame delta times.
+     * Has no effect if timeStep is set to "vary".
+     *
+     * @default true
+     **/
+    interpolate?: boolean;
 }
 export declare const Physics: FC<RapierWorldProps>;
 export {};

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

@@ -9,5 +9,6 @@ export { MeshCollider } from "./MeshCollider";
 export { Debug } from "./Debug";
 export { InstancedRigidBodies } from "./InstancedRigidBodies";
 export * from "./AnyCollider";
+export { Attractor } from "./Attractor";
 export * from "./hooks";
-export * from "./bitmasks";
+export * from "./interaction-groups";

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

@@ -1,12 +1,12 @@
 import { MutableRefObject } from "react";
 import { CoefficientCombineRule, Collider as RapierCollider, InteractionGroups, RigidBody as RapierRigidBody, TempContactManifold } from "@dimforge/rapier3d-compat";
-import { createColliderApi, createJointApi, createRigidBodyApi, createWorldApi } from "./api";
-import { ColliderProps } from ".";
+import { Rotation, Vector } from "@dimforge/rapier3d-compat/math";
 import { Object3DProps } from "@react-three/fiber";
 import { Object3D } from "three";
+import { ColliderProps } from ".";
+import { createColliderApi, createJointApi, createRigidBodyApi, createWorldApi } from "./api";
 export { CoefficientCombineRule as CoefficientCombineRule } from "@dimforge/rapier3d-compat";
 export { RapierRigidBody, RapierCollider };
-import { Rotation, Vector } from "@dimforge/rapier3d-compat/math";
 export declare type RefGetter<T> = MutableRefObject<() => T | undefined>;
 export declare type RigidBodyAutoCollider = "ball" | "cuboid" | "hull" | "trimesh" | false;
 export interface UseRigidBodyAPI {
@@ -74,6 +74,10 @@ export declare type ColliderShape = "cuboid" | "trimesh" | "ball" | "capsule" |
 export declare type Vector3Array = [x: number, y: number, z: number];
 export declare type Boolean3Array = [x: boolean, y: boolean, z: boolean];
 export interface UseColliderOptions<ColliderArgs extends Array<unknown>> {
+    /**
+     * The optional name passed to THREE's Object3D
+     */
+    name?: string;
     /**
      * The shape of your collider
      */
@@ -136,6 +140,10 @@ export interface UseColliderOptions<ColliderArgs extends Array<unknown>> {
      * 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.
      */
@@ -175,26 +183,44 @@ export interface UseColliderOptions<ColliderArgs extends Array<unknown>> {
      */
     sensor?: boolean;
 }
-export declare type CollisionEnterPayload = {
+export declare type CollisionTarget = {
     rigidBody?: RapierRigidBody;
     collider: RapierCollider;
-    manifold: TempContactManifold;
-    flipped: boolean;
     rigidBodyObject?: Object3D;
     colliderObject?: Object3D;
 };
-export declare type CollisionExitPayload = {
+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 IntersectionEnterPayload = CollisionExitPayload;
-export declare type IntersectionExitPayload = CollisionExitPayload;
+export declare type CollisionEnterPayload = CollisionPayload & {
+    manifold: TempContactManifold;
+    flipped: boolean;
+};
+export declare type CollisionExitPayload = CollisionPayload;
+export declare type IntersectionEnterPayload = CollisionPayload;
+export declare type IntersectionExitPayload = CollisionPayload;
+export declare type ContactForcePayload = CollisionPayload & {
+    totalForce: Vector;
+    totalForceMagnitude: number;
+    maxForceDirection: Vector;
+    maxForceMagnitude: number;
+};
 export declare type CollisionEnterHandler = (payload: CollisionEnterPayload) => void;
 export declare type CollisionExitHandler = (payload: CollisionExitPayload) => void;
 export declare type IntersectionEnterHandler = (payload: IntersectionEnterPayload) => void;
 export declare type IntersectionExitHandler = (payload: IntersectionExitPayload) => void;
+export declare type ContactForceHandler = (payload: ContactForcePayload) => void;
 export interface UseRigidBodyOptions extends ColliderProps {
     /**
      * Specify the type of this rigid body

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

@@ -1,6 +1,6 @@
 import { Collider, RigidBody } from "@dimforge/rapier3d-compat";
 import { MutableRefObject } from "react";
-import { Vector3, Object3D, BufferGeometry } from "three";
+import { BufferGeometry, Object3D, Vector3 } from "three";
 import { ColliderProps, RigidBodyProps } from ".";
 import { WorldApi } from "./api";
 import { ColliderState, ColliderStateMap, EventMap } from "./Physics";