@babylonjs/core 5.35.0 → 5.36.0

package/Physics/physicsJoint.js.map

@@ -1 +1 @@
-{"version":3,"file":"physicsJoint.js","sourceRoot":"","sources":["../../../../lts/core/generated/Physics/physicsJoint.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Vector3 } from \"../Maths/math.vector\";\r\nimport type { IPhysicsEnginePlugin } from \"./IPhysicsEngine\";\r\n/**\r\n * Interface for Physics-Joint data\r\n * @see https://doc.babylonjs.com/features/featuresDeepDive/physics/usingPhysicsEngine\r\n */\r\nexport interface PhysicsJointData {\r\n    //Important for some engines, optional!\r\n    /**\r\n     * The main pivot of the joint\r\n     */\r\n    mainPivot?: Vector3;\r\n    /**\r\n     * The connected pivot of the joint\r\n     */\r\n    connectedPivot?: Vector3;\r\n    /**\r\n     * The main axis of the joint\r\n     */\r\n    mainAxis?: Vector3;\r\n    /**\r\n     * The connected axis of the joint\r\n     */\r\n    connectedAxis?: Vector3;\r\n    /**\r\n     * The collision of the joint\r\n     */\r\n    collision?: boolean;\r\n    /**\r\n     * Native Oimo/Cannon/Energy data\r\n     */\r\n    nativeParams?: any;\r\n}\r\n\r\n/**\r\n * This is a holder class for the physics joint created by the physics plugin\r\n * It holds a set of functions to control the underlying joint\r\n * @see https://doc.babylonjs.com/features/featuresDeepDive/physics/usingPhysicsEngine\r\n */\r\nexport class PhysicsJoint {\r\n    private _physicsJoint: any;\r\n    protected _physicsPlugin: IPhysicsEnginePlugin;\r\n\r\n    /**\r\n     * Initializes the physics joint\r\n     * @param type The type of the physics joint\r\n     * @param jointData The data for the physics joint\r\n     */\r\n    constructor(\r\n        /**\r\n         * The type of the physics joint\r\n         */\r\n        public type: number,\r\n        /**\r\n         * The data for the physics joint\r\n         */\r\n        public jointData: PhysicsJointData\r\n    ) {\r\n        jointData.nativeParams = jointData.nativeParams || {};\r\n    }\r\n\r\n    /**\r\n     * Gets the physics joint\r\n     */\r\n    public get physicsJoint(): any {\r\n        return this._physicsJoint;\r\n    }\r\n\r\n    /**\r\n     * Sets the physics joint\r\n     */\r\n    public set physicsJoint(newJoint: any) {\r\n        if (this._physicsJoint) {\r\n            //remove from the world\r\n        }\r\n\r\n        this._physicsJoint = newJoint;\r\n    }\r\n\r\n    /**\r\n     * Sets the physics plugin\r\n     */\r\n    public set physicsPlugin(physicsPlugin: IPhysicsEnginePlugin) {\r\n        this._physicsPlugin = physicsPlugin;\r\n    }\r\n\r\n    /**\r\n     * Execute a function that is physics-plugin specific.\r\n     * @param {Function} func the function that will be executed.\r\n     *                        It accepts two parameters: the physics world and the physics joint\r\n     */\r\n    public executeNativeFunction(func: (world: any, physicsJoint: any) => void) {\r\n        func(this._physicsPlugin.world, this._physicsJoint);\r\n    }\r\n\r\n    //TODO check if the native joints are the same\r\n\r\n    //Joint Types\r\n    /**\r\n     * Distance-Joint type\r\n     */\r\n    public static DistanceJoint = 0;\r\n    /**\r\n     * Hinge-Joint type\r\n     */\r\n    public static HingeJoint = 1;\r\n    /**\r\n     * Ball-and-Socket joint type\r\n     */\r\n    public static BallAndSocketJoint = 2;\r\n    /**\r\n     * Wheel-Joint type\r\n     */\r\n    public static WheelJoint = 3;\r\n    /**\r\n     * Slider-Joint type\r\n     */\r\n    public static SliderJoint = 4;\r\n    //OIMO\r\n    /**\r\n     * Prismatic-Joint type\r\n     */\r\n    public static PrismaticJoint = 5;\r\n    //\r\n    /**\r\n     * Universal-Joint type\r\n     * ENERGY FTW! (compare with this - @see http://ode-wiki.org/wiki/index.php?title=Manual:_Joint_Types_and_Functions)\r\n     */\r\n    public static UniversalJoint = 6;\r\n    /**\r\n     * Hinge-Joint 2 type\r\n     */\r\n    public static Hinge2Joint = PhysicsJoint.WheelJoint;\r\n    //Cannon\r\n    /**\r\n     * Point to Point Joint type.  Similar to a Ball-Joint.  Different in parameters\r\n     */\r\n    public static PointToPointJoint = 8;\r\n    //Cannon only at the moment\r\n    /**\r\n     * Spring-Joint type\r\n     */\r\n    public static SpringJoint = 9;\r\n    /**\r\n     * Lock-Joint type\r\n     */\r\n    public static LockJoint = 10;\r\n}\r\n\r\n/**\r\n * A class representing a physics distance joint\r\n * @see https://doc.babylonjs.com/features/featuresDeepDive/physics/usingPhysicsEngine\r\n */\r\nexport class DistanceJoint extends PhysicsJoint {\r\n    /**\r\n     *\r\n     * @param jointData The data for the Distance-Joint\r\n     */\r\n    constructor(jointData: DistanceJointData) {\r\n        super(PhysicsJoint.DistanceJoint, jointData);\r\n    }\r\n\r\n    /**\r\n     * Update the predefined distance.\r\n     * @param maxDistance The maximum preferred distance\r\n     * @param minDistance The minimum preferred distance\r\n     */\r\n    public updateDistance(maxDistance: number, minDistance?: number) {\r\n        this._physicsPlugin.updateDistanceJoint(this, maxDistance, minDistance);\r\n    }\r\n}\r\n\r\n/**\r\n * Represents a Motor-Enabled Joint\r\n * @see https://doc.babylonjs.com/features/featuresDeepDive/physics/usingPhysicsEngine\r\n */\r\nexport class MotorEnabledJoint extends PhysicsJoint implements IMotorEnabledJoint {\r\n    /**\r\n     * Initializes the Motor-Enabled Joint\r\n     * @param type The type of the joint\r\n     * @param jointData The physical joint data for the joint\r\n     */\r\n    constructor(type: number, jointData: PhysicsJointData) {\r\n        super(type, jointData);\r\n    }\r\n\r\n    /**\r\n     * Set the motor values.\r\n     * Attention, this function is plugin specific. Engines won't react 100% the same.\r\n     * @param force the force to apply\r\n     * @param maxForce max force for this motor.\r\n     */\r\n    public setMotor(force?: number, maxForce?: number) {\r\n        this._physicsPlugin.setMotor(this, force || 0, maxForce);\r\n    }\r\n\r\n    /**\r\n     * Set the motor's limits.\r\n     * Attention, this function is plugin specific. Engines won't react 100% the same.\r\n     * @param upperLimit The upper limit of the motor\r\n     * @param lowerLimit The lower limit of the motor\r\n     */\r\n    public setLimit(upperLimit: number, lowerLimit?: number) {\r\n        this._physicsPlugin.setLimit(this, upperLimit, lowerLimit);\r\n    }\r\n}\r\n\r\n/**\r\n * This class represents a single physics Hinge-Joint\r\n * @see https://doc.babylonjs.com/features/featuresDeepDive/physics/usingPhysicsEngine\r\n */\r\nexport class HingeJoint extends MotorEnabledJoint {\r\n    /**\r\n     * Initializes the Hinge-Joint\r\n     * @param jointData The joint data for the Hinge-Joint\r\n     */\r\n    constructor(jointData: PhysicsJointData) {\r\n        super(PhysicsJoint.HingeJoint, jointData);\r\n    }\r\n\r\n    /**\r\n     * Set the motor values.\r\n     * Attention, this function is plugin specific. Engines won't react 100% the same.\r\n     * @param {number} force the force to apply\r\n     * @param {number} maxForce max force for this motor.\r\n     */\r\n    public setMotor(force?: number, maxForce?: number) {\r\n        this._physicsPlugin.setMotor(this, force || 0, maxForce);\r\n    }\r\n\r\n    /**\r\n     * Set the motor's limits.\r\n     * Attention, this function is plugin specific. Engines won't react 100% the same.\r\n     * @param upperLimit The upper limit of the motor\r\n     * @param lowerLimit The lower limit of the motor\r\n     */\r\n    public setLimit(upperLimit: number, lowerLimit?: number) {\r\n        this._physicsPlugin.setLimit(this, upperLimit, lowerLimit);\r\n    }\r\n}\r\n\r\n/**\r\n * This class represents a dual hinge physics joint (same as wheel joint)\r\n * @see https://doc.babylonjs.com/features/featuresDeepDive/physics/usingPhysicsEngine\r\n */\r\nexport class Hinge2Joint extends MotorEnabledJoint {\r\n    /**\r\n     * Initializes the Hinge2-Joint\r\n     * @param jointData The joint data for the Hinge2-Joint\r\n     */\r\n    constructor(jointData: PhysicsJointData) {\r\n        super(PhysicsJoint.Hinge2Joint, jointData);\r\n    }\r\n\r\n    /**\r\n     * Set the motor values.\r\n     * Attention, this function is plugin specific. Engines won't react 100% the same.\r\n     * @param targetSpeed the speed the motor is to reach\r\n     * @param maxForce max force for this motor.\r\n     * @param motorIndex motor's index, 0 or 1.\r\n     */\r\n    public setMotor(targetSpeed?: number, maxForce?: number, motorIndex: number = 0) {\r\n        this._physicsPlugin.setMotor(this, targetSpeed || 0, maxForce, motorIndex);\r\n    }\r\n\r\n    /**\r\n     * Set the motor limits.\r\n     * Attention, this function is plugin specific. Engines won't react 100% the same.\r\n     * @param upperLimit the upper limit\r\n     * @param lowerLimit lower limit\r\n     * @param motorIndex the motor's index, 0 or 1.\r\n     */\r\n    public setLimit(upperLimit: number, lowerLimit?: number, motorIndex: number = 0) {\r\n        this._physicsPlugin.setLimit(this, upperLimit, lowerLimit, motorIndex);\r\n    }\r\n}\r\n\r\n/**\r\n * Interface for a motor enabled joint\r\n * @see https://doc.babylonjs.com/features/featuresDeepDive/physics/usingPhysicsEngine\r\n */\r\nexport interface IMotorEnabledJoint {\r\n    /**\r\n     * Physics joint\r\n     */\r\n    physicsJoint: any;\r\n    /**\r\n     * Sets the motor of the motor-enabled joint\r\n     * @param force The force of the motor\r\n     * @param maxForce The maximum force of the motor\r\n     * @param motorIndex The index of the motor\r\n     */\r\n    setMotor(force?: number, maxForce?: number, motorIndex?: number): void;\r\n    /**\r\n     * Sets the limit of the motor\r\n     * @param upperLimit The upper limit of the motor\r\n     * @param lowerLimit The lower limit of the motor\r\n     * @param motorIndex The index of the motor\r\n     */\r\n    setLimit(upperLimit: number, lowerLimit?: number, motorIndex?: number): void;\r\n}\r\n\r\n/**\r\n * Joint data for a Distance-Joint\r\n * @see https://doc.babylonjs.com/features/featuresDeepDive/physics/usingPhysicsEngine\r\n */\r\nexport interface DistanceJointData extends PhysicsJointData {\r\n    /**\r\n     * Max distance the 2 joint objects can be apart\r\n     */\r\n    maxDistance: number;\r\n    //Oimo - minDistance\r\n    //Cannon - maxForce\r\n}\r\n\r\n/**\r\n * Joint data from a spring joint\r\n * @see https://doc.babylonjs.com/features/featuresDeepDive/physics/usingPhysicsEngine\r\n */\r\nexport interface SpringJointData extends PhysicsJointData {\r\n    /**\r\n     * Length of the spring\r\n     */\r\n    length: number;\r\n    /**\r\n     * Stiffness of the spring\r\n     */\r\n    stiffness: number;\r\n    /**\r\n     * Damping of the spring\r\n     */\r\n    damping: number;\r\n    /** this callback will be called when applying the force to the impostors. */\r\n    forceApplicationCallback: () => void;\r\n}\r\n"]}
+{"version":3,"file":"physicsJoint.js","sourceRoot":"","sources":["../../../../lts/core/generated/Physics/physicsJoint.ts"],"names":[],"mappings":"AAAA,qBAAqB;AACrB,cAAc,mBAAmB,CAAC","sourcesContent":["// ES 6 Compatibility\r\nexport * from \"./v1/physicsJoint\";\r\n"]}

