@react-three/p2/dist/src/hooks.d.ts

2D physics based hooks for react-three-fiber

import { Object3D } from 'three';
import type { Quaternion } from 'three';
import type { ContactMaterialOptions } from 'p2-es';
import type { DependencyList, Ref, RefObject } from 'react';
import type { AddRayMessage, AtomicName, CollideBeginEvent, CollideEndEvent, CollideEvent, RayhitEvent, VectorName } from './setup';
export declare type AtomicProps = {
    allowSleep: boolean;
    angle: number;
    angularDamping: number;
    collisionFilterGroup: number;
    collisionFilterMask: number;
    collisionResponse: number;
    fixedRotation: boolean;
    isTrigger: boolean;
    linearDamping: number;
    mass: number;
    material: ContactMaterialOptions;
    sleepSpeedLimit: number;
    sleepTimeLimit: number;
    userData: {};
};
export declare type Duplet = [x: number, y: number];
export declare type VectorProps = Record<VectorName, Duplet>;
export declare type Quad = [x: number, y: number, z: number, w: number];
export declare type BodyProps<T extends any[] = unknown[]> = Partial<AtomicProps> & Partial<VectorProps> & {
    args?: T;
    onCollide?: (e: CollideEvent) => void;
    onCollideBegin?: (e: CollideBeginEvent) => void;
    onCollideEnd?: (e: CollideEndEvent) => void;
    quaternion?: Quad;
    angle?: number;
    type?: 'Dynamic' | 'Static' | 'Kinematic';
};
export declare type BodyPropsArgsRequired<T extends any[] = unknown[]> = BodyProps<T> & {
    args: T;
};
export declare type ShapeType = 'Box' | 'Circle' | 'Capsule' | 'Particle' | 'Plane' | 'Convex' | 'Line' | 'Heightfield';
export declare type BodyShapeType = ShapeType | 'Compound';
export declare type BoxArgs = [width?: number, height?: number];
export declare type CapsuleArgs = [length?: number, radius?: number];
export declare type CircleArgs = [radius?: number];
export declare type ConvexArgs = [vertices: number[][], axes?: number[][]];
export declare type LineArgs = [length?: number];
export declare type HeightfieldArgs = [heights: number[], options?: {
    elementWidth?: number;
    maxValue?: number;
    minValue?: number;
}];
export declare type BoxProps = BodyProps<BoxArgs>;
export declare type CapsuleProps = BodyProps<CapsuleArgs>;
export declare type CircleProps = BodyProps<CircleArgs>;
export declare type ConvexProps = BodyProps<ConvexArgs>;
export declare type LineProps = BodyProps<LineArgs>;
export declare type HeightfieldProps = BodyPropsArgsRequired<HeightfieldArgs>;
export interface CompoundBodyProps extends BodyProps {
    shapes: BodyProps & {
        type: ShapeType;
    }[];
}
export declare type AtomicApi<K extends AtomicName> = {
    set: (value: AtomicProps[K]) => void;
    subscribe: (callback: (value: AtomicProps[K]) => void) => () => void;
};
export declare type QuaternionApi = {
    set: (x: number, y: number, z: number, w: number) => void;
    copy: ({ w, x, y, z }: Quaternion) => void;
    subscribe: (callback: (value: Quad) => void) => () => void;
};
export declare type AngleApi = {
    set: (angle: number) => void;
    copy: (angle: number) => void;
    subscribe: (callback: (value: number) => void) => () => void;
};
export declare type VectorApi = {
    set: (x: number, y: number) => void;
    copy: (array: Duplet) => void;
    subscribe: (callback: (value: Duplet) => void) => () => void;
};
export declare type WorkerApi = {
    [K in AtomicName]: AtomicApi<K>;
} & {
    [K in VectorName]: VectorApi;
} & {
    applyForce: (force: Duplet, worldPoint: Duplet) => void;
    applyImpulse: (impulse: Duplet, worldPoint: Duplet) => void;
    applyLocalForce: (force: Duplet, localPoint: Duplet) => void;
    applyLocalImpulse: (impulse: Duplet, localPoint: Duplet) => void;
    applyTorque: (torque: Duplet) => void;
    quaternion: QuaternionApi;
    angle: AngleApi;
    sleep: () => void;
    wakeUp: () => void;
};
export interface PublicApi extends WorkerApi {
    at: (index: number) => WorkerApi;
}
export declare type Api = [RefObject<Object3D>, PublicApi];
export declare type ConstraintTypes = 'Distance' | 'Gear' | 'Lock' | 'Prismatic' | 'Revolute';
export interface ConstraintOptns {
    collideConnected?: boolean;
}
export interface DistanceConstraintOpts extends ConstraintOptns {
    distance?: number;
    localAnchorA?: Duplet;
    localAnchorB?: Duplet;
    maxForce?: number;
}
export interface GearConstraintOpts extends ConstraintOptns {
    angle?: number;
    ratio?: number;
    maxTorque?: number;
}
export interface LockConstraintOpts extends ConstraintOptns {
    localOffsetB?: Duplet;
    localAngleB?: number;
    maxForce?: number;
}
export interface PrismaticConstraintOpts extends ConstraintOptns {
    maxForce?: number;
    localAnchorA?: Duplet;
    localAnchorB?: Duplet;
    localAxisA?: Duplet;
    disableRotationalLock?: boolean;
    upperLimit?: number;
    lowerLimit?: number;
}
export interface RevoluteConstraintOpts extends ConstraintOptns {
    worldPivot?: Duplet;
    localPivotA?: Duplet;
    localPivotB?: Duplet;
    maxForce?: number;
}
export interface SpringOptns {
    restLength?: number;
    stiffness?: number;
    damping?: number;
    worldAnchorA?: Duplet;
    worldAnchorB?: Duplet;
    localAnchorA?: Duplet;
    localAnchorB?: Duplet;
}
declare type GetByIndex<T extends BodyProps> = (index: number) => T;
export declare function useBox(fn: GetByIndex<BoxProps>, fwdRef?: Ref<Object3D>, deps?: DependencyList): Api;
export declare function useCapsule(fn: GetByIndex<CapsuleProps>, fwdRef?: Ref<Object3D>, deps?: DependencyList): Api;
export declare function useCircle(fn: GetByIndex<CircleProps>, fwdRef?: Ref<Object3D>, deps?: DependencyList): Api;
export declare function useConvex(fn: GetByIndex<ConvexProps>, fwdRef?: Ref<Object3D>, deps?: DependencyList): Api;
export declare function useHeightfield(fn: GetByIndex<HeightfieldProps>, fwdRef?: Ref<Object3D>, deps?: DependencyList): Api;
export declare function useLine(fn: GetByIndex<LineProps>, fwdRef?: Ref<Object3D>, deps?: DependencyList): Api;
export declare function useParticle(fn: GetByIndex<BodyProps>, fwdRef?: Ref<Object3D>, deps?: DependencyList): Api;
export declare function usePlane(fn: GetByIndex<BodyProps>, fwdRef?: Ref<Object3D>, deps?: DependencyList): Api;
export declare function useCompoundBody(fn: GetByIndex<CompoundBodyProps>, fwdRef?: Ref<Object3D>, deps?: DependencyList): Api;
declare type ConstraintApi = [
    RefObject<Object3D>,
    RefObject<Object3D>,
    {
        enable: () => void;
        disable: () => void;
    }
];
declare type SpringApi = [
    RefObject<Object3D>,
    RefObject<Object3D>,
    {
        setStiffness: (value: number) => void;
        setRestLength: (value: number) => void;
        setDamping: (value: number) => void;
    }
];
export declare function useDistanceConstraint(bodyA: Ref<Object3D<import("three").Event>> | undefined, bodyB: Ref<Object3D<import("three").Event>> | undefined, optns: DistanceConstraintOpts, deps?: DependencyList): ConstraintApi;
export declare function useGearConstraint(bodyA: Ref<Object3D<import("three").Event>> | undefined, bodyB: Ref<Object3D<import("three").Event>> | undefined, optns: GearConstraintOpts, deps?: DependencyList): ConstraintApi;
export declare function useLockConstraint(bodyA: Ref<Object3D<import("three").Event>> | undefined, bodyB: Ref<Object3D<import("three").Event>> | undefined, optns: LockConstraintOpts, deps?: DependencyList): ConstraintApi;
export declare function usePrismaticConstraint(bodyA: Ref<Object3D<import("three").Event>> | undefined, bodyB: Ref<Object3D<import("three").Event>> | undefined, optns: PrismaticConstraintOpts, deps?: DependencyList): ConstraintApi;
export declare function useRevoluteConstraint(bodyA: Ref<Object3D<import("three").Event>> | undefined, bodyB: Ref<Object3D<import("three").Event>> | undefined, optns: RevoluteConstraintOpts, deps?: DependencyList): ConstraintApi;
export declare function useSpring(bodyA: Ref<Object3D<import("three").Event>> | undefined, bodyB: Ref<Object3D<import("three").Event>> | undefined, optns: SpringOptns, deps?: DependencyList): SpringApi;
declare type RayOptions = Omit<AddRayMessage['props'], 'mode'>;
export declare function useRaycastClosest(options: RayOptions, callback: (e: RayhitEvent) => void, deps?: DependencyList): void;
export declare function useRaycastAny(options: RayOptions, callback: (e: RayhitEvent) => void, deps?: DependencyList): void;
export declare function useRaycastAll(options: RayOptions, callback: (e: RayhitEvent) => void, deps?: DependencyList): void;
export interface TopDownVehiclePublicApi {
    applyEngineForce: (value: number, wheelIndex: number) => void;
    setBrake: (brake: number, wheelIndex: number) => void;
    setSteeringValue: (value: number, wheelIndex: number) => void;
}
export interface WheelInfoOptions {
    localPosition?: Duplet;
    sideFriction?: number;
}
export interface TopDownVehicleProps {
    chassisBody: Ref<Object3D>;
    wheelInfos: WheelInfoOptions[];
    indexForwardAxis?: number;
    indexRightAxis?: number;
    indexUpAxis?: number;
}
export declare function useTopDownVehicle(fn: () => TopDownVehicleProps, fwdRef?: Ref<Object3D>, deps?: DependencyList): [RefObject<Object3D>, TopDownVehiclePublicApi];
export interface KinematicCharacterControllerPublicApi {
    setJump: (isDown: boolean) => void;
    setInput: (input: [x: number, y: number]) => void;
    collisions: {
        subscribe: (callback: (collisions: {}) => void) => void;
    };
    raysData: {
        subscribe: (callback: (raysData: {}) => void) => void;
    };
}
export interface KinematicCharacterControllerProps {
    body: Ref<Object3D>;
    collisionMask: number;
    accelerationTimeAirborne?: number;
    accelerationTimeGrounded?: number;
    moveSpeed?: number;
    wallSlideSpeedMax?: number;
    wallStickTime?: number;
    wallJumpClimb?: Duplet;
    wallJumpOff?: Duplet;
    wallLeap?: Duplet;
    timeToJumpApex?: number;
    maxJumpHeight?: number;
    minJumpHeight?: number;
    velocityXSmoothing?: number;
    velocityXMin?: number;
    maxClimbAngle?: number;
    maxDescendAngle?: number;
    skinWidth?: number;
    dstBetweenRays?: number;
}
export declare function useKinematicCharacterController(fn: () => KinematicCharacterControllerProps, fwdRef?: Ref<Object3D>, deps?: DependencyList): [RefObject<Object3D>, KinematicCharacterControllerPublicApi];
export interface PlatformControllerPublicApi {
    collisions: {
        subscribe: (callback: (collisions: {}) => void) => void;
    };
    raysData: {
        subscribe: (callback: (raysData: {}) => void) => void;
    };
}
export interface PlatformControllerProps {
    body: Ref<Object3D>;
    passengerMask: number;
    localWaypoints: Duplet[];
    speed?: number;
    skinWidth?: number;
    dstBetweenRays?: number;
}
export declare function usePlatformController(fn: () => PlatformControllerProps, fwdRef?: Ref<Object3D>, deps?: DependencyList): [RefObject<Object3D>, PlatformControllerPublicApi];
export {};