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

2D physics based hooks for react-three-fiber

import type { ContactMaterialOptions, MaterialOptions } from 'p2-es';
import type { DependencyList, Ref, RefObject } from 'react';
import { Object3D } from 'three';
import type { AtomicName, CollideBeginEvent, CollideEndEvent, CollideEvent, DistanceConstraintOpts, Duplet, GearConstraintOpts, LockConstraintOpts, PrismaticConstraintOpts, RayhitEvent, RayOptions, RevoluteConstraintOpts, SpringOptns, VectorName, WheelInfoOptions } from './setup';
export declare type AtomicProps = {
    allowSleep: boolean;
    angle: number;
    angularDamping: number;
    angularVelocity: number;
    collisionFilterGroup: number;
    collisionFilterMask: number;
    collisionResponse: boolean;
    fixedRotation: boolean;
    isTrigger: boolean;
    linearDamping: number;
    mass: number;
    material: MaterialOptions;
    sleepSpeedLimit: number;
    sleepTimeLimit: number;
    userData: Record<PropertyKey, any>;
};
export declare type VectorProps = Record<VectorName, Duplet>;
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;
    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 VectorApi = {
    copy: (array: Duplet) => void;
    set: (x: number, y: number) => 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;
    sleep: () => void;
    wakeUp: () => void;
};
export interface PublicApi extends WorkerApi {
    at: (index: number) => WorkerApi;
}
export declare type Api = [RefObject<Object3D>, PublicApi];
declare type GetByIndex<T extends BodyProps> = (index: number) => T;
export declare function usePlane(fn: GetByIndex<BodyProps>, fwdRef?: Ref<Object3D>, deps?: DependencyList): Api;
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 useCompoundBody(fn: GetByIndex<CompoundBodyProps>, fwdRef?: Ref<Object3D>, deps?: DependencyList): Api;
declare type ConstraintApi = [
    RefObject<Object3D>,
    RefObject<Object3D>,
    {
        disable: () => void;
        enable: () => void;
    }
];
declare type SpringApi = [
    RefObject<Object3D>,
    RefObject<Object3D>,
    {
        setDamping: (value: number) => void;
        setRestLength: (value: number) => void;
        setStiffness: (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;
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 TopDownVehicleProps {
    chassisBody: Ref<Object3D>;
    wheels: WheelInfoOptions[];
}
export declare function useTopDownVehicle(fn: () => TopDownVehicleProps, fwdRef?: Ref<Object3D>, deps?: DependencyList): [RefObject<Object3D>, TopDownVehiclePublicApi];
export declare function useContactMaterial(materialA: MaterialOptions, materialB: MaterialOptions, options: ContactMaterialOptions, deps?: DependencyList): void;
declare type KinematicCharacterControllerCollisions = {
    above: boolean;
    below: boolean;
    climbingSlope: boolean;
    descendingSlope: boolean;
    faceDir: number;
    fallingThroughPlatform: boolean;
    left: boolean;
    right: boolean;
    slopeAngle: number;
    slopeAngleOld: number;
    velocityOld: Duplet;
};
export interface KinematicCharacterControllerPublicApi {
    collisions: {
        subscribe: (callback: (collisions: KinematicCharacterControllerCollisions) => void) => void;
    };
    raysData: {
        subscribe: (callback: (raysData: []) => void) => void;
    };
    setInput: (input: [x: number, y: number]) => void;
    setJump: (isDown: boolean) => void;
}
export interface KinematicCharacterControllerProps {
    accelerationTimeAirborne?: number;
    accelerationTimeGrounded?: number;
    body: Ref<Object3D>;
    collisionMask: number;
    dstBetweenRays?: number;
    maxClimbAngle?: number;
    maxDescendAngle?: number;
    maxJumpHeight?: number;
    minJumpHeight?: number;
    moveSpeed?: number;
    skinWidth?: number;
    timeToJumpApex?: number;
    velocityXMin?: number;
    velocityXSmoothing?: number;
    wallJumpClimb?: Duplet;
    wallJumpOff?: Duplet;
    wallLeap?: Duplet;
    wallSlideSpeedMax?: number;
    wallStickTime?: 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>;
    dstBetweenRays?: number;
    localWaypoints: Duplet[];
    passengerMask: number;
    skinWidth?: number;
    speed?: number;
}
export declare function usePlatformController(fn: () => PlatformControllerProps, fwdRef?: Ref<Object3D>, deps?: DependencyList): [RefObject<Object3D>, PlatformControllerPublicApi];
export {};