package/Physics/v1/IPhysicsEnginePlugin.d.ts

@@ -0,0 +1,73 @@
+import type { Nullable } from "../../types";
+import type { Vector3, Quaternion } from "../../Maths/math.vector";
+import type { AbstractMesh } from "../../Meshes/abstractMesh";
+import type { PhysicsImpostor } from "./physicsImpostor";
+import type { PhysicsJoint, IMotorEnabledJoint } from "./physicsJoint";
+import type { PhysicsRaycastResult } from "../physicsRaycastResult";
+/**
+ * Interface used to describe a physics joint
+ */
+export interface PhysicsImpostorJoint {
+    /** Defines the main impostor to which the joint is linked */
+    mainImpostor: PhysicsImpostor;
+    /** Defines the impostor that is connected to the main impostor using this joint */
+    connectedImpostor: PhysicsImpostor;
+    /** Defines the joint itself */
+    joint: PhysicsJoint;
+}
+/** @internal */
+export interface IPhysicsEnginePlugin {
+    /**
+     *
+     */
+    world: any;
+    /**
+     *
+     */
+    name: string;
+    setGravity(gravity: Vector3): void;
+    setTimeStep(timeStep: number): void;
+    getTimeStep(): number;
+    executeStep(delta: number, impostors: Array<PhysicsImpostor>): void;
+    getPluginVersion(): number;
+    applyImpulse(impostor: PhysicsImpostor, force: Vector3, contactPoint: Vector3): void;
+    applyForce(impostor: PhysicsImpostor, force: Vector3, contactPoint: Vector3): void;
+    generatePhysicsBody(impostor: PhysicsImpostor): void;
+    removePhysicsBody(impostor: PhysicsImpostor): void;
+    generateJoint(joint: PhysicsImpostorJoint): void;
+    removeJoint(joint: PhysicsImpostorJoint): void;
+    isSupported(): boolean;
+    setTransformationFromPhysicsBody(impostor: PhysicsImpostor): void;
+    setPhysicsBodyTransformation(impostor: PhysicsImpostor, newPosition: Vector3, newRotation: Quaternion): void;
+    setLinearVelocity(impostor: PhysicsImpostor, velocity: Nullable<Vector3>): void;
+    setAngularVelocity(impostor: PhysicsImpostor, velocity: Nullable<Vector3>): void;
+    getLinearVelocity(impostor: PhysicsImpostor): Nullable<Vector3>;
+    getAngularVelocity(impostor: PhysicsImpostor): Nullable<Vector3>;
+    setBodyMass(impostor: PhysicsImpostor, mass: number): void;
+    getBodyMass(impostor: PhysicsImpostor): number;
+    getBodyFriction(impostor: PhysicsImpostor): number;
+    setBodyFriction(impostor: PhysicsImpostor, friction: number): void;
+    getBodyRestitution(impostor: PhysicsImpostor): number;
+    setBodyRestitution(impostor: PhysicsImpostor, restitution: number): void;
+    getBodyPressure?(impostor: PhysicsImpostor): number;
+    setBodyPressure?(impostor: PhysicsImpostor, pressure: number): void;
+    getBodyStiffness?(impostor: PhysicsImpostor): number;
+    setBodyStiffness?(impostor: PhysicsImpostor, stiffness: number): void;
+    getBodyVelocityIterations?(impostor: PhysicsImpostor): number;
+    setBodyVelocityIterations?(impostor: PhysicsImpostor, velocityIterations: number): void;
+    getBodyPositionIterations?(impostor: PhysicsImpostor): number;
+    setBodyPositionIterations?(impostor: PhysicsImpostor, positionIterations: number): void;
+    appendAnchor?(impostor: PhysicsImpostor, otherImpostor: PhysicsImpostor, width: number, height: number, influence: number, noCollisionBetweenLinkedBodies: boolean): void;
+    appendHook?(impostor: PhysicsImpostor, otherImpostor: PhysicsImpostor, length: number, influence: number, noCollisionBetweenLinkedBodies: boolean): void;
+    sleepBody(impostor: PhysicsImpostor): void;
+    wakeUpBody(impostor: PhysicsImpostor): void;
+    raycast(from: Vector3, to: Vector3): PhysicsRaycastResult;
+    raycastToRef(from: Vector3, to: Vector3, result: PhysicsRaycastResult): void;
+    updateDistanceJoint(joint: PhysicsJoint, maxDistance: number, minDistance?: number): void;
+    setMotor(joint: IMotorEnabledJoint, speed: number, maxForce?: number, motorIndex?: number): void;
+    setLimit(joint: IMotorEnabledJoint, upperLimit: number, lowerLimit?: number, motorIndex?: number): void;
+    getRadius(impostor: PhysicsImpostor): number;
+    getBoxSizeToRef(impostor: PhysicsImpostor, result: Vector3): void;
+    syncMeshWithImpostor(mesh: AbstractMesh, impostor: PhysicsImpostor): void;
+    dispose(): void;
+}

