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

2D physics based hooks for react-three-fiber

import type { RayOptions } from 'p2-es';
import type { MutableRefObject } from 'react';
import type { Object3D } from 'three';
import type { ProviderProps, WorkerCollideEvent, WorkerRayhitEvent } from './Provider';
import type { AtomicProps, BodyProps, BodyShapeType, ConstraintTypes, Quad, SpringOptns, WheelInfoOptions } from './hooks';
import type { Duplet } from './hooks';
export declare type Buffers = {
    positions: Float32Array;
    quaternions: Float32Array;
};
export declare type Refs = {
    [uuid: string]: Object3D;
};
declare type WorkerContact = WorkerCollideEvent['data']['contact'];
export declare type CollideEvent = Omit<WorkerCollideEvent['data'], 'body' | 'target' | 'contact'> & {
    body: Object3D;
    target: Object3D;
    contact: Omit<WorkerContact, 'bi' | 'bj'> & {
        bi: Object3D;
        bj: Object3D;
    };
};
export declare type CollideBeginEvent = {
    op: 'event';
    type: 'collideBegin';
    target: Object3D;
    body: Object3D;
    contacts: [];
};
export declare type CollideEndEvent = {
    op: 'event';
    type: 'collideEnd';
    target: Object3D;
    body: Object3D;
};
export declare type RayhitEvent = Omit<WorkerRayhitEvent['data'], 'body'> & {
    body: Object3D | null;
};
declare type CannonEvent = CollideBeginEvent | CollideEndEvent | CollideEvent | RayhitEvent;
declare type CallbackByType<T extends {
    type: string;
}> = {
    [K in T['type']]?: T extends {
        type: K;
    } ? (e: T) => void : never;
};
declare type CannonEvents = {
    [uuid: string]: Partial<CallbackByType<CannonEvent>>;
};
export declare type Subscription = Partial<{
    [K in SubscriptionName]: (value: PropValue<K>) => void;
}>;
export declare type Subscriptions = Partial<{
    [id: number]: Subscription;
}>;
declare type CharacterControllerCollisions = [
    above: boolean,
    below: boolean,
    left: boolean,
    right: boolean,
    climbingSlope: boolean,
    descendingSlope: boolean,
    slopeAngle: number,
    slopeAngleOld: number,
    velocityOld: Duplet,
    faceDir: number,
    fallingThroughPlatform: boolean
];
export declare type PropValue<T extends SubscriptionName = SubscriptionName> = T extends AtomicName ? AtomicProps[T] : T extends VectorName ? Duplet : T extends 'quaternion' ? Quad : T extends 'collisions' ? CharacterControllerCollisions : never;
export declare const atomicNames: readonly ["allowSleep", "angle", "angularDamping", "collisionFilterGroup", "collisionFilterMask", "collisionResponse", "fixedRotation", "isTrigger", "linearDamping", "mass", "material", "sleepSpeedLimit", "sleepTimeLimit", "userData"];
export declare type AtomicName = typeof atomicNames[number];
export declare const vectorNames: readonly ["angularFactor", "angularVelocity", "linearFactor", "position", "velocity"];
export declare type VectorName = typeof vectorNames[number];
export declare const subscriptionNames: readonly ["allowSleep", "angle", "angularDamping", "collisionFilterGroup", "collisionFilterMask", "collisionResponse", "fixedRotation", "isTrigger", "linearDamping", "mass", "material", "sleepSpeedLimit", "sleepTimeLimit", "userData", "angularFactor", "angularVelocity", "linearFactor", "position", "velocity", "quaternion", "collisions", "raysData"];
export declare type SubscriptionName = typeof subscriptionNames[number];
export declare type SetOpName<T extends AtomicName | VectorName | WorldPropName | 'quaternion' | 'rotation'> = `set${Capitalize<T>}`;
declare type Operation<T extends string, P> = {
    op: T;
} & (P extends void ? {} : {
    props: P;
});
declare type WithUUID<T extends string, P = void> = Operation<T, P> & {
    uuid: string;
};
declare type WithUUIDs<T extends string, P = void> = Operation<T, P> & {
    uuid: string[];
};
declare type AddConstraintMessage = WithUUID<'addConstraint', [uuidA: string, uuidB: string, options: {}]> & {
    type: 'Hinge' | ConstraintTypes;
};
declare type DisableConstraintMessage = WithUUID<'disableConstraint'>;
declare type EnableConstraintMessage = WithUUID<'enableConstraint'>;
declare type RemoveConstraintMessage = WithUUID<'removeConstraint'>;
declare type ConstraintMessage = AddConstraintMessage | DisableConstraintMessage | EnableConstraintMessage | RemoveConstraintMessage;
declare type DisableConstraintMotorMessage = WithUUID<'disableConstraintMotor'>;
declare type EnableConstraintMotorMessage = WithUUID<'enableConstraintMotor'>;
declare type SetConstraintMotorMaxForce = WithUUID<'setConstraintMotorMaxForce', number>;
declare type SetConstraintMotorSpeed = WithUUID<'setConstraintMotorSpeed', number>;
declare type ConstraintMotorMessage = DisableConstraintMotorMessage | EnableConstraintMotorMessage | SetConstraintMotorSpeed | SetConstraintMotorMaxForce;
declare type AddSpringMessage = WithUUID<'addSpring', [uuidA: string, uuidB: string, options: SpringOptns]>;
declare type RemoveSpringMessage = WithUUID<'removeSpring'>;
declare type SetSpringDampingMessage = WithUUID<'setSpringDamping', number>;
declare type SetSpringRestLengthMessage = WithUUID<'setSpringRestLength', number>;
declare type SetSpringStiffnessMessage = WithUUID<'setSpringStiffness', number>;
declare type SpringMessage = AddSpringMessage | RemoveSpringMessage | SetSpringDampingMessage | SetSpringRestLengthMessage | SetSpringStiffnessMessage;
export declare type RayMode = 'Closest' | 'Any' | 'All';
export declare type AddRayMessage = WithUUID<'addRay', {
    from?: Duplet;
    mode: RayMode;
    to?: Duplet;
} & Pick<RayOptions, 'checkCollisionResponse' | 'collisionGroup' | 'collisionMask' | 'skipBackfaces'>>;
declare type RemoveRayMessage = WithUUID<'removeRay'>;
declare type RayMessage = AddRayMessage | RemoveRayMessage;
declare type AddTopDownVehicleMessage = WithUUIDs<'addTopDownVehicle', [
    chassisBodyUUID: string,
    wheelInfos: WheelInfoOptions[],
    indexForwardAxis: number,
    indexRightAxis: number,
    indexUpAxis: number
]>;
declare type RemoveTopDownVehicleMessage = WithUUIDs<'removeTopDownVehicle'>;
declare type ApplyTopDownVehicleEngineForceMessage = WithUUID<'applyTopDownVehicleEngineForce', [
    value: number,
    wheelIndex: number
]>;
declare type SetTopDownVehicleBrakeMessage = WithUUID<'setTopDownVehicleBrake', [brake: number, wheelIndex: number]>;
declare type SetTopDownVehicleSteeringValueMessage = WithUUID<'setTopDownVehicleSteeringValue', [value: number, wheelIndex: number]>;
declare type TopDownVehicleMessage = AddTopDownVehicleMessage | ApplyTopDownVehicleEngineForceMessage | RemoveTopDownVehicleMessage | SetTopDownVehicleBrakeMessage | SetTopDownVehicleSteeringValueMessage;
declare type AddKinematicCharacterControllerMessage = WithUUIDs<'addKinematicCharacterController', [
    bodyUUID: string,
    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
]>;
declare type RemoveKinematicCharacterControllerMessage = WithUUIDs<'removeKinematicCharacterController'>;
declare type SetKinematicCharacterControllerJumpMessage = WithUUID<'setKinematicCharacterControllerJump', [isDown: boolean]>;
declare type SetKinematicCharacterControllerInputMessage = WithUUID<'setKinematicCharacterControllerInput', [input: [x: number, y: number]]>;
declare type KinematicCharacterControllerMessage = AddKinematicCharacterControllerMessage | RemoveKinematicCharacterControllerMessage | SetKinematicCharacterControllerJumpMessage | SetKinematicCharacterControllerInputMessage;
declare type AddPlatformControllerMessage = WithUUIDs<'addPlatformController', [
    bodyUUID: string,
    passengerMask: number,
    localWaypoints: Duplet[],
    speed?: number,
    skinWidth?: number,
    dstBetweenRays?: number
]>;
declare type RemovePlatformControllerMessage = WithUUIDs<'removePlatformController'>;
declare type PlatformControllerMessage = AddPlatformControllerMessage | RemovePlatformControllerMessage;
declare type AtomicMessage = WithUUID<SetOpName<AtomicName>, any>;
declare type QuaternionMessage = WithUUID<SetOpName<'quaternion'>, Quad>;
declare type RotationMessage = WithUUID<SetOpName<'rotation'>, number>;
declare type VectorMessage = WithUUID<SetOpName<VectorName>, Duplet>;
declare type ApplyForceMessage = WithUUID<'applyForce', [force: Duplet, worldPoint: Duplet]>;
declare type ApplyImpulseMessage = WithUUID<'applyImpulse', [impulse: Duplet, worldPoint: Duplet]>;
declare type ApplyLocalForceMessage = WithUUID<'applyLocalForce', [force: Duplet, localPoint: Duplet]>;
declare type ApplyLocalImpulseMessage = WithUUID<'applyLocalImpulse', [impulse: Duplet, localPoint: Duplet]>;
declare type ApplyTorque = WithUUID<'applyTorque', [torque: Duplet]>;
declare type ApplyMessage = ApplyForceMessage | ApplyImpulseMessage | ApplyLocalForceMessage | ApplyLocalImpulseMessage | ApplyTorque;
declare type SerializableBodyProps = {
    onCollide: boolean;
};
declare type AddBodiesMessage = WithUUIDs<'addBodies', SerializableBodyProps[]> & {
    type: BodyShapeType;
};
declare type RemoveBodiesMessage = WithUUIDs<'removeBodies'>;
declare type BodiesMessage = AddBodiesMessage | RemoveBodiesMessage;
declare type SleepMessage = WithUUID<'sleep'>;
declare type WakeUpMessage = WithUUID<'wakeUp'>;
export declare type SubscriptionTarget = 'bodies' | 'vehicles' | 'controllers';
declare type SubscribeMessage = WithUUID<'subscribe', {
    id: number;
    target: SubscriptionTarget;
    type: SubscriptionName;
}>;
declare type UnsubscribeMessage = Operation<'unsubscribe', number>;
declare type SubscriptionMessage = SubscribeMessage | UnsubscribeMessage;
export declare type WorldPropName = 'axisIndex' | 'broadphase' | 'gravity' | 'iterations' | 'step' | 'tolerance';
declare type WorldMessage<T extends WorldPropName> = Operation<SetOpName<T>, Required<ProviderProps[T]>>;
declare type CannonMessage = ApplyMessage | AtomicMessage | BodiesMessage | ConstraintMessage | ConstraintMotorMessage | QuaternionMessage | TopDownVehicleMessage | KinematicCharacterControllerMessage | PlatformControllerMessage | RayMessage | RotationMessage | SleepMessage | SpringMessage | SubscriptionMessage | VectorMessage | WakeUpMessage | WorldMessage<WorldPropName>;
export interface CannonWorker extends Worker {
    postMessage: (message: CannonMessage) => void;
}
export declare type ProviderContext = {
    worker: CannonWorker;
    bodies: MutableRefObject<{
        [uuid: string]: number;
    }>;
    buffers: Buffers;
    refs: Refs;
    events: CannonEvents;
    subscriptions: Subscriptions;
};
export declare type DebugApi = {
    add(id: string, props: BodyProps, type: BodyShapeType): void;
    remove(id: string): void;
};
export declare const context: import("react").Context<ProviderContext>;
export declare const debugContext: import("react").Context<DebugApi>;
export {};