/**
 * @author       Yannick Deubel (https://github.com/yandeu)
 * @copyright    Copyright (c) 2020 Yannick Deubel; Project Url: https://github.com/enable3d/enable3d
 * @license      {@link https://github.com/enable3d/enable3d/blob/master/LICENSE|LGPL-3.0}
 */
import PhysicsBody from '@enable3d/common/dist/physicsBody.js';
import { ExtendedObject3D } from '@enable3d/common/dist/extendedObject3D.js';
export { ExtendedObject3D };
import { ExtendedMesh } from '@enable3d/common/dist/extendedMesh.js';
export { ExtendedMesh };
import { ExtendedGroup } from '@enable3d/common/dist/extendedGroup.js';
export { ExtendedGroup };
import { Events } from '@yandeu/events';
import { Euler, Matrix4, Quaternion, Scene, Vector3 } from 'three';
import Factories from '@enable3d/common/dist/factories.js';
import { CollisionEvents } from './collisionEvents.js';
import DebugDrawer from './debugDrawer.js';
import { PhysicsLoader } from '@enable3d/common/dist/physicsLoader.js';
import DefaultMaterial from '@enable3d/common/dist/defaultMaterial.js';
export { PhysicsLoader };
import * as Types from '@enable3d/common/dist/types.js';
import { AllHitsRaycaster, ClosestRaycaster } from './raycaster/raycaster.js';
export { ClosestRaycaster, AllHitsRaycaster };
export { Types };
export { Clock } from './lib/Clock.js';
declare class AmmoPhysics extends Events {
    scene: Scene | 'headless';
    config: Types.ThreeGraphicsConfig;
    worldTransform: Ammo.btTransform;
    factory: Factories;
    isHeadless: boolean;
    rigidBodies: Array<ExtendedMesh | ExtendedGroup>;
    protected earlierDetectedCollisions: {
        combinedName: string;
        collision: boolean;
    }[];
    protected gravity: {
        x: number;
        y: number;
        z: number;
    };
    protected tmpEuler: Euler;
    protected tmpQuaternion: Quaternion;
    protected tmpVector3: Vector3;
    protected tmpVector3a: Vector3;
    protected tmpMatrix4: Matrix4;
    protected tmpMatrix4a: Matrix4;
    protected tmpBtVector3: Ammo.btVector3;
    protected tmpBtQuaternion: Ammo.btQuaternion;
    physicsWorld: Ammo.btSoftRigidDynamicsWorld;
    protected debugDrawer: DebugDrawer;
    private convexBreaker;
    protected addRigidBody: (threeObject: ExtendedMesh, physicsShape: any, mass: any, pos: any, quat: any) => void;
    private objectsToRemove;
    private numObjectsToRemove;
    protected emptyV3: Vector3;
    protected impactPoint: Vector3;
    protected impactNormal: Vector3;
    protected defaultMaterial: DefaultMaterial;
    private shapes;
    private constraints;
    collisionEvents: CollisionEvents;
    private readonly complexShapes;
    constructor(scene: Scene | 'headless', config?: Types.ThreeGraphicsConfig);
    /** @deprecated Use worldTransform instead of tmpTrans. */
    get tmpTrans(): Ammo.btTransform;
    /** @deprecated Use worldTransform instead of tmpTrans. */
    set tmpTrans(transform: Ammo.btTransform);
    /** Destroys a physics body. */
    destroy(body: ExtendedMesh | ExtendedGroup): void;
    protected setup(): void;
    updateDebugger(): void;
    protected setupPhysicsWorld(): any;
    private createDebrisFromBreakableObject;
    private removeDebris;
    update(delta: number): void;
    private updatePhysics;
    private detectCollisions;
    setGravity(x?: number, y?: number, z?: number): void;
    get debug(): {
        enable: () => void;
        mode: (debugMode?: number) => void;
        disable: () => void;
    } | null;
    private start;
    get add(): {
        collider: (object1: ExtendedMesh, object2: ExtendedMesh, eventCallback: (event: Types.CollisionEvent) => void) => void;
        constraints: {
            lock: (bodyA: PhysicsBody, bodyB: PhysicsBody, disableCollisionsBetweenLinkedBodies?: boolean) => Ammo.btGeneric6DofConstraint;
            fixed: (bodyA: PhysicsBody, bodyB: PhysicsBody, disableCollisionsBetweenLinkedBodies?: boolean) => Ammo.btFixedConstraint;
            pointToPoint: (bodyA: PhysicsBody, bodyB: PhysicsBody, config: {
                pivotA?: Types.XYZ;
                pivotB?: Types.XYZ;
            }, disableCollisionsBetweenLinkedBodies?: boolean) => Ammo.btPoint2PointConstraint;
            hinge: (bodyA: PhysicsBody, bodyB: PhysicsBody, config: {
                pivotA?: Types.XYZ;
                pivotB?: Types.XYZ;
                axisA?: Types.XYZ;
                axisB?: Types.XYZ;
            }, disableCollisionsBetweenLinkedBodies?: boolean) => Ammo.btHingeConstraint;
            slider: (bodyA: PhysicsBody, bodyB: PhysicsBody, config?: {
                frameA?: Types.XYZ;
                frameB?: Types.XYZ;
                linearLowerLimit?: number;
                linearUpperLimit?: number;
                angularLowerLimit?: number;
                angularUpperLimit?: number;
            }, disableCollisionsBetweenLinkedBodies?: boolean) => Ammo.btSliderConstraint;
            spring: (bodyA: PhysicsBody, bodyB: PhysicsBody, config?: {
                stiffness?: number;
                damping?: number;
                angularLock?: boolean;
                linearLowerLimit?: Types.XYZ;
                linearUpperLimit?: Types.XYZ;
                angularLowerLimit?: Types.XYZ;
                angularUpperLimit?: Types.XYZ;
                center?: boolean;
                offset?: Types.XYZ;
                enableSpring?: boolean;
            }, disableCollisionsBetweenLinkedBodies?: boolean) => Ammo.btGeneric6DofSpringConstraint;
            coneTwist: (bodyA: PhysicsBody, bodyB: PhysicsBody, config?: {
                frameA: Types.XYZ;
                frameB: Types.XYZ;
            }, disableCollisionsBetweenLinkedBodies?: boolean) => Ammo.btConeTwistConstraint;
            dof: (bodyA: PhysicsBody, bodyB: PhysicsBody, config?: {
                linearLowerLimit?: Types.XYZ;
                linearUpperLimit?: Types.XYZ;
                angularLowerLimit?: Types.XYZ;
                angularUpperLimit?: Types.XYZ;
                center?: boolean;
                offset?: Types.XYZ;
            } | undefined, disableCollisionsBetweenLinkedBodies?: boolean) => Ammo.btGeneric6DofConstraint;
        };
        existing: (object: ExtendedMesh | ExtendedGroup, config?: Types.AddExistingConfig) => any;
        plane: (planeConfig?: Types.PlaneConfig, materialConfig?: Types.MaterialConfig) => ExtendedMesh;
        sphere: (sphereConfig?: Types.SphereConfig, materialConfig?: Types.MaterialConfig) => ExtendedMesh;
        ground: (groundConfig?: Types.GroundConfig, materialConfig?: Types.MaterialConfig) => ExtendedMesh;
        box: (boxConfig?: Types.BoxConfig, materialConfig?: Types.MaterialConfig) => ExtendedMesh;
        capsule: (capsuleConfig?: Types.CapsuleConfig, materialConfig?: Types.MaterialConfig) => ExtendedMesh;
        cylinder: (cylinderConfig?: Types.CylinderConfig, materialConfig?: Types.MaterialConfig) => ExtendedMesh;
        cone: (coneConfig?: Types.ConeConfig, materialConfig?: Types.MaterialConfig) => ExtendedMesh;
        torus: (torusConfig?: Types.TorusConfig, materialConfig?: Types.MaterialConfig) => ExtendedMesh;
        extrude: (extrudeConfig: Types.ExtrudeConfig, materialConfig?: Types.MaterialConfig) => ExtendedMesh;
        /**
         * Creates a new Raycaster
         * @param type Returns only the closes body by default. Can be 'closest' or 'allHits'.
         */
        raycaster: (type?: string) => ClosestRaycaster | AllHitsRaycaster;
    };
    private prepareThreeObjectForCollisionShape;
    createCollisionShape(shape: string, params: any, object?: ExtendedMesh | ExtendedGroup): Ammo.btCollisionShape;
    mergeCollisionShapesToCompoundShape(collisionShapes: Ammo.btCollisionShape[]): Ammo.btCompoundShape;
    protected addExisting(object: ExtendedMesh | ExtendedGroup, config?: Types.AddExistingConfig): any;
    addRigidBodyToWorld(object: ExtendedMesh | ExtendedGroup, rigidBody: Ammo.btRigidBody, collisionFlags: number, collisionGroup: number, collisionMask: number, offset?: {
        x?: number;
        y?: number;
        z?: number;
    }): void;
    applyPosQuatScaleMargin(collisionShape: Ammo.btCollisionShape, pos?: Vector3, quat?: Quaternion, scale?: Vector3, margin?: number): Ammo.btTransform;
    collisionShapeToRigidBody(collisionShape: Ammo.btCollisionShape, localTransform: Ammo.btTransform, mass: number, disableDeactivation: boolean): Ammo.btRigidBody;
}
export { AmmoPhysics };
//# sourceMappingURL=physics.d.ts.map