package/Physics/v1/IPhysicsEnginePlugin.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=IPhysicsEnginePlugin.js.map

package/Physics/v1/IPhysicsEnginePlugin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IPhysicsEnginePlugin.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Physics/v1/IPhysicsEnginePlugin.ts"],"names":[],"mappings":"","sourcesContent":["import type { Nullable } from \"../../types\";\r\nimport type { Vector3, Quaternion } from \"../../Maths/math.vector\";\r\nimport type { AbstractMesh } from \"../../Meshes/abstractMesh\";\r\nimport type { PhysicsImpostor } from \"./physicsImpostor\";\r\nimport type { PhysicsJoint, IMotorEnabledJoint } from \"./physicsJoint\";\r\nimport type { PhysicsRaycastResult } from \"../physicsRaycastResult\";\r\n\r\n/**\r\n * Interface used to describe a physics joint\r\n */\r\nexport interface PhysicsImpostorJoint {\r\n    /** Defines the main impostor to which the joint is linked */\r\n    mainImpostor: PhysicsImpostor;\r\n    /** Defines the impostor that is connected to the main impostor using this joint */\r\n    connectedImpostor: PhysicsImpostor;\r\n    /** Defines the joint itself */\r\n    joint: PhysicsJoint;\r\n}\r\n\r\n/** @internal */\r\nexport interface IPhysicsEnginePlugin {\r\n    /**\r\n     *\r\n     */\r\n    world: any;\r\n    /**\r\n     *\r\n     */\r\n    name: string;\r\n    setGravity(gravity: Vector3): void;\r\n    setTimeStep(timeStep: number): void;\r\n    getTimeStep(): number;\r\n    executeStep(delta: number, impostors: Array<PhysicsImpostor>): void; //not forgetting pre and post events\r\n    getPluginVersion(): number;\r\n    applyImpulse(impostor: PhysicsImpostor, force: Vector3, contactPoint: Vector3): void;\r\n    applyForce(impostor: PhysicsImpostor, force: Vector3, contactPoint: Vector3): void;\r\n    generatePhysicsBody(impostor: PhysicsImpostor): void;\r\n    removePhysicsBody(impostor: PhysicsImpostor): void;\r\n    generateJoint(joint: PhysicsImpostorJoint): void;\r\n    removeJoint(joint: PhysicsImpostorJoint): void;\r\n    isSupported(): boolean;\r\n    setTransformationFromPhysicsBody(impostor: PhysicsImpostor): void;\r\n    setPhysicsBodyTransformation(impostor: PhysicsImpostor, newPosition: Vector3, newRotation: Quaternion): void;\r\n    setLinearVelocity(impostor: PhysicsImpostor, velocity: Nullable<Vector3>): void;\r\n    setAngularVelocity(impostor: PhysicsImpostor, velocity: Nullable<Vector3>): void;\r\n    getLinearVelocity(impostor: PhysicsImpostor): Nullable<Vector3>;\r\n    getAngularVelocity(impostor: PhysicsImpostor): Nullable<Vector3>;\r\n    setBodyMass(impostor: PhysicsImpostor, mass: number): void;\r\n    getBodyMass(impostor: PhysicsImpostor): number;\r\n    getBodyFriction(impostor: PhysicsImpostor): number;\r\n    setBodyFriction(impostor: PhysicsImpostor, friction: number): void;\r\n    getBodyRestitution(impostor: PhysicsImpostor): number;\r\n    setBodyRestitution(impostor: PhysicsImpostor, restitution: number): void;\r\n    getBodyPressure?(impostor: PhysicsImpostor): number;\r\n    setBodyPressure?(impostor: PhysicsImpostor, pressure: number): void;\r\n    getBodyStiffness?(impostor: PhysicsImpostor): number;\r\n    setBodyStiffness?(impostor: PhysicsImpostor, stiffness: number): void;\r\n    getBodyVelocityIterations?(impostor: PhysicsImpostor): number;\r\n    setBodyVelocityIterations?(impostor: PhysicsImpostor, velocityIterations: number): void;\r\n    getBodyPositionIterations?(impostor: PhysicsImpostor): number;\r\n    setBodyPositionIterations?(impostor: PhysicsImpostor, positionIterations: number): void;\r\n    appendAnchor?(impostor: PhysicsImpostor, otherImpostor: PhysicsImpostor, width: number, height: number, influence: number, noCollisionBetweenLinkedBodies: boolean): void;\r\n    appendHook?(impostor: PhysicsImpostor, otherImpostor: PhysicsImpostor, length: number, influence: number, noCollisionBetweenLinkedBodies: boolean): void;\r\n    sleepBody(impostor: PhysicsImpostor): void;\r\n    wakeUpBody(impostor: PhysicsImpostor): void;\r\n    raycast(from: Vector3, to: Vector3): PhysicsRaycastResult;\r\n    raycastToRef(from: Vector3, to: Vector3, result: PhysicsRaycastResult): void;\r\n\r\n    //Joint Update\r\n    updateDistanceJoint(joint: PhysicsJoint, maxDistance: number, minDistance?: number): void;\r\n    setMotor(joint: IMotorEnabledJoint, speed: number, maxForce?: number, motorIndex?: number): void;\r\n    setLimit(joint: IMotorEnabledJoint, upperLimit: number, lowerLimit?: number, motorIndex?: number): void;\r\n    getRadius(impostor: PhysicsImpostor): number;\r\n    getBoxSizeToRef(impostor: PhysicsImpostor, result: Vector3): void;\r\n    syncMeshWithImpostor(mesh: AbstractMesh, impostor: PhysicsImpostor): void;\r\n    dispose(): void;\r\n}\r\n"]}

