@frsource/babylon-box3d 1.0.0

package/dist/index.d.mts

@@ -0,0 +1,782 @@
+/**
+ * box3d-wasm ships no bundled TypeScript types (see
+ * https://github.com/monteslu/box3d-wasm). This is a hand-written surface
+ * covering exactly the embind API consumed by {@link Box3DPlugin}, derived
+ * from the wrapper's glue code (csrc/glue.cpp) and README.
+ */
+declare module 'box3d-wasm' {
+  export interface Vec3 {
+    x: number;
+    y: number;
+    z: number;
+  }
+
+  export interface Quat {
+    x: number;
+    y: number;
+    z: number;
+    w: number;
+  }
+
+  export interface Box3DTransform {
+    position?: Vec3;
+    rotation?: Quat;
+  }
+
+  export interface Filter {
+    categoryBits?: number;
+    maskBits?: number;
+    groupIndex?: number;
+  }
+
+  export interface ShapeMaterialOptions {
+    density?: number;
+    friction?: number;
+    restitution?: number;
+    rollingResistance?: number;
+    tangentVelocity?: Vec3;
+    userMaterialId?: number;
+    isSensor?: boolean;
+    enableSensorEvents?: boolean;
+    enableContactEvents?: boolean;
+    enableHitEvents?: boolean;
+    invokeContactCreation?: boolean;
+    updateBodyMass?: boolean;
+    filter?: Filter;
+    userData?: number;
+  }
+
+  export interface BoxShapeOptions extends ShapeMaterialOptions {
+    halfExtents?: Vec3;
+    hx?: number;
+    hy?: number;
+    hz?: number;
+    offset?: Vec3;
+    rotation?: Quat;
+  }
+
+  export interface SphereShapeOptions extends ShapeMaterialOptions {
+    center?: Vec3;
+    radius?: number;
+  }
+
+  export interface CapsuleShapeOptions extends ShapeMaterialOptions {
+    radius?: number;
+    height?: number;
+    center1?: Vec3;
+    center2?: Vec3;
+  }
+
+  export interface HullShapeOptions extends ShapeMaterialOptions {
+    points: Vec3[];
+    maxVertices?: number;
+  }
+
+  export interface AABB {
+    lowerBound: Vec3;
+    upperBound: Vec3;
+  }
+
+  export interface ShapeRayCastResult {
+    hit: boolean;
+    point?: Vec3;
+    normal?: Vec3;
+    fraction?: number;
+  }
+
+  export type Box3DShapeType =
+    | 'sphere'
+    | 'capsule'
+    | 'hull'
+    | 'mesh'
+    | 'heightField'
+    | 'compound'
+    | 'unknown';
+
+  export class Shape {
+    isValid(): boolean;
+    destroy(updateBodyMass: boolean): void;
+    getType(): Box3DShapeType;
+    getUserData(): number;
+    setUserData(tag: number): void;
+    getFriction(): number;
+    setFriction(friction: number): void;
+    getRestitution(): number;
+    setRestitution(restitution: number): void;
+    getDensity(): number;
+    setDensity(density: number, updateBodyMass: boolean): void;
+    isSensor(): boolean;
+    enableSensorEvents(flag: boolean): void;
+    enableContactEvents(flag: boolean): void;
+    enableHitEvents(flag: boolean): void;
+    getFilter(): Required<Filter>;
+    setFilter(filter: Filter): void;
+    getAABB(): AABB;
+    rayCast(origin: Vec3, translation: Vec3): ShapeRayCastResult;
+  }
+
+  export interface JointBaseOptions {
+    localFrameA?: Box3DTransform;
+    localFrameB?: Box3DTransform;
+    anchorA?: Vec3;
+    anchorB?: Vec3;
+    collideConnected?: boolean;
+    forceThreshold?: number;
+    torqueThreshold?: number;
+  }
+
+  export class Joint {
+    isValid(): boolean;
+    destroy(wakeAttached: boolean): void;
+    getType(): string;
+    wakeBodies(): void;
+    getCollideConnected(): boolean;
+    setCollideConnected(flag: boolean): void;
+    getLocalFrameA(): Required<Box3DTransform>;
+    getLocalFrameB(): Required<Box3DTransform>;
+    getConstraintForce(): Vec3;
+    getConstraintTorque(): Vec3;
+  }
+
+  export interface DistanceJointOptions extends JointBaseOptions {
+    length?: number;
+    enableSpring?: boolean;
+    hertz?: number;
+    dampingRatio?: number;
+    lowerSpringForce?: number;
+    upperSpringForce?: number;
+    enableLimit?: boolean;
+    minLength?: number;
+    maxLength?: number;
+    enableMotor?: boolean;
+    maxMotorForce?: number;
+    motorSpeed?: number;
+  }
+
+  export class DistanceJoint extends Joint {
+    setLength(length: number): void;
+    getLength(): number;
+    getCurrentLength(): number;
+    enableSpring(flag: boolean): void;
+    setSpringHertz(hertz: number): void;
+    setSpringDampingRatio(ratio: number): void;
+    enableLimit(flag: boolean): void;
+    setLengthRange(min: number, max: number): void;
+    enableMotor(flag: boolean): void;
+    setMotorSpeed(speed: number): void;
+    setMaxMotorForce(force: number): void;
+  }
+
+  export interface RevoluteJointOptions extends JointBaseOptions {
+    targetAngle?: number;
+    enableSpring?: boolean;
+    hertz?: number;
+    dampingRatio?: number;
+    enableLimit?: boolean;
+    lowerAngle?: number;
+    upperAngle?: number;
+    enableMotor?: boolean;
+    maxMotorTorque?: number;
+    motorSpeed?: number;
+  }
+
+  export class RevoluteJoint extends Joint {
+    getAngle(): number;
+    enableSpring(flag: boolean): void;
+    setSpringHertz(hertz: number): void;
+    setSpringDampingRatio(ratio: number): void;
+    setTargetAngle(angle: number): void;
+    enableLimit(flag: boolean): void;
+    setLimits(lower: number, upper: number): void;
+    enableMotor(flag: boolean): void;
+    setMotorSpeed(speed: number): void;
+    setMaxMotorTorque(torque: number): void;
+    getMotorTorque(): number;
+  }
+
+  export interface SphericalJointOptions extends JointBaseOptions {
+    enableSpring?: boolean;
+    hertz?: number;
+    dampingRatio?: number;
+    targetRotation?: Quat;
+    enableConeLimit?: boolean;
+    coneAngle?: number;
+    enableTwistLimit?: boolean;
+    lowerTwistAngle?: number;
+    upperTwistAngle?: number;
+    enableMotor?: boolean;
+    maxMotorTorque?: number;
+    motorVelocity?: Vec3;
+  }
+
+  export class SphericalJoint extends Joint {
+    enableConeLimit(flag: boolean): void;
+    setConeLimit(angle: number): void;
+    getConeAngle(): number;
+    enableTwistLimit(flag: boolean): void;
+    setTwistLimits(lower: number, upper: number): void;
+    getTwistAngle(): number;
+    enableSpring(flag: boolean): void;
+    setSpringHertz(hertz: number): void;
+    setSpringDampingRatio(ratio: number): void;
+    setTargetRotation(rotation: Quat): void;
+    enableMotor(flag: boolean): void;
+    setMotorVelocity(velocity: Vec3): void;
+    setMaxMotorTorque(torque: number): void;
+  }
+
+  export interface PrismaticJointOptions extends JointBaseOptions {
+    enableSpring?: boolean;
+    hertz?: number;
+    dampingRatio?: number;
+    targetTranslation?: number;
+    enableLimit?: boolean;
+    lowerTranslation?: number;
+    upperTranslation?: number;
+    enableMotor?: boolean;
+    maxMotorForce?: number;
+    motorSpeed?: number;
+  }
+
+  export class PrismaticJoint extends Joint {
+    getTranslation(): number;
+    getSpeed(): number;
+    enableSpring(flag: boolean): void;
+    setSpringHertz(hertz: number): void;
+    setSpringDampingRatio(ratio: number): void;
+    setTargetTranslation(translation: number): void;
+    enableLimit(flag: boolean): void;
+    setLimits(lower: number, upper: number): void;
+    enableMotor(flag: boolean): void;
+    setMotorSpeed(speed: number): void;
+    setMaxMotorForce(force: number): void;
+  }
+
+  export interface WeldJointOptions extends JointBaseOptions {
+    linearHertz?: number;
+    angularHertz?: number;
+    linearDampingRatio?: number;
+    angularDampingRatio?: number;
+  }
+
+  export class WeldJoint extends Joint {
+    setLinearHertz(hertz: number): void;
+    setLinearDampingRatio(ratio: number): void;
+    setAngularHertz(hertz: number): void;
+    setAngularDampingRatio(ratio: number): void;
+  }
+
+  export interface MotorJointOptions extends JointBaseOptions {
+    linearVelocity?: Vec3;
+    maxVelocityForce?: number;
+    angularVelocity?: Vec3;
+    maxVelocityTorque?: number;
+    linearHertz?: number;
+    linearDampingRatio?: number;
+    maxSpringForce?: number;
+    angularHertz?: number;
+    angularDampingRatio?: number;
+    maxSpringTorque?: number;
+  }
+
+  export class MotorJoint extends Joint {
+    setLinearVelocity(velocity: Vec3): void;
+    setAngularVelocity(velocity: Vec3): void;
+    setMaxVelocityForce(force: number): void;
+    setMaxVelocityTorque(torque: number): void;
+    setLinearHertz(hertz: number): void;
+    setLinearDampingRatio(ratio: number): void;
+    setAngularHertz(hertz: number): void;
+    setAngularDampingRatio(ratio: number): void;
+    setMaxSpringForce(force: number): void;
+    setMaxSpringTorque(torque: number): void;
+  }
+
+  export interface MotionLocks {
+    linearX?: boolean;
+    linearY?: boolean;
+    linearZ?: boolean;
+    angularX?: boolean;
+    angularY?: boolean;
+    angularZ?: boolean;
+  }
+
+  export type Box3DBodyType = 'static' | 'kinematic' | 'dynamic';
+
+  export interface BodyOptions {
+    type?: Box3DBodyType;
+    position?: Vec3;
+    rotation?: Quat;
+    linearVelocity?: Vec3;
+    angularVelocity?: Vec3;
+    linearDamping?: number;
+    angularDamping?: number;
+    gravityScale?: number;
+    sleepThreshold?: number;
+    enableSleep?: boolean;
+    isAwake?: boolean;
+    isBullet?: boolean;
+    isEnabled?: boolean;
+    allowFastRotation?: boolean;
+    enableContactRecycling?: boolean;
+    motionLocks?: MotionLocks;
+    userData?: number;
+    name?: string;
+  }
+
+  export class Body {
+    isValid(): boolean;
+    destroy(): void;
+    getType(): Box3DBodyType;
+    setType(type: Box3DBodyType): void;
+    getName(): string;
+    setName(name: string): void;
+    getUserData(): number;
+    setUserData(tag: number): void;
+    getPosition(): Vec3;
+    getRotation(): Quat;
+    getTransform(): Required<Box3DTransform>;
+    setTransform(position: Vec3, rotation: Quat): void;
+    setTargetTransform(
+      target: Box3DTransform,
+      timeStep: number,
+      wake: boolean,
+    ): void;
+    getLinearVelocity(): Vec3;
+    setLinearVelocity(velocity: Vec3): void;
+    getAngularVelocity(): Vec3;
+    setAngularVelocity(velocity: Vec3): void;
+    applyForce(force: Vec3, point: Vec3, wake: boolean): void;
+    applyForceToCenter(force: Vec3, wake: boolean): void;
+    applyTorque(torque: Vec3, wake: boolean): void;
+    applyLinearImpulse(impulse: Vec3, point: Vec3, wake: boolean): void;
+    applyLinearImpulseToCenter(impulse: Vec3, wake: boolean): void;
+    applyAngularImpulse(impulse: Vec3, wake: boolean): void;
+    getMass(): number;
+    applyMassFromShapes(): void;
+    getLocalCenterOfMass(): Vec3;
+    getWorldCenterOfMass(): Vec3;
+    getLocalPoint(worldPoint: Vec3): Vec3;
+    getWorldPoint(localPoint: Vec3): Vec3;
+    getLinearDamping(): number;
+    setLinearDamping(damping: number): void;
+    getAngularDamping(): number;
+    setAngularDamping(damping: number): void;
+    getGravityScale(): number;
+    setGravityScale(scale: number): void;
+    isAwake(): boolean;
+    setAwake(awake: boolean): void;
+    enableSleep(flag: boolean): void;
+    isEnabled(): boolean;
+    setEnabled(flag: boolean): void;
+    isBullet(): boolean;
+    setBullet(flag: boolean): void;
+    setMotionLocks(locks: MotionLocks): void;
+    getMotionLocks(): Required<MotionLocks>;
+    getShapeCount(): number;
+    computeAABB(): AABB;
+    createSphere(options: SphereShapeOptions): Shape;
+    createCapsule(options: CapsuleShapeOptions): Shape;
+    createBox(options: BoxShapeOptions): Shape;
+    createHull(options: HullShapeOptions): Shape;
+  }
+
+  export interface WorldOptions {
+    gravity?: Vec3;
+    restitutionThreshold?: number;
+    hitEventThreshold?: number;
+    contactHertz?: number;
+    contactDampingRatio?: number;
+    contactSpeed?: number;
+    maximumLinearSpeed?: number;
+    enableSleep?: boolean;
+    enableContinuous?: boolean;
+    /** Only honored by the `deluxe` (threaded) flavour. */
+    workerCount?: number;
+  }
+
+  export interface RayCastResult {
+    hit: boolean;
+    point?: Vec3;
+    normal?: Vec3;
+    fraction?: number;
+    shapeUserData?: number;
+    bodyUserData?: number;
+    shape?: Shape;
+  }
+
+  export interface QueryFilter {
+    categoryBits?: number;
+    maskBits?: number;
+  }
+
+  export interface ExplosionOptions {
+    position?: Vec3;
+    radius?: number;
+    falloff?: number;
+    impulsePerArea?: number;
+    maskBits?: number;
+  }
+
+  export interface BodyMoveEvent {
+    userData: number;
+    position: Vec3;
+    rotation: Quat;
+    fellAsleep: boolean;
+  }
+
+  export interface ContactBeginEvent {
+    shapeUserDataA: number;
+    shapeUserDataB: number;
+  }
+
+  export interface ContactEndEvent {
+    shapeUserDataA: number | null;
+    shapeUserDataB: number | null;
+  }
+
+  export interface ContactHitEvent {
+    shapeUserDataA: number;
+    shapeUserDataB: number;
+    point: Vec3;
+    normal: Vec3;
+    approachSpeed: number;
+  }
+
+  export interface ContactEvents {
+    begin: ContactBeginEvent[];
+    end: ContactEndEvent[];
+    hit: ContactHitEvent[];
+  }
+
+  export interface SensorBeginEvent {
+    sensorUserData: number;
+    visitorUserData: number;
+  }
+
+  export interface SensorEndEvent {
+    sensorUserData: number | null;
+    visitorUserData: number | null;
+  }
+
+  export interface SensorEvents {
+    begin: SensorBeginEvent[];
+    end: SensorEndEvent[];
+  }
+
+  export interface Profile {
+    step: number;
+    pairs: number;
+    collide: number;
+    solve: number;
+  }
+
+  export class World {
+    constructor(options?: WorldOptions);
+    isValid(): boolean;
+    destroy(): void;
+    step(timeStep: number, subStepCount: number): void;
+    getGravity(): Vec3;
+    setGravity(gravity: Vec3): void;
+    enableSleeping(flag: boolean): void;
+    enableContinuous(flag: boolean): void;
+    getAwakeBodyCount(): number;
+    getWorkerCount(): number;
+    createBody(options?: BodyOptions): Body;
+    createDistanceJoint(
+      bodyA: Body,
+      bodyB: Body,
+      options?: DistanceJointOptions,
+    ): DistanceJoint;
+    createRevoluteJoint(
+      bodyA: Body,
+      bodyB: Body,
+      options?: RevoluteJointOptions,
+    ): RevoluteJoint;
+    createSphericalJoint(
+      bodyA: Body,
+      bodyB: Body,
+      options?: SphericalJointOptions,
+    ): SphericalJoint;
+    createPrismaticJoint(
+      bodyA: Body,
+      bodyB: Body,
+      options?: PrismaticJointOptions,
+    ): PrismaticJoint;
+    createWeldJoint(
+      bodyA: Body,
+      bodyB: Body,
+      options?: WeldJointOptions,
+    ): WeldJoint;
+    createMotorJoint(
+      bodyA: Body,
+      bodyB: Body,
+      options?: MotorJointOptions,
+    ): MotorJoint;
+    castRayClosest(
+      origin: Vec3,
+      translation: Vec3,
+      filter?: QueryFilter,
+    ): RayCastResult;
+    explode(options: ExplosionOptions): void;
+    getBodyEvents(): BodyMoveEvent[];
+    getContactEvents(): ContactEvents;
+    getSensorEvents(): SensorEvents;
+    getProfile(): Profile;
+  }
+
+  export interface Box3DModule {
+    World: typeof World;
+    /** Whether this flavour of the module has wasm threads enabled. */
+    threaded: boolean;
+    /** Upper bound accepted by `WorldOptions.workerCount`. */
+    maxWorkers: number;
+  }
+
+  export interface Box3DFactoryOptions {
+    locateFile?: (path: string, prefix: string) => string;
+    [key: string]: unknown;
+  }
+
+  export default function Box3D(
+    options?: Box3DFactoryOptions,
+  ): Promise<Box3DModule>;
+}
+
+declare module 'box3d-wasm/standard' {
+  export { default } from 'box3d-wasm';
+}
+
+declare module 'box3d-wasm/deluxe' {
+  export { default } from 'box3d-wasm';
+}
+
+/**
+ * Joint types box3d-wasm's compiled binary exposes (wheel joint: car
+ * suspension + steering + drive in a single joint; filter joint: pure
+ * collision-filtering between two bodies; parallel joint: constrains a body's
+ * rotation to match another's, e.g. for parallel linkages) that aren't used
+ * by `Box3DPlugin` -- Babylon's V2 physics API has no equivalent constraint
+ * type to wrap any of them in, so they're absent from `box3d-wasm.d.ts`.
+ * Consumers that want them access box3d directly through
+ * `Box3DPlugin.world` (bypassing the `IPhysicsEnginePluginV2` abstraction)
+ * and this augments the base declaration with the missing surface.
+ * Verified present by instantiating the compiled `box3d-wasm@0.2.0` binary
+ * and inspecting the live prototypes (`Object.getOwnPropertyNames`) --
+ * upstream ships no types at all, so nothing here is derived from a
+ * declaration file that could be stale.
+ */
+declare module 'box3d-wasm' {
+  export interface WheelJointOptions extends JointBaseOptions {
+    enableSuspensionSpring?: boolean;
+    suspensionHertz?: number;
+    suspensionDampingRatio?: number;
+    enableSuspensionLimit?: boolean;
+    lowerSuspensionLimit?: number;
+    upperSuspensionLimit?: number;
+    enableSpinMotor?: boolean;
+    maxSpinTorque?: number;
+    spinMotorSpeed?: number;
+    enableSteering?: boolean;
+    steeringHertz?: number;
+    steeringDampingRatio?: number;
+    maxSteeringTorque?: number;
+    enableSteeringLimit?: boolean;
+    lowerSteeringLimit?: number;
+    upperSteeringLimit?: number;
+    targetSteeringAngle?: number;
+  }
+
+  export class WheelJoint extends Joint {
+    getSpinSpeed(): number;
+    enableSpinMotor(flag: boolean): void;
+    setSpinMotorSpeed(speed: number): void;
+    setMaxSpinTorque(torque: number): void;
+    getSteeringAngle(): number;
+    enableSteering(flag: boolean): void;
+    setTargetSteeringAngle(angle: number): void;
+    enableSteeringLimit(flag: boolean): void;
+    setSteeringLimits(lower: number, upper: number): void;
+    setMaxSteeringTorque(torque: number): void;
+    setSteeringHertz(hertz: number): void;
+    setSteeringDampingRatio(ratio: number): void;
+    enableSuspension(flag: boolean): void;
+    enableSuspensionLimit(flag: boolean): void;
+    setSuspensionLimits(lower: number, upper: number): void;
+    setSuspensionHertz(hertz: number): void;
+    setSuspensionDampingRatio(ratio: number): void;
+  }
+
+  export type FilterJointOptions = JointBaseOptions;
+
+  export class FilterJoint extends Joint {}
+
+  export interface ParallelJointOptions extends JointBaseOptions {
+    enableSpring?: boolean;
+    hertz?: number;
+    dampingRatio?: number;
+    maxTorque?: number;
+  }
+
+  export class ParallelJoint extends Joint {
+    setMaxTorque(torque: number): void;
+    setSpringHertz(hertz: number): void;
+    setSpringDampingRatio(ratio: number): void;
+  }
+
+  export interface World {
+    createWheelJoint(
+      bodyA: Body,
+      bodyB: Body,
+      options?: WheelJointOptions,
+    ): WheelJoint;
+    createFilterJoint(
+      bodyA: Body,
+      bodyB: Body,
+      options?: FilterJointOptions,
+    ): FilterJoint;
+    createParallelJoint(
+      bodyA: Body,
+      bodyB: Body,
+      options?: ParallelJointOptions,
+    ): ParallelJoint;
+  }
+}
+
+import { IPhysicsEnginePluginV2, Observable, IPhysicsCollisionEvent, IBasePhysicsCollisionEvent, Vector3, PhysicsBody, PhysicsMotionType, Quaternion, Mesh, TransformNode, Nullable, PhysicsShape, PhysicsShapeType, PhysicsMassProperties, PhysicsConstraint, PhysicsShapeParameters, PhysicsMaterial, BoundingBox, PhysicsConstraintAxis, PhysicsConstraintAxisLimitMode, PhysicsConstraintMotorType, ConstrainedBodyPair, PhysicsRaycastResult, IRaycastQuery } from '@babylonjs/core';
+import { World, Box3DModule } from 'box3d-wasm';
+
+/**
+ * Babylon.js Physics V2 plugin backed by {@link https://github.com/monteslu/box3d-wasm | box3d-wasm}.
+ *
+ * Modeled after `@babylonjs/core`'s `HavokPlugin` (same file layout as
+ * `Physics/v2/Plugins/havokPlugin.ts`), adapted to the narrower API surface
+ * that box3d-wasm's embind bindings expose. See the package README for a
+ * summary of what isn't (fully) supported.
+ */
+declare class Box3DPlugin implements IPhysicsEnginePluginV2 {
+    world: World;
+    name: string;
+    onCollisionObservable: Observable<IPhysicsCollisionEvent>;
+    onCollisionEndedObservable: Observable<IBasePhysicsCollisionEvent>;
+    onTriggerCollisionObservable: Observable<IBasePhysicsCollisionEvent>;
+    private _timeStep;
+    private _subStepCount;
+    private _maxLinearVelocity;
+    private _maxAngularVelocity;
+    private readonly _bodies;
+    private readonly _shapeOwners;
+    private _warnedAboutInstancing;
+    /**
+     * @param box3d - The resolved box3d-wasm module, e.g. `await Box3D()`.
+     * @param worldOptions - Forwarded to box3d-wasm's `World` constructor (gravity, sleep, continuous collision, thread count, ...).
+     */
+    constructor(box3d: Box3DModule, worldOptions?: ConstructorParameters<Box3DModule['World']>[0]);
+    setGravity(gravity: Vector3): void;
+    setTimeStep(timeStep: number): void;
+    getTimeStep(): number;
+    /** Number of box3d solver sub-steps per `executeStep` call. Defaults to 4, matching box3d's own samples. */
+    setSubStepCount(subStepCount: number): void;
+    getPluginVersion(): number;
+    setVelocityLimits(maxLinearVelocity: number, maxAngularVelocity: number): void;
+    getMaxLinearVelocity(): number;
+    getMaxAngularVelocity(): number;
+    executeStep(delta: number, bodies: Array<PhysicsBody>): void;
+    private _clampLinearVelocities;
+    /** Pushes kinematic/animated transform-node motion into box3d before stepping. Dynamic bodies are driven by the solver and skip this. */
+    private _prestep;
+    initBody(body: PhysicsBody, motionType: PhysicsMotionType, position: Vector3, orientation: Quaternion): void;
+    initBodyInstances(body: PhysicsBody, motionType: PhysicsMotionType, mesh: Mesh): void;
+    updateBodyInstances(_body: PhysicsBody, _mesh: Mesh): void;
+    removeBody(body: PhysicsBody): void;
+    sync(body: PhysicsBody): void;
+    syncTransform(body: PhysicsBody, transformNode: TransformNode): void;
+    setShape(body: PhysicsBody, shape: Nullable<PhysicsShape>): void;
+    getShape(body: PhysicsBody): Nullable<PhysicsShape>;
+    getShapeType(shape: PhysicsShape): PhysicsShapeType;
+    setEventMask(body: PhysicsBody, eventMask: number): void;
+    getEventMask(body: PhysicsBody): number;
+    setMotionType(body: PhysicsBody, motionType: PhysicsMotionType): void;
+    getMotionType(body: PhysicsBody): PhysicsMotionType;
+    computeMassProperties(body: PhysicsBody): PhysicsMassProperties;
+    setMassProperties(body: PhysicsBody, massProps: PhysicsMassProperties): void;
+    getMassProperties(body: PhysicsBody): PhysicsMassProperties;
+    setLinearDamping(body: PhysicsBody, damping: number): void;
+    getLinearDamping(body: PhysicsBody): number;
+    setAngularDamping(body: PhysicsBody, damping: number): void;
+    getAngularDamping(body: PhysicsBody): number;
+    setLinearVelocity(body: PhysicsBody, linVel: Vector3): void;
+    getLinearVelocityToRef(body: PhysicsBody, linVel: Vector3): void;
+    applyImpulse(body: PhysicsBody, impulse: Vector3, location: Vector3): void;
+    applyAngularImpulse(body: PhysicsBody, angularImpulse: Vector3): void;
+    applyForce(body: PhysicsBody, force: Vector3, location: Vector3): void;
+    applyTorque(body: PhysicsBody, torque: Vector3): void;
+    setAngularVelocity(body: PhysicsBody, angVel: Vector3): void;
+    getAngularVelocityToRef(body: PhysicsBody, angVel: Vector3): void;
+    getBodyGeometry(_body: PhysicsBody): object;
+    disposeBody(body: PhysicsBody): void;
+    setCollisionCallbackEnabled(body: PhysicsBody, enabled: boolean): void;
+    setCollisionEndedCallbackEnabled(body: PhysicsBody, enabled: boolean): void;
+    addConstraint(body: PhysicsBody, childBody: PhysicsBody, constraint: PhysicsConstraint): void;
+    getCollisionObservable(body: PhysicsBody): Observable<IPhysicsCollisionEvent>;
+    getCollisionEndedObservable(body: PhysicsBody): Observable<IBasePhysicsCollisionEvent>;
+    setGravityFactor(body: PhysicsBody, factor: number): void;
+    getGravityFactor(body: PhysicsBody): number;
+    setTargetTransform(body: PhysicsBody, position: Vector3, rotation: Quaternion): void;
+    private _getPluginData;
+    private _destroyAttachments;
+    initShape(shape: PhysicsShape, type: PhysicsShapeType, options: PhysicsShapeParameters): void;
+    setShapeFilterMembershipMask(shape: PhysicsShape, membershipMask: number): void;
+    getShapeFilterMembershipMask(shape: PhysicsShape): number;
+    setShapeFilterCollideMask(shape: PhysicsShape, collideMask: number): void;
+    getShapeFilterCollideMask(shape: PhysicsShape): number;
+    setMaterial(shape: PhysicsShape, material: PhysicsMaterial): void;
+    getMaterial(shape: PhysicsShape): PhysicsMaterial;
+    setDensity(shape: PhysicsShape, density: number): void;
+    getDensity(shape: PhysicsShape): number;
+    addChild(shape: PhysicsShape, newChild: PhysicsShape, translation?: Vector3, rotation?: Quaternion, scale?: Vector3): void;
+    removeChild(shape: PhysicsShape, childIndex: number): void;
+    getNumChildren(shape: PhysicsShape): number;
+    getBoundingBox(shape: PhysicsShape): BoundingBox;
+    getBodyBoundingBox(body: PhysicsBody): BoundingBox;
+    disposeShape(shape: PhysicsShape): void;
+    setTrigger(shape: PhysicsShape, isTrigger: boolean): void;
+    private _getShapeData;
+    private _nativeShapesOf;
+    private _ownersOfShape;
+    /** Re-creates every body's attachment tree that (transitively) references `shape`, e.g. after `addChild`/`removeChild`/`setTrigger`. */
+    private _reattachOwners;
+    private _refreshShapeFilters;
+    /** Recursively creates native box3d shapes for `shape` (and, for CONTAINER shapes, its children) on `bodyData.native`, composing local transforms along the way. */
+    private _attachShape;
+    initConstraint(constraint: PhysicsConstraint, body: PhysicsBody, childBody: PhysicsBody): void;
+    setEnabled(constraint: PhysicsConstraint, isEnabled: boolean): void;
+    getEnabled(constraint: PhysicsConstraint): boolean;
+    setCollisionsEnabled(constraint: PhysicsConstraint, isEnabled: boolean): void;
+    getCollisionsEnabled(constraint: PhysicsConstraint): boolean;
+    setAxisFriction(constraint: PhysicsConstraint, axis: PhysicsConstraintAxis, friction: number): void;
+    getAxisFriction(constraint: PhysicsConstraint, axis: PhysicsConstraintAxis): Nullable<number>;
+    setAxisMode(constraint: PhysicsConstraint, axis: PhysicsConstraintAxis, limitMode: PhysicsConstraintAxisLimitMode): void;
+    getAxisMode(constraint: PhysicsConstraint, axis: PhysicsConstraintAxis): Nullable<PhysicsConstraintAxisLimitMode>;
+    setAxisMinLimit(constraint: PhysicsConstraint, axis: PhysicsConstraintAxis, minLimit: number): void;
+    getAxisMinLimit(constraint: PhysicsConstraint, axis: PhysicsConstraintAxis): Nullable<number>;
+    setAxisMaxLimit(constraint: PhysicsConstraint, axis: PhysicsConstraintAxis, limit: number): void;
+    getAxisMaxLimit(constraint: PhysicsConstraint, axis: PhysicsConstraintAxis): Nullable<number>;
+    setAxisMotorType(constraint: PhysicsConstraint, axis: PhysicsConstraintAxis, motorType: PhysicsConstraintMotorType): void;
+    getAxisMotorType(constraint: PhysicsConstraint, axis: PhysicsConstraintAxis): Nullable<PhysicsConstraintMotorType>;
+    setAxisMotorTarget(constraint: PhysicsConstraint, axis: PhysicsConstraintAxis, target: number): void;
+    getAxisMotorTarget(constraint: PhysicsConstraint, axis: PhysicsConstraintAxis): Nullable<number>;
+    setAxisMotorMaxForce(constraint: PhysicsConstraint, axis: PhysicsConstraintAxis, maxForce: number): void;
+    getAxisMotorMaxForce(constraint: PhysicsConstraint, axis: PhysicsConstraintAxis): Nullable<number>;
+    disposeConstraint(constraint: PhysicsConstraint): void;
+    getBodiesUsingConstraint(constraint: PhysicsConstraint): ConstrainedBodyPair[];
+    private _getConstraintData;
+    raycast(from: Vector3, to: Vector3, result: PhysicsRaycastResult | Array<PhysicsRaycastResult>, query?: IRaycastQuery): void;
+    dispose(): void;
+    private _dispatchEvents;
+    private _notifyCollision;
+    private _notifyCollisionEnded;
+    private _notifyTrigger;
+}
+
+export { Box3DPlugin };