package/Physics/v1/Plugins/ammoJSPlugin.d.ts

@@ -0,0 +1,401 @@
+import { Quaternion, Vector3 } from "../../../Maths/math.vector";
+import type { IPhysicsEnginePlugin, PhysicsImpostorJoint } from "../IPhysicsEnginePlugin";
+import { PhysicsImpostor } from "../physicsImpostor";
+import type { IMotorEnabledJoint } from "..//physicsJoint";
+import type { Nullable } from "../../../types";
+import type { AbstractMesh } from "../../../Meshes/abstractMesh";
+import { PhysicsRaycastResult } from "../../physicsRaycastResult";
+/**
+ * AmmoJS Physics plugin
+ * @see https://doc.babylonjs.com/features/featuresDeepDive/physics/usingPhysicsEngine
+ * @see https://github.com/kripken/ammo.js/
+ */
+export declare class AmmoJSPlugin implements IPhysicsEnginePlugin {
+    private _useDeltaForWorldStep;
+    /**
+     * Reference to the Ammo library
+     */
+    bjsAMMO: any;
+    /**
+     * Created ammoJS world which physics bodies are added to
+     */
+    world: any;
+    /**
+     * Name of the plugin
+     */
+    name: string;
+    private _timeStep;
+    private _fixedTimeStep;
+    private _maxSteps;
+    private _tmpQuaternion;
+    private _tmpAmmoTransform;
+    private _tmpAmmoQuaternion;
+    private _tmpAmmoConcreteContactResultCallback;
+    private _collisionConfiguration;
+    private _dispatcher;
+    private _overlappingPairCache;
+    private _solver;
+    private _softBodySolver;
+    private _tmpAmmoVectorA;
+    private _tmpAmmoVectorB;
+    private _tmpAmmoVectorC;
+    private _tmpAmmoVectorD;
+    private _tmpContactCallbackResult;
+    private _tmpAmmoVectorRCA;
+    private _tmpAmmoVectorRCB;
+    private _raycastResult;
+    private _tmpContactPoint;
+    private _tmpContactNormal;
+    private _tmpContactDistance;
+    private _tmpContactImpulse;
+    private _tmpVec3;
+    private static readonly _DISABLE_COLLISION_FLAG;
+    private static readonly _KINEMATIC_FLAG;
+    private static readonly _DISABLE_DEACTIVATION_FLAG;
+    /**
+     * Initializes the ammoJS plugin
+     * @param _useDeltaForWorldStep if the time between frames should be used when calculating physics steps (Default: true)
+     * @param ammoInjection can be used to inject your own ammo reference
+     * @param overlappingPairCache can be used to specify your own overlapping pair cache
+     */
+    constructor(_useDeltaForWorldStep?: boolean, ammoInjection?: any, overlappingPairCache?: any);
+    /**
+     *
+     * @returns plugin version
+     */
+    getPluginVersion(): number;
+    /**
+     * Sets the gravity of the physics world (m/(s^2))
+     * @param gravity Gravity to set
+     */
+    setGravity(gravity: Vector3): void;
+    /**
+     * Amount of time to step forward on each frame (only used if useDeltaForWorldStep is false in the constructor)
+     * @param timeStep timestep to use in seconds
+     */
+    setTimeStep(timeStep: number): void;
+    /**
+     * Increment to step forward in the physics engine (If timeStep is set to 1/60 and fixedTimeStep is set to 1/120 the physics engine should run 2 steps per frame) (Default: 1/60)
+     * @param fixedTimeStep fixedTimeStep to use in seconds
+     */
+    setFixedTimeStep(fixedTimeStep: number): void;
+    /**
+     * Sets the maximum number of steps by the physics engine per frame (Default: 5)
+     * @param maxSteps the maximum number of steps by the physics engine per frame
+     */
+    setMaxSteps(maxSteps: number): void;
+    /**
+     * Gets the current timestep (only used if useDeltaForWorldStep is false in the constructor)
+     * @returns the current timestep in seconds
+     */
+    getTimeStep(): number;
+    /**
+     * The create custom shape handler function to be called when using BABYLON.PhysicsImposter.CustomImpostor
+     */
+    onCreateCustomShape: (impostor: PhysicsImpostor) => any;
+    /**
+     * The create custom mesh impostor handler function to support building custom mesh impostor vertex data
+     */
+    onCreateCustomMeshImpostor: (impostor: PhysicsImpostor) => any;
+    /**
+     * The create custom convex hull impostor handler function to support building custom convex hull impostor vertex data
+     */
+    onCreateCustomConvexHullImpostor: (impostor: PhysicsImpostor) => any;
+    private _isImpostorInContact;
+    private _isImpostorPairInContact;
+    private _stepSimulation;
+    /**
+     * Moves the physics simulation forward delta seconds and updates the given physics imposters
+     * Prior to the step the imposters physics location is set to the position of the babylon meshes
+     * After the step the babylon meshes are set to the position of the physics imposters
+     * @param delta amount of time to step forward
+     * @param impostors array of imposters to update before/after the step
+     */
+    executeStep(delta: number, impostors: Array<PhysicsImpostor>): void;
+    /**
+     * Update babylon mesh to match physics world object
+     * @param impostor imposter to match
+     */
+    private _afterSoftStep;
+    /**
+     * Update babylon mesh vertices vertices to match physics world softbody or cloth
+     * @param impostor imposter to match
+     */
+    private _ropeStep;
+    /**
+     * Update babylon mesh vertices vertices to match physics world softbody or cloth
+     * @param impostor imposter to match
+     */
+    private _softbodyOrClothStep;
+    private _tmpMatrix;
+    /**
+     * Applies an impulse on the imposter
+     * @param impostor imposter to apply impulse to
+     * @param force amount of force to be applied to the imposter
+     * @param contactPoint the location to apply the impulse on the imposter
+     */
+    applyImpulse(impostor: PhysicsImpostor, force: Vector3, contactPoint: Vector3): void;
+    /**
+     * Applies a force on the imposter
+     * @param impostor imposter to apply force
+     * @param force amount of force to be applied to the imposter
+     * @param contactPoint the location to apply the force on the imposter
+     */
+    applyForce(impostor: PhysicsImpostor, force: Vector3, contactPoint: Vector3): void;
+    /**
+     * Creates a physics body using the plugin
+     * @param impostor the imposter to create the physics body on
+     */
+    generatePhysicsBody(impostor: PhysicsImpostor): void;
+    /**
+     * Removes the physics body from the imposter and disposes of the body's memory
+     * @param impostor imposter to remove the physics body from
+     */
+    removePhysicsBody(impostor: PhysicsImpostor): void;
+    /**
+     * Generates a joint
+     * @param impostorJoint the imposter joint to create the joint with
+     */
+    generateJoint(impostorJoint: PhysicsImpostorJoint): void;
+    /**
+     * Removes a joint
+     * @param impostorJoint the imposter joint to remove the joint from
+     */
+    removeJoint(impostorJoint: PhysicsImpostorJoint): void;
+    private _addMeshVerts;
+    /**
+     * Initialise the soft body vertices to match its object's (mesh) vertices
+     * Softbody vertices (nodes) are in world space and to match this
+     * The object's position and rotation is set to zero and so its vertices are also then set in world space
+     * @param impostor to create the softbody for
+     */
+    private _softVertexData;
+    /**
+     * Create an impostor's soft body
+     * @param impostor to create the softbody for
+     */
+    private _createSoftbody;
+    /**
+     * Create cloth for an impostor
+     * @param impostor to create the softbody for
+     */
+    private _createCloth;
+    /**
+     * Create rope for an impostor
+     * @param impostor to create the softbody for
+     */
+    private _createRope;
+    /**
+     * Create a custom physics impostor shape using the plugin's onCreateCustomShape handler
+     * @param impostor to create the custom physics shape for
+     */
+    private _createCustom;
+    private _addHullVerts;
+    private _createShape;
+    /**
+     * Sets the mesh body position/rotation from the babylon impostor
+     * @param impostor imposter containing the physics body and babylon object
+     */
+    setTransformationFromPhysicsBody(impostor: PhysicsImpostor): void;
+    /**
+     * Sets the babylon object's position/rotation from the physics body's position/rotation
+     * @param impostor imposter containing the physics body and babylon object
+     * @param newPosition new position
+     * @param newRotation new rotation
+     */
+    setPhysicsBodyTransformation(impostor: PhysicsImpostor, newPosition: Vector3, newRotation: Quaternion): void;
+    /**
+     * If this plugin is supported
+     * @returns true if its supported
+     */
+    isSupported(): boolean;
+    /**
+     * Sets the linear velocity of the physics body
+     * @param impostor imposter to set the velocity on
+     * @param velocity velocity to set
+     */
+    setLinearVelocity(impostor: PhysicsImpostor, velocity: Vector3): void;
+    /**
+     * Sets the angular velocity of the physics body
+     * @param impostor imposter to set the velocity on
+     * @param velocity velocity to set
+     */
+    setAngularVelocity(impostor: PhysicsImpostor, velocity: Vector3): void;
+    /**
+     * gets the linear velocity
+     * @param impostor imposter to get linear velocity from
+     * @returns linear velocity
+     */
+    getLinearVelocity(impostor: PhysicsImpostor): Nullable<Vector3>;
+    /**
+     * gets the angular velocity
+     * @param impostor imposter to get angular velocity from
+     * @returns angular velocity
+     */
+    getAngularVelocity(impostor: PhysicsImpostor): Nullable<Vector3>;
+    /**
+     * Sets the mass of physics body
+     * @param impostor imposter to set the mass on
+     * @param mass mass to set
+     */
+    setBodyMass(impostor: PhysicsImpostor, mass: number): void;
+    /**
+     * Gets the mass of the physics body
+     * @param impostor imposter to get the mass from
+     * @returns mass
+     */
+    getBodyMass(impostor: PhysicsImpostor): number;
+    /**
+     * Gets friction of the impostor
+     * @param impostor impostor to get friction from
+     * @returns friction value
+     */
+    getBodyFriction(impostor: PhysicsImpostor): number;
+    /**
+     * Sets friction of the impostor
+     * @param impostor impostor to set friction on
+     * @param friction friction value
+     */
+    setBodyFriction(impostor: PhysicsImpostor, friction: number): void;
+    /**
+     * Gets restitution of the impostor
+     * @param impostor impostor to get restitution from
+     * @returns restitution value
+     */
+    getBodyRestitution(impostor: PhysicsImpostor): number;
+    /**
+     * Sets restitution of the impostor
+     * @param impostor impostor to set resitution on
+     * @param restitution resitution value
+     */
+    setBodyRestitution(impostor: PhysicsImpostor, restitution: number): void;
+    /**
+     * Gets pressure inside the impostor
+     * @param impostor impostor to get pressure from
+     * @returns pressure value
+     */
+    getBodyPressure(impostor: PhysicsImpostor): number;
+    /**
+     * Sets pressure inside a soft body impostor
+     * Cloth and rope must remain 0 pressure
+     * @param impostor impostor to set pressure on
+     * @param pressure pressure value
+     */
+    setBodyPressure(impostor: PhysicsImpostor, pressure: number): void;
+    /**
+     * Gets stiffness of the impostor
+     * @param impostor impostor to get stiffness from
+     * @returns pressure value
+     */
+    getBodyStiffness(impostor: PhysicsImpostor): number;
+    /**
+     * Sets stiffness of the impostor
+     * @param impostor impostor to set stiffness on
+     * @param stiffness stiffness value from 0 to 1
+     */
+    setBodyStiffness(impostor: PhysicsImpostor, stiffness: number): void;
+    /**
+     * Gets velocityIterations of the impostor
+     * @param impostor impostor to get velocity iterations from
+     * @returns velocityIterations value
+     */
+    getBodyVelocityIterations(impostor: PhysicsImpostor): number;
+    /**
+     * Sets velocityIterations of the impostor
+     * @param impostor impostor to set velocity iterations on
+     * @param velocityIterations velocityIterations value
+     */
+    setBodyVelocityIterations(impostor: PhysicsImpostor, velocityIterations: number): void;
+    /**
+     * Gets positionIterations of the impostor
+     * @param impostor impostor to get position iterations from
+     * @returns positionIterations value
+     */
+    getBodyPositionIterations(impostor: PhysicsImpostor): number;
+    /**
+     * Sets positionIterations of the impostor
+     * @param impostor impostor to set position on
+     * @param positionIterations positionIterations value
+     */
+    setBodyPositionIterations(impostor: PhysicsImpostor, positionIterations: number): void;
+    /**
+     * Append an anchor to a cloth object
+     * @param impostor is the cloth impostor to add anchor to
+     * @param otherImpostor is the rigid impostor to anchor to
+     * @param width ratio across width from 0 to 1
+     * @param height ratio up height from 0 to 1
+     * @param influence the elasticity between cloth impostor and anchor from 0, very stretchy to 1, little stretch
+     * @param noCollisionBetweenLinkedBodies when true collisions between soft impostor and anchor are ignored; default false
+     */
+    appendAnchor(impostor: PhysicsImpostor, otherImpostor: PhysicsImpostor, width: number, height: number, influence?: number, noCollisionBetweenLinkedBodies?: boolean): void;
+    /**
+     * Append an hook to a rope object
+     * @param impostor is the rope impostor to add hook to
+     * @param otherImpostor is the rigid impostor to hook to
+     * @param length ratio along the rope from 0 to 1
+     * @param influence the elasticity between soft impostor and anchor from 0, very stretchy to 1, little stretch
+     * @param noCollisionBetweenLinkedBodies when true collisions between soft impostor and anchor are ignored; default false
+     */
+    appendHook(impostor: PhysicsImpostor, otherImpostor: PhysicsImpostor, length: number, influence?: number, noCollisionBetweenLinkedBodies?: boolean): void;
+    /**
+     * Sleeps the physics body and stops it from being active
+     * @param impostor impostor to sleep
+     */
+    sleepBody(impostor: PhysicsImpostor): void;
+    /**
+     * Activates the physics body
+     * @param impostor impostor to activate
+     */
+    wakeUpBody(impostor: PhysicsImpostor): void;
+    /**
+     * Updates the distance parameters of the joint
+     */
+    updateDistanceJoint(): void;
+    /**
+     * Sets a motor on the joint
+     * @param joint joint to set motor on
+     * @param speed speed of the motor
+     * @param maxForce maximum force of the motor
+     */
+    setMotor(joint: IMotorEnabledJoint, speed?: number, maxForce?: number): void;
+    /**
+     * Sets the motors limit
+     */
+    setLimit(): void;
+    /**
+     * Syncs the position and rotation of a mesh with the impostor
+     * @param mesh mesh to sync
+     * @param impostor impostor to update the mesh with
+     */
+    syncMeshWithImpostor(mesh: AbstractMesh, impostor: PhysicsImpostor): void;
+    /**
+     * Gets the radius of the impostor
+     * @param impostor impostor to get radius from
+     * @returns the radius
+     */
+    getRadius(impostor: PhysicsImpostor): number;
+    /**
+     * Gets the box size of the impostor
+     * @param impostor impostor to get box size from
+     * @param result the resulting box size
+     */
+    getBoxSizeToRef(impostor: PhysicsImpostor, result: Vector3): void;
+    /**
+     * Disposes of the impostor
+     */
+    dispose(): void;
+    /**
+     * Does a raycast in the physics world
+     * @param from where should the ray start?
+     * @param to where should the ray end?
+     * @returns PhysicsRaycastResult
+     */
+    raycast(from: Vector3, to: Vector3): PhysicsRaycastResult;
+    /**
+     * Does a raycast in the physics world
+     * @param from when should the ray start?
+     * @param to when should the ray end?
+     * @param result resulting PhysicsRaycastResult
+     */
+    raycastToRef(from: Vector3, to: Vector3, result: PhysicsRaycastResult): void;
+}