@babylonjs/core 5.57.0 → 6.0.0

package/Physics/v2/IPhysicsEnginePlugin.d.ts

@@ -9,15 +9,14 @@ import type { PhysicsMaterial } from "./physicsMaterial";
 import type { Mesh } from "../../Meshes/mesh";
 import type { Nullable } from "../../types.js";
 import type { Observable } from "../../Misc/observable.js";
-/** @internal */
-export declare enum ConstraintAxisLimitMode {
+/** How a specific axis can be constrained */
+export declare enum PhysicsConstraintAxisLimitMode {
     FREE = 0,
     LIMITED = 1,
-    LOCKED = 2,
-    NONE = 3
+    LOCKED = 2
 }
-/** @internal */
-export declare enum ConstraintAxis {
+/** The constraint specific axis to use when setting Friction, `ConstraintAxisLimitMode`, max force, ... */
+export declare enum PhysicsConstraintAxis {
     LINEAR_X = 0,
     LINEAR_Y = 1,
     LINEAR_Z = 2,
@@ -26,17 +25,39 @@ export declare enum ConstraintAxis {
     ANGULAR_Z = 5,
     LINEAR_DISTANCE = 6
 }
-/** @internal */
-export declare enum ConstraintType {
+/** Type of Constraint */
+export declare enum PhysicsConstraintType {
+    /**
+     * A ball and socket constraint will attempt to line up the pivot
+     * positions in each body, and have no restrictions on rotation
+     */
     BALL_AND_SOCKET = 1,
+    /**
+     * A distance constraint will attempt to keep the pivot locations
+     * within a specified distance.
+     */
     DISTANCE = 2,
+    /**
+     * A hinge constraint will keep the pivot positions aligned as well
+     * as two angular axes. The remaining angular axis will be free to rotate.
+     */
     HINGE = 3,
+    /**
+     * A slider constraint allows bodies to translate along one axis and
+     * rotate about the same axis. The remaining two axes are locked in
+     * place
+     */
     SLIDER = 4,
+    /**
+     * A lock constraint will attempt to keep the pivots completely lined
+     * up between both bodies, allowing no relative movement.
+     */
     LOCK = 5,
-    PRISMATIC = 6
+    PRISMATIC = 6,
+    SIX_DOF = 7
 }
-/** @internal */
-export declare enum ShapeType {
+/** Type of Shape */
+export declare enum PhysicsShapeType {
     SPHERE = 0,
     CAPSULE = 1,
     CYLINDER = 2,
@@ -46,8 +67,8 @@ export declare enum ShapeType {
     MESH = 6,
     HEIGHTFIELD = 7
 }
-/** @internal */
-export declare enum ConstraintMotorType {
+/** Optional motor which attempts to move a body at a specific velocity, or at a specific position */
+export declare enum PhysicsConstraintMotorType {
     NONE = 0,
     VELOCITY = 1,
     POSITION = 2
@@ -64,6 +85,14 @@ export interface IPhysicsCollisionEvent {
      * 2nd physics body that collided
      */
     collidedAgainst: PhysicsBody;
+    /**
+     * index in instances array for the collider
+     */
+    colliderIndex: number;
+    /**
+     * index in instances array for the collidedAgainst
+     */
+    collidedAgainstIndex: number;
     /**
      * World position where the collision occured
      */
@@ -81,7 +110,9 @@ export interface IPhysicsCollisionEvent {
      */
     normal: Nullable<Vector3>;
 }
-/** @internal */
+/**
+ * Parameters used to describe the Shape
+ */
 export interface PhysicsShapeParameters {
     /**
      * Shape center position
@@ -100,7 +131,7 @@ export interface PhysicsShapeParameters {
      */
     pointB?: Vector3;
     /**
-     *
+     * Shape orientation
      */
     rotation?: Quaternion;
     /**
@@ -116,38 +147,55 @@ export interface PhysicsShapeParameters {
      */
     includeChildMeshes?: boolean;
 }
-/** @internal */
+/**
+ * Parameters used to describe a Constraint
+ */
 export interface PhysicsConstraintParameters {
     /**
-     * Pivot vector for 1st body
+     * Location of the constraint pivot in the space of first body
      */
     pivotA?: Vector3;
     /**
-     * Pivot vector for 2nd body
+     * Location of the constraint pivot in the space of the second body
      */
     pivotB?: Vector3;
     /**
-     * Axis vector for 1st body
+     * An axis in the space of the first body which determines how
+     * distances/angles are measured for LINEAR_X/ANGULAR_X limits.
      */
     axisA?: Vector3;
     /**
-     * Axis vector for 2nd body
+     * An axis in the space of the second body which determines how
+     * distances/angles are measured for LINEAR_X/ANGULAR_X limits.
      */
     axisB?: Vector3;
     /**
-     * Maximum distance between both bodies
+     * An axis in the space of the first body which determines how
+     * distances/angles are measured for LINEAR_Y/ANGULAR_Y limits.
+     */
+    perpAxisA?: Vector3;
+    /**
+     * An axis in the space of the second body which determines how
+     * distances/angles are measured for LINEAR_Y/ANGULAR_Y limits.
+     */
+    perpAxisB?: Vector3;
+    /**
+     * The maximum distance that can seperate the two pivots.
+     * Only used for DISTANCE constraints
      */
     maxDistance?: number;
     /**
-     * Can connected bodies collide?
+     * Determines if the connected bodies should collide. Generally,
+     * it is preferable to set this to false, especially if the constraint
+     * positions the bodies so that they overlap. Otherwise, the constraint
+     * will "fight" the collision detection and may cause jitter.
      */
     collision?: boolean;
 }
 /**
- *
+ * Parameters used to describe mass and inertia of the Physics Body
  */
-/** @internal */
-export interface MassProperties {
+export interface PhysicsMassProperties {
     /**
      * The center of mass, in local space. This is The
      * point the body will rotate around when applying
@@ -190,6 +238,9 @@ export interface MassProperties {
      */
     inertiaOrientation?: Quaternion;
 }
+/**
+ * Indicates how the body will behave.
+ */
 export declare enum PhysicsMotionType {
     STATIC = 0,
     ANIMATED = 1,
@@ -208,14 +259,7 @@ export interface IPhysicsEnginePluginV2 {
     /**
      * Collision observable
      */
-    onCollisionObservable: Observable<{
-        collider: PhysicsBody;
-        collidedAgainst: PhysicsBody;
-        point: Nullable<Vector3>;
-        distance: number;
-        impulse: number;
-        normal: Nullable<Vector3>;
-    }>;
+    onCollisionObservable: Observable<IPhysicsCollisionEvent>;
     setGravity(gravity: Vector3): void;
     setTimeStep(timeStep: number): void;
     getTimeStep(): number;
@@ -227,41 +271,40 @@ export interface IPhysicsEnginePluginV2 {
     removeBody(body: PhysicsBody): void;
     sync(body: PhysicsBody): void;
     syncTransform(body: PhysicsBody, transformNode: TransformNode): void;
-    addNodeShape(body: PhysicsBody, shapeNode: TransformNode): void;
-    setShape(body: PhysicsBody, shape: PhysicsShape): void;
-    getShape(body: PhysicsBody): PhysicsShape;
-    getShapeType(shape: PhysicsShape): ShapeType;
-    setFilterGroup(body: PhysicsBody, group: number): void;
-    getFilterGroup(body: PhysicsBody): number;
-    setEventMask(body: PhysicsBody, eventMask: number): void;
-    getEventMask(body: PhysicsBody): number;
-    setMotionType(body: PhysicsBody, motionType: PhysicsMotionType): void;
-    getMotionType(body: PhysicsBody): PhysicsMotionType;
-    computeMassProperties(body: PhysicsBody): MassProperties;
-    setMassProperties(body: PhysicsBody, massProps: MassProperties): void;
-    getMassProperties(body: PhysicsBody): MassProperties;
-    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;
-    applyForce(body: PhysicsBody, force: Vector3, location: Vector3): void;
-    setAngularVelocity(body: PhysicsBody, angVel: Vector3): void;
-    getAngularVelocityToRef(body: PhysicsBody, angVel: Vector3): void;
+    setShape(body: PhysicsBody, shape: Nullable<PhysicsShape>): void;
+    getShape(body: PhysicsBody): Nullable<PhysicsShape>;
+    getShapeType(shape: PhysicsShape): PhysicsShapeType;
+    setEventMask(body: PhysicsBody, eventMask: number, instanceIndex?: number): void;
+    getEventMask(body: PhysicsBody, instanceIndex?: number): number;
+    setMotionType(body: PhysicsBody, motionType: PhysicsMotionType, instanceIndex?: number): void;
+    getMotionType(body: PhysicsBody, instanceIndex?: number): PhysicsMotionType;
+    computeMassProperties(body: PhysicsBody, instanceIndex?: number): PhysicsMassProperties;
+    setMassProperties(body: PhysicsBody, massProps: PhysicsMassProperties, instanceIndex?: number): void;
+    getMassProperties(body: PhysicsBody, instanceIndex?: number): PhysicsMassProperties;
+    setLinearDamping(body: PhysicsBody, damping: number, instanceIndex?: number): void;
+    getLinearDamping(body: PhysicsBody, instanceIndex?: number): number;
+    setAngularDamping(body: PhysicsBody, damping: number, instanceIndex?: number): void;
+    getAngularDamping(body: PhysicsBody, instanceIndex?: number): number;
+    setLinearVelocity(body: PhysicsBody, linVel: Vector3, instanceIndex?: number): void;
+    getLinearVelocityToRef(body: PhysicsBody, linVel: Vector3, instanceIndex?: number): void;
+    applyImpulse(body: PhysicsBody, impulse: Vector3, location: Vector3, instanceIndex?: number): void;
+    applyForce(body: PhysicsBody, force: Vector3, location: Vector3, instanceIndex?: number): void;
+    setAngularVelocity(body: PhysicsBody, angVel: Vector3, instanceIndex?: number): void;
+    getAngularVelocityToRef(body: PhysicsBody, angVel: Vector3, instanceIndex?: number): void;
     getBodyGeometry(body: PhysicsBody): {};
     disposeBody(body: PhysicsBody): void;
-    setCollisionCallbackEnabled(body: PhysicsBody, enabled: boolean): void;
-    addConstraint(body: PhysicsBody, childBody: PhysicsBody, constraint: PhysicsConstraint): void;
-    getCollisionObservable(body: PhysicsBody): Observable<IPhysicsCollisionEvent>;
-    initShape(shape: PhysicsShape, type: ShapeType, options: PhysicsShapeParameters): void;
-    setFilterLayer(shape: PhysicsShape, layer: number): void;
-    getFilterLayer(shape: PhysicsShape): number;
+    setCollisionCallbackEnabled(body: PhysicsBody, enabled: boolean, instanceIndex?: number): void;
+    addConstraint(body: PhysicsBody, childBody: PhysicsBody, constraint: PhysicsConstraint, instanceIndex?: number, childInstanceIndex?: number): void;
+    getCollisionObservable(body: PhysicsBody, instanceIndex?: number): Observable<IPhysicsCollisionEvent>;
+    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;
     setDensity(shape: PhysicsShape, density: number): void;
     getDensity(shape: PhysicsShape): number;
-    addChild(shape: PhysicsShape, newChild: PhysicsShape, childTransform: TransformNode): void;
+    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;
@@ -271,20 +314,20 @@ export interface IPhysicsEnginePluginV2 {
     getEnabled(constraint: PhysicsConstraint): boolean;
     setCollisionsEnabled(constraint: PhysicsConstraint, isEnabled: boolean): void;
     getCollisionsEnabled(constraint: PhysicsConstraint): boolean;
-    setAxisFriction(constraint: PhysicsConstraint, axis: ConstraintAxis, friction: number): void;
-    getAxisFriction(constraint: PhysicsConstraint, axis: ConstraintAxis): number;
-    setAxisMode(constraint: PhysicsConstraint, axis: ConstraintAxis, limitMode: ConstraintAxisLimitMode): void;
-    getAxisMode(constraint: PhysicsConstraint, axis: ConstraintAxis): ConstraintAxisLimitMode;
-    setAxisMinLimit(constraint: PhysicsConstraint, axis: ConstraintAxis, minLimit: number): void;
-    getAxisMinLimit(constraint: PhysicsConstraint, axis: ConstraintAxis): number;
-    setAxisMaxLimit(constraint: PhysicsConstraint, axis: ConstraintAxis, limit: number): void;
-    getAxisMaxLimit(constraint: PhysicsConstraint, axis: ConstraintAxis): number;
-    setAxisMotorType(constraint: PhysicsConstraint, axis: ConstraintAxis, motorType: ConstraintMotorType): void;
-    getAxisMotorType(constraint: PhysicsConstraint, axis: ConstraintAxis): ConstraintMotorType;
-    setAxisMotorTarget(constraint: PhysicsConstraint, axis: ConstraintAxis, target: number): void;
-    getAxisMotorTarget(constraint: PhysicsConstraint, axis: ConstraintAxis): number;
-    setAxisMotorMaxForce(constraint: PhysicsConstraint, axis: ConstraintAxis, maxForce: number): void;
-    getAxisMotorMaxForce(constraint: PhysicsConstraint, axis: ConstraintAxis): number;
+    setAxisFriction(constraint: PhysicsConstraint, axis: PhysicsConstraintAxis, friction: number): void;
+    getAxisFriction(constraint: PhysicsConstraint, axis: PhysicsConstraintAxis): number;
+    setAxisMode(constraint: PhysicsConstraint, axis: PhysicsConstraintAxis, limitMode: PhysicsConstraintAxisLimitMode): void;
+    getAxisMode(constraint: PhysicsConstraint, axis: PhysicsConstraintAxis): PhysicsConstraintAxisLimitMode;
+    setAxisMinLimit(constraint: PhysicsConstraint, axis: PhysicsConstraintAxis, minLimit: number): void;
+    getAxisMinLimit(constraint: PhysicsConstraint, axis: PhysicsConstraintAxis): number;
+    setAxisMaxLimit(constraint: PhysicsConstraint, axis: PhysicsConstraintAxis, limit: number): void;
+    getAxisMaxLimit(constraint: PhysicsConstraint, axis: PhysicsConstraintAxis): number;
+    setAxisMotorType(constraint: PhysicsConstraint, axis: PhysicsConstraintAxis, motorType: PhysicsConstraintMotorType): void;
+    getAxisMotorType(constraint: PhysicsConstraint, axis: PhysicsConstraintAxis): PhysicsConstraintMotorType;
+    setAxisMotorTarget(constraint: PhysicsConstraint, axis: PhysicsConstraintAxis, target: number): void;
+    getAxisMotorTarget(constraint: PhysicsConstraint, axis: PhysicsConstraintAxis): number;
+    setAxisMotorMaxForce(constraint: PhysicsConstraint, axis: PhysicsConstraintAxis, maxForce: number): void;
+    getAxisMotorMaxForce(constraint: PhysicsConstraint, axis: PhysicsConstraintAxis): number;
     disposeConstraint(constraint: PhysicsConstraint): void;
     raycast(from: Vector3, to: Vector3, result: PhysicsRaycastResult): void;
     dispose(): void;

package/Physics/v2/IPhysicsEnginePlugin.js

@@ -1,51 +1,122 @@
-/** @internal */
-export var ConstraintAxisLimitMode;
-(function (ConstraintAxisLimitMode) {
-    ConstraintAxisLimitMode[ConstraintAxisLimitMode["FREE"] = 0] = "FREE";
-    ConstraintAxisLimitMode[ConstraintAxisLimitMode["LIMITED"] = 1] = "LIMITED";
-    ConstraintAxisLimitMode[ConstraintAxisLimitMode["LOCKED"] = 2] = "LOCKED";
-    ConstraintAxisLimitMode[ConstraintAxisLimitMode["NONE"] = 3] = "NONE";
-})(ConstraintAxisLimitMode || (ConstraintAxisLimitMode = {}));
-/** @internal */
-export var ConstraintAxis;
-(function (ConstraintAxis) {
-    ConstraintAxis[ConstraintAxis["LINEAR_X"] = 0] = "LINEAR_X";
-    ConstraintAxis[ConstraintAxis["LINEAR_Y"] = 1] = "LINEAR_Y";
-    ConstraintAxis[ConstraintAxis["LINEAR_Z"] = 2] = "LINEAR_Z";
-    ConstraintAxis[ConstraintAxis["ANGULAR_X"] = 3] = "ANGULAR_X";
-    ConstraintAxis[ConstraintAxis["ANGULAR_Y"] = 4] = "ANGULAR_Y";
-    ConstraintAxis[ConstraintAxis["ANGULAR_Z"] = 5] = "ANGULAR_Z";
-    ConstraintAxis[ConstraintAxis["LINEAR_DISTANCE"] = 6] = "LINEAR_DISTANCE";
-})(ConstraintAxis || (ConstraintAxis = {}));
-/** @internal */
-export var ConstraintType;
-(function (ConstraintType) {
-    ConstraintType[ConstraintType["BALL_AND_SOCKET"] = 1] = "BALL_AND_SOCKET";
-    ConstraintType[ConstraintType["DISTANCE"] = 2] = "DISTANCE";
-    ConstraintType[ConstraintType["HINGE"] = 3] = "HINGE";
-    ConstraintType[ConstraintType["SLIDER"] = 4] = "SLIDER";
-    ConstraintType[ConstraintType["LOCK"] = 5] = "LOCK";
-    ConstraintType[ConstraintType["PRISMATIC"] = 6] = "PRISMATIC";
-})(ConstraintType || (ConstraintType = {}));
-/** @internal */
-export var ShapeType;
-(function (ShapeType) {
-    ShapeType[ShapeType["SPHERE"] = 0] = "SPHERE";
-    ShapeType[ShapeType["CAPSULE"] = 1] = "CAPSULE";
-    ShapeType[ShapeType["CYLINDER"] = 2] = "CYLINDER";
-    ShapeType[ShapeType["BOX"] = 3] = "BOX";
-    ShapeType[ShapeType["CONVEX_HULL"] = 4] = "CONVEX_HULL";
-    ShapeType[ShapeType["CONTAINER"] = 5] = "CONTAINER";
-    ShapeType[ShapeType["MESH"] = 6] = "MESH";
-    ShapeType[ShapeType["HEIGHTFIELD"] = 7] = "HEIGHTFIELD";
-})(ShapeType || (ShapeType = {}));
-/** @internal */
-export var ConstraintMotorType;
-(function (ConstraintMotorType) {
-    ConstraintMotorType[ConstraintMotorType["NONE"] = 0] = "NONE";
-    ConstraintMotorType[ConstraintMotorType["VELOCITY"] = 1] = "VELOCITY";
-    ConstraintMotorType[ConstraintMotorType["POSITION"] = 2] = "POSITION";
-})(ConstraintMotorType || (ConstraintMotorType = {}));
+/** How a specific axis can be constrained */
+export var PhysicsConstraintAxisLimitMode;
+(function (PhysicsConstraintAxisLimitMode) {
+    /*
+     * The axis is not restricted at all
+     */
+    PhysicsConstraintAxisLimitMode[PhysicsConstraintAxisLimitMode["FREE"] = 0] = "FREE";
+    /*
+     * The axis has a minimum/maximum limit
+     */
+    PhysicsConstraintAxisLimitMode[PhysicsConstraintAxisLimitMode["LIMITED"] = 1] = "LIMITED";
+    /*
+     * The axis allows no relative movement of the pivots
+     */
+    PhysicsConstraintAxisLimitMode[PhysicsConstraintAxisLimitMode["LOCKED"] = 2] = "LOCKED";
+})(PhysicsConstraintAxisLimitMode || (PhysicsConstraintAxisLimitMode = {}));
+/** The constraint specific axis to use when setting Friction, `ConstraintAxisLimitMode`, max force, ... */
+export var PhysicsConstraintAxis;
+(function (PhysicsConstraintAxis) {
+    /*
+     * Translation along the primary axis of the constraint (i.e. the
+     * direction specified by PhysicsConstraintParameters.axisA/axisB)
+     */
+    PhysicsConstraintAxis[PhysicsConstraintAxis["LINEAR_X"] = 0] = "LINEAR_X";
+    /*
+     * Translation along the second axis of the constraint (i.e. the
+     * direction specified by PhysicsConstraintParameters.perpAxisA/perpAxisB)
+     */
+    PhysicsConstraintAxis[PhysicsConstraintAxis["LINEAR_Y"] = 1] = "LINEAR_Y";
+    /*
+     * Translation along the third axis of the constraint. This axis is
+     * computed from the cross product of axisA/axisB and perpAxisA/perpAxisB)
+     */
+    PhysicsConstraintAxis[PhysicsConstraintAxis["LINEAR_Z"] = 2] = "LINEAR_Z";
+    /*
+     * Rotation around the primary axis of the constraint (i.e. the
+     * axis specified by PhysicsConstraintParameters.axisA/axisB)
+     */
+    PhysicsConstraintAxis[PhysicsConstraintAxis["ANGULAR_X"] = 3] = "ANGULAR_X";
+    /*
+     * Rotation around the second axis of the constraint (i.e. the
+     * axis specified by PhysicsConstraintParameters.perpAxisA/perpAxisB)
+     */
+    PhysicsConstraintAxis[PhysicsConstraintAxis["ANGULAR_Y"] = 4] = "ANGULAR_Y";
+    /*
+     * Rotation around the third axis of the constraint. This axis is
+     * computed from the cross product of axisA/axisB and perpAxisA/perpAxisB)
+     */
+    PhysicsConstraintAxis[PhysicsConstraintAxis["ANGULAR_Z"] = 5] = "ANGULAR_Z";
+    /*
+     * A 3D distance limit; similar to specifying the LINEAR_X/Y/Z axes
+     * individually, but the distance calculation uses all three axes
+     * simultaneously, instead of individually.
+     */
+    PhysicsConstraintAxis[PhysicsConstraintAxis["LINEAR_DISTANCE"] = 6] = "LINEAR_DISTANCE";
+})(PhysicsConstraintAxis || (PhysicsConstraintAxis = {}));
+/** Type of Constraint */
+export var PhysicsConstraintType;
+(function (PhysicsConstraintType) {
+    /**
+     * A ball and socket constraint will attempt to line up the pivot
+     * positions in each body, and have no restrictions on rotation
+     */
+    PhysicsConstraintType[PhysicsConstraintType["BALL_AND_SOCKET"] = 1] = "BALL_AND_SOCKET";
+    /**
+     * A distance constraint will attempt to keep the pivot locations
+     * within a specified distance.
+     */
+    PhysicsConstraintType[PhysicsConstraintType["DISTANCE"] = 2] = "DISTANCE";
+    /**
+     * A hinge constraint will keep the pivot positions aligned as well
+     * as two angular axes. The remaining angular axis will be free to rotate.
+     */
+    PhysicsConstraintType[PhysicsConstraintType["HINGE"] = 3] = "HINGE";
+    /**
+     * A slider constraint allows bodies to translate along one axis and
+     * rotate about the same axis. The remaining two axes are locked in
+     * place
+     */
+    PhysicsConstraintType[PhysicsConstraintType["SLIDER"] = 4] = "SLIDER";
+    /**
+     * A lock constraint will attempt to keep the pivots completely lined
+     * up between both bodies, allowing no relative movement.
+     */
+    PhysicsConstraintType[PhysicsConstraintType["LOCK"] = 5] = "LOCK";
+    /*
+     * A prismatic will lock the rotations of the bodies, and allow translation
+     * only along one axis
+     */
+    PhysicsConstraintType[PhysicsConstraintType["PRISMATIC"] = 6] = "PRISMATIC";
+    /*
+     * A generic constraint; this starts with no limits on how the bodies can
+     * move relative to each other, but limits can be added via the PhysicsConstraint
+     * interfaces. This can be used to specify a large variety of constraints
+     */
+    PhysicsConstraintType[PhysicsConstraintType["SIX_DOF"] = 7] = "SIX_DOF";
+})(PhysicsConstraintType || (PhysicsConstraintType = {}));
+/** Type of Shape */
+export var PhysicsShapeType;
+(function (PhysicsShapeType) {
+    PhysicsShapeType[PhysicsShapeType["SPHERE"] = 0] = "SPHERE";
+    PhysicsShapeType[PhysicsShapeType["CAPSULE"] = 1] = "CAPSULE";
+    PhysicsShapeType[PhysicsShapeType["CYLINDER"] = 2] = "CYLINDER";
+    PhysicsShapeType[PhysicsShapeType["BOX"] = 3] = "BOX";
+    PhysicsShapeType[PhysicsShapeType["CONVEX_HULL"] = 4] = "CONVEX_HULL";
+    PhysicsShapeType[PhysicsShapeType["CONTAINER"] = 5] = "CONTAINER";
+    PhysicsShapeType[PhysicsShapeType["MESH"] = 6] = "MESH";
+    PhysicsShapeType[PhysicsShapeType["HEIGHTFIELD"] = 7] = "HEIGHTFIELD";
+})(PhysicsShapeType || (PhysicsShapeType = {}));
+/** Optional motor which attempts to move a body at a specific velocity, or at a specific position */
+export var PhysicsConstraintMotorType;
+(function (PhysicsConstraintMotorType) {
+    PhysicsConstraintMotorType[PhysicsConstraintMotorType["NONE"] = 0] = "NONE";
+    PhysicsConstraintMotorType[PhysicsConstraintMotorType["VELOCITY"] = 1] = "VELOCITY";
+    PhysicsConstraintMotorType[PhysicsConstraintMotorType["POSITION"] = 2] = "POSITION";
+})(PhysicsConstraintMotorType || (PhysicsConstraintMotorType = {}));
+/**
+ * Indicates how the body will behave.
+ */
 export var PhysicsMotionType;
 (function (PhysicsMotionType) {
     PhysicsMotionType[PhysicsMotionType["STATIC"] = 0] = "STATIC";

package/Physics/v2/IPhysicsEnginePlugin.js.map

@@ -1 +1 @@
-{"version":3,"file":"IPhysicsEnginePlugin.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Physics/v2/IPhysicsEnginePlugin.ts"],"names":[],"mappings":"AAYA,gBAAgB;AAChB,MAAM,CAAN,IAAY,uBAKX;AALD,WAAY,uBAAuB;IAC/B,qEAAI,CAAA;IACJ,2EAAO,CAAA;IACP,yEAAM,CAAA;IACN,qEAAI,CAAA;AACR,CAAC,EALW,uBAAuB,KAAvB,uBAAuB,QAKlC;AAED,gBAAgB;AAChB,MAAM,CAAN,IAAY,cAQX;AARD,WAAY,cAAc;IACtB,2DAAQ,CAAA;IACR,2DAAQ,CAAA;IACR,2DAAQ,CAAA;IACR,6DAAS,CAAA;IACT,6DAAS,CAAA;IACT,6DAAS,CAAA;IACT,yEAAe,CAAA;AACnB,CAAC,EARW,cAAc,KAAd,cAAc,QAQzB;AAED,gBAAgB;AAChB,MAAM,CAAN,IAAY,cAOX;AAPD,WAAY,cAAc;IACtB,yEAAmB,CAAA;IACnB,2DAAY,CAAA;IACZ,qDAAS,CAAA;IACT,uDAAU,CAAA;IACV,mDAAQ,CAAA;IACR,6DAAa,CAAA;AACjB,CAAC,EAPW,cAAc,KAAd,cAAc,QAOzB;AAED,gBAAgB;AAChB,MAAM,CAAN,IAAY,SASX;AATD,WAAY,SAAS;IACjB,6CAAM,CAAA;IACN,+CAAO,CAAA;IACP,iDAAQ,CAAA;IACR,uCAAG,CAAA;IACH,uDAAW,CAAA;IACX,mDAAS,CAAA;IACT,yCAAI,CAAA;IACJ,uDAAW,CAAA;AACf,CAAC,EATW,SAAS,KAAT,SAAS,QASpB;AAED,gBAAgB;AAChB,MAAM,CAAN,IAAY,mBAIX;AAJD,WAAY,mBAAmB;IAC3B,6DAAI,CAAA;IACJ,qEAAQ,CAAA;IACR,qEAAQ,CAAA;AACZ,CAAC,EAJW,mBAAmB,KAAnB,mBAAmB,QAI9B;AAgJD,MAAM,CAAN,IAAY,iBAIX;AAJD,WAAY,iBAAiB;IACzB,6DAAM,CAAA;IACN,iEAAQ,CAAA;IACR,+DAAO,CAAA;AACX,CAAC,EAJW,iBAAiB,KAAjB,iBAAiB,QAI5B","sourcesContent":["import type { Vector3, Quaternion } from \"../../Maths/math.vector\";\r\nimport type { PhysicsRaycastResult } from \"../physicsRaycastResult\";\r\nimport type { PhysicsBody } from \"./physicsBody\";\r\nimport type { PhysicsShape } from \"./physicsShape\";\r\nimport type { PhysicsConstraint } from \"./physicsConstraint\";\r\nimport type { BoundingBox } from \"../../Culling/boundingBox\";\r\nimport type { TransformNode } from \"../../Meshes/transformNode\";\r\nimport type { PhysicsMaterial } from \"./physicsMaterial\";\r\nimport type { Mesh } from \"../../Meshes/mesh\";\r\nimport type { Nullable } from \"core/types\";\r\nimport type { Observable } from \"core/Misc/observable\";\r\n\r\n/** @internal */\r\nexport enum ConstraintAxisLimitMode {\r\n    FREE,\r\n    LIMITED,\r\n    LOCKED,\r\n    NONE,\r\n}\r\n\r\n/** @internal */\r\nexport enum ConstraintAxis {\r\n    LINEAR_X,\r\n    LINEAR_Y,\r\n    LINEAR_Z,\r\n    ANGULAR_X,\r\n    ANGULAR_Y,\r\n    ANGULAR_Z,\r\n    LINEAR_DISTANCE,\r\n}\r\n\r\n/** @internal */\r\nexport enum ConstraintType {\r\n    BALL_AND_SOCKET = 1,\r\n    DISTANCE = 2,\r\n    HINGE = 3,\r\n    SLIDER = 4,\r\n    LOCK = 5,\r\n    PRISMATIC = 6,\r\n}\r\n\r\n/** @internal */\r\nexport enum ShapeType {\r\n    SPHERE,\r\n    CAPSULE,\r\n    CYLINDER,\r\n    BOX,\r\n    CONVEX_HULL,\r\n    CONTAINER,\r\n    MESH,\r\n    HEIGHTFIELD,\r\n}\r\n\r\n/** @internal */\r\nexport enum ConstraintMotorType {\r\n    NONE,\r\n    VELOCITY,\r\n    POSITION,\r\n}\r\n\r\n/**\r\n * Collision object that is the parameter when notification for collision fires.\r\n */\r\nexport interface IPhysicsCollisionEvent {\r\n    /**\r\n     * 1st physics body that collided\r\n     */\r\n    collider: PhysicsBody;\r\n    /**\r\n     * 2nd physics body that collided\r\n     */\r\n    collidedAgainst: PhysicsBody;\r\n    /**\r\n     * World position where the collision occured\r\n     */\r\n    point: Nullable<Vector3>;\r\n    /**\r\n     * Penetration distance\r\n     */\r\n    distance: number;\r\n    /**\r\n     * Impulse value computed by the solver response\r\n     */\r\n    impulse: number;\r\n    /**\r\n     * Collision world normal direction\r\n     */\r\n    normal: Nullable<Vector3>;\r\n}\r\n\r\n/** @internal */\r\nexport interface PhysicsShapeParameters {\r\n    /**\r\n     * Shape center position\r\n     */\r\n    center?: Vector3;\r\n    /**\r\n     * Radius for cylinder, shape and capsule\r\n     */\r\n    radius?: number;\r\n    /**\r\n     * First point position that defines the cylinder or capsule\r\n     */\r\n    pointA?: Vector3;\r\n    /**\r\n     * Second point position that defines the cylinder or capsule\r\n     */\r\n    pointB?: Vector3;\r\n    /**\r\n     *\r\n     */\r\n    rotation?: Quaternion;\r\n    /**\r\n     * Dimesion extention for the box\r\n     */\r\n    extents?: Vector3;\r\n    /**\r\n     * Mesh used for Mesh shape or convex hull. It can be different than the mesh the body is attached to.\r\n     */\r\n    mesh?: Mesh;\r\n    /**\r\n     * Use children hierarchy\r\n     */\r\n    includeChildMeshes?: boolean;\r\n}\r\n\r\n/** @internal */\r\nexport interface PhysicsConstraintParameters {\r\n    /**\r\n     * Pivot vector for 1st body\r\n     */\r\n    pivotA?: Vector3;\r\n    /**\r\n     * Pivot vector for 2nd body\r\n     */\r\n    pivotB?: Vector3;\r\n    /**\r\n     * Axis vector for 1st body\r\n     */\r\n    axisA?: Vector3;\r\n    /**\r\n     * Axis vector for 2nd body\r\n     */\r\n    axisB?: Vector3;\r\n    /**\r\n     * Maximum distance between both bodies\r\n     */\r\n    maxDistance?: number;\r\n    /**\r\n     * Can connected bodies collide?\r\n     */\r\n    collision?: boolean;\r\n}\r\n\r\n/**\r\n *\r\n */\r\n/** @internal */\r\nexport interface MassProperties {\r\n    /**\r\n     * The center of mass, in local space. This is The\r\n     * point the body will rotate around when applying\r\n     * an angular velocity.\r\n     *\r\n     * If not provided, the physics engine will compute\r\n     * an appropriate value.\r\n     */\r\n    centerOfMass?: Vector3;\r\n    /**\r\n     * The total mass of this object, in kilograms. This\r\n     * affects how easy it is to move the body. A value\r\n     * of zero will be used as an infinite mass.\r\n     *\r\n     * If not provided, the physics engine will compute\r\n     * an appropriate value.\r\n     */\r\n    mass?: number;\r\n    /**\r\n     * The principal moments of inertia of this object\r\n     * for a unit mass. This determines how easy it is\r\n     * for the body to rotate. A value of zero on any\r\n     * axis will be used as infinite interia about that\r\n     * axis.\r\n     *\r\n     * If not provided, the physics engine will compute\r\n     * an appropriate value.\r\n     */\r\n    inertia?: Vector3;\r\n    /**\r\n     * The rotation rotating from inertia major axis space\r\n     * to parent space (i.e., the rotation which, when\r\n     * applied to the 3x3 inertia tensor causes the inertia\r\n     * tensor to become a diagonal matrix). This determines\r\n     * how the values of inertia are aligned with the parent\r\n     * object.\r\n     *\r\n     * If not provided, the physics engine will compute\r\n     * an appropriate value.\r\n     */\r\n    inertiaOrientation?: Quaternion;\r\n}\r\n\r\nexport enum PhysicsMotionType {\r\n    STATIC,\r\n    ANIMATED,\r\n    DYNAMIC,\r\n}\r\n\r\n/** @internal */\r\nexport interface IPhysicsEnginePluginV2 {\r\n    /**\r\n     * Physics plugin world instance\r\n     */\r\n    world: any;\r\n    /**\r\n     * Physics plugin name\r\n     */\r\n    name: string;\r\n\r\n    /**\r\n     * Collision observable\r\n     */\r\n    onCollisionObservable: Observable<{\r\n        collider: PhysicsBody;\r\n        collidedAgainst: PhysicsBody;\r\n        point: Nullable<Vector3>;\r\n        distance: number;\r\n        impulse: number;\r\n        normal: Nullable<Vector3>;\r\n    }>;\r\n\r\n    setGravity(gravity: Vector3): void;\r\n    setTimeStep(timeStep: number): void;\r\n    getTimeStep(): number;\r\n    executeStep(delta: number, bodies: Array<PhysicsBody>): void; //not forgetting pre and post events\r\n    getPluginVersion(): number;\r\n\r\n    // body\r\n    initBody(body: PhysicsBody, motionType: PhysicsMotionType, position: Vector3, orientation: Quaternion): void;\r\n    initBodyInstances(body: PhysicsBody, motionType: PhysicsMotionType, mesh: Mesh): void;\r\n    updateBodyInstances(body: PhysicsBody, mesh: Mesh): void;\r\n    removeBody(body: PhysicsBody): void;\r\n    sync(body: PhysicsBody): void;\r\n    syncTransform(body: PhysicsBody, transformNode: TransformNode): void;\r\n    addNodeShape(body: PhysicsBody, shapeNode: TransformNode): void;\r\n    setShape(body: PhysicsBody, shape: PhysicsShape): void;\r\n    getShape(body: PhysicsBody): PhysicsShape;\r\n    getShapeType(shape: PhysicsShape): ShapeType;\r\n    setFilterGroup(body: PhysicsBody, group: number): void;\r\n    getFilterGroup(body: PhysicsBody): number;\r\n    setEventMask(body: PhysicsBody, eventMask: number): void;\r\n    getEventMask(body: PhysicsBody): number;\r\n    setMotionType(body: PhysicsBody, motionType: PhysicsMotionType): void;\r\n    getMotionType(body: PhysicsBody): PhysicsMotionType;\r\n    computeMassProperties(body: PhysicsBody): MassProperties;\r\n    setMassProperties(body: PhysicsBody, massProps: MassProperties): void;\r\n    getMassProperties(body: PhysicsBody): MassProperties;\r\n    setLinearDamping(body: PhysicsBody, damping: number): void;\r\n    getLinearDamping(body: PhysicsBody): number;\r\n    setAngularDamping(body: PhysicsBody, damping: number): void;\r\n    getAngularDamping(body: PhysicsBody): number;\r\n    setLinearVelocity(body: PhysicsBody, linVel: Vector3): void;\r\n    getLinearVelocityToRef(body: PhysicsBody, linVel: Vector3): void;\r\n    applyImpulse(body: PhysicsBody, impulse: Vector3, location: Vector3): void;\r\n    applyForce(body: PhysicsBody, force: Vector3, location: Vector3): void;\r\n    setAngularVelocity(body: PhysicsBody, angVel: Vector3): void;\r\n    getAngularVelocityToRef(body: PhysicsBody, angVel: Vector3): void;\r\n    getBodyGeometry(body: PhysicsBody): {};\r\n    disposeBody(body: PhysicsBody): void;\r\n    setCollisionCallbackEnabled(body: PhysicsBody, enabled: boolean): void;\r\n    addConstraint(body: PhysicsBody, childBody: PhysicsBody, constraint: PhysicsConstraint): void;\r\n    getCollisionObservable(body: PhysicsBody): Observable<IPhysicsCollisionEvent>;\r\n\r\n    // shape\r\n    initShape(shape: PhysicsShape, type: ShapeType, options: PhysicsShapeParameters): void;\r\n    setFilterLayer(shape: PhysicsShape, layer: number): void;\r\n    getFilterLayer(shape: PhysicsShape): number;\r\n    setMaterial(shape: PhysicsShape, material: PhysicsMaterial): void;\r\n    setDensity(shape: PhysicsShape, density: number): void;\r\n    getDensity(shape: PhysicsShape): number;\r\n    addChild(shape: PhysicsShape, newChild: PhysicsShape, childTransform: TransformNode): void;\r\n    removeChild(shape: PhysicsShape, childIndex: number): void;\r\n    getNumChildren(shape: PhysicsShape): number;\r\n    getBoundingBox(shape: PhysicsShape): BoundingBox;\r\n    disposeShape(shape: PhysicsShape): void;\r\n\r\n    // constraint\r\n    initConstraint(constraint: PhysicsConstraint, body: PhysicsBody, childBody: PhysicsBody): void;\r\n    setEnabled(constraint: PhysicsConstraint, isEnabled: boolean): void;\r\n    getEnabled(constraint: PhysicsConstraint): boolean;\r\n    setCollisionsEnabled(constraint: PhysicsConstraint, isEnabled: boolean): void;\r\n    getCollisionsEnabled(constraint: PhysicsConstraint): boolean;\r\n    setAxisFriction(constraint: PhysicsConstraint, axis: ConstraintAxis, friction: number): void;\r\n    getAxisFriction(constraint: PhysicsConstraint, axis: ConstraintAxis): number;\r\n    setAxisMode(constraint: PhysicsConstraint, axis: ConstraintAxis, limitMode: ConstraintAxisLimitMode): void;\r\n    getAxisMode(constraint: PhysicsConstraint, axis: ConstraintAxis): ConstraintAxisLimitMode;\r\n    setAxisMinLimit(constraint: PhysicsConstraint, axis: ConstraintAxis, minLimit: number): void;\r\n    getAxisMinLimit(constraint: PhysicsConstraint, axis: ConstraintAxis): number;\r\n    setAxisMaxLimit(constraint: PhysicsConstraint, axis: ConstraintAxis, limit: number): void;\r\n    getAxisMaxLimit(constraint: PhysicsConstraint, axis: ConstraintAxis): number;\r\n    setAxisMotorType(constraint: PhysicsConstraint, axis: ConstraintAxis, motorType: ConstraintMotorType): void;\r\n    getAxisMotorType(constraint: PhysicsConstraint, axis: ConstraintAxis): ConstraintMotorType;\r\n    setAxisMotorTarget(constraint: PhysicsConstraint, axis: ConstraintAxis, target: number): void;\r\n    getAxisMotorTarget(constraint: PhysicsConstraint, axis: ConstraintAxis): number;\r\n    setAxisMotorMaxForce(constraint: PhysicsConstraint, axis: ConstraintAxis, maxForce: number): void;\r\n    getAxisMotorMaxForce(constraint: PhysicsConstraint, axis: ConstraintAxis): number;\r\n    disposeConstraint(constraint: PhysicsConstraint): void;\r\n\r\n    // raycast\r\n    raycast(from: Vector3, to: Vector3, result: PhysicsRaycastResult): void;\r\n\r\n    dispose(): void;\r\n}\r\n"]}
+{"version":3,"file":"IPhysicsEnginePlugin.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Physics/v2/IPhysicsEnginePlugin.ts"],"names":[],"mappings":"AAYA,6CAA6C;AAC7C,MAAM,CAAN,IAAY,8BAaX;AAbD,WAAY,8BAA8B;IACtC;;OAEG;IACH,mFAAI,CAAA;IACJ;;OAEG;IACH,yFAAO,CAAA;IACP;;OAEG;IACH,uFAAM,CAAA;AACV,CAAC,EAbW,8BAA8B,KAA9B,8BAA8B,QAazC;AAED,2GAA2G;AAC3G,MAAM,CAAN,IAAY,qBAqCX;AArCD,WAAY,qBAAqB;IAC7B;;;OAGG;IACH,yEAAQ,CAAA;IACR;;;OAGG;IACH,yEAAQ,CAAA;IACR;;;OAGG;IACH,yEAAQ,CAAA;IACR;;;OAGG;IACH,2EAAS,CAAA;IACT;;;OAGG;IACH,2EAAS,CAAA;IACT;;;OAGG;IACH,2EAAS,CAAA;IACT;;;;OAIG;IACH,uFAAe,CAAA;AACnB,CAAC,EArCW,qBAAqB,KAArB,qBAAqB,QAqChC;AAED,yBAAyB;AACzB,MAAM,CAAN,IAAY,qBAsCX;AAtCD,WAAY,qBAAqB;IAC7B;;;OAGG;IACH,uFAAmB,CAAA;IACnB;;;OAGG;IACH,yEAAY,CAAA;IACZ;;;OAGG;IACH,mEAAS,CAAA;IACT;;;;OAIG;IACH,qEAAU,CAAA;IACV;;;OAGG;IACH,iEAAQ,CAAA;IACR;;;OAGG;IACH,2EAAa,CAAA;IACb;;;;OAIG;IACH,uEAAW,CAAA;AACf,CAAC,EAtCW,qBAAqB,KAArB,qBAAqB,QAsChC;AAED,oBAAoB;AACpB,MAAM,CAAN,IAAY,gBASX;AATD,WAAY,gBAAgB;IACxB,2DAAM,CAAA;IACN,6DAAO,CAAA;IACP,+DAAQ,CAAA;IACR,qDAAG,CAAA;IACH,qEAAW,CAAA;IACX,iEAAS,CAAA;IACT,uDAAI,CAAA;IACJ,qEAAW,CAAA;AACf,CAAC,EATW,gBAAgB,KAAhB,gBAAgB,QAS3B;AAED,qGAAqG;AACrG,MAAM,CAAN,IAAY,0BAIX;AAJD,WAAY,0BAA0B;IAClC,2EAAI,CAAA;IACJ,mFAAQ,CAAA;IACR,mFAAQ,CAAA;AACZ,CAAC,EAJW,0BAA0B,KAA1B,0BAA0B,QAIrC;AA+KD;;GAEG;AACH,MAAM,CAAN,IAAY,iBAIX;AAJD,WAAY,iBAAiB;IACzB,6DAAM,CAAA;IACN,iEAAQ,CAAA;IACR,+DAAO,CAAA;AACX,CAAC,EAJW,iBAAiB,KAAjB,iBAAiB,QAI5B","sourcesContent":["import type { Vector3, Quaternion } from \"../../Maths/math.vector\";\r\nimport type { PhysicsRaycastResult } from \"../physicsRaycastResult\";\r\nimport type { PhysicsBody } from \"./physicsBody\";\r\nimport type { PhysicsShape } from \"./physicsShape\";\r\nimport type { PhysicsConstraint } from \"./physicsConstraint\";\r\nimport type { BoundingBox } from \"../../Culling/boundingBox\";\r\nimport type { TransformNode } from \"../../Meshes/transformNode\";\r\nimport type { PhysicsMaterial } from \"./physicsMaterial\";\r\nimport type { Mesh } from \"../../Meshes/mesh\";\r\nimport type { Nullable } from \"core/types\";\r\nimport type { Observable } from \"core/Misc/observable\";\r\n\r\n/** How a specific axis can be constrained */\r\nexport enum PhysicsConstraintAxisLimitMode {\r\n    /*\r\n     * The axis is not restricted at all\r\n     */\r\n    FREE,\r\n    /*\r\n     * The axis has a minimum/maximum limit\r\n     */\r\n    LIMITED,\r\n    /*\r\n     * The axis allows no relative movement of the pivots\r\n     */\r\n    LOCKED,\r\n}\r\n\r\n/** The constraint specific axis to use when setting Friction, `ConstraintAxisLimitMode`, max force, ... */\r\nexport enum PhysicsConstraintAxis {\r\n    /*\r\n     * Translation along the primary axis of the constraint (i.e. the\r\n     * direction specified by PhysicsConstraintParameters.axisA/axisB)\r\n     */\r\n    LINEAR_X,\r\n    /*\r\n     * Translation along the second axis of the constraint (i.e. the\r\n     * direction specified by PhysicsConstraintParameters.perpAxisA/perpAxisB)\r\n     */\r\n    LINEAR_Y,\r\n    /*\r\n     * Translation along the third axis of the constraint. This axis is\r\n     * computed from the cross product of axisA/axisB and perpAxisA/perpAxisB)\r\n     */\r\n    LINEAR_Z,\r\n    /*\r\n     * Rotation around the primary axis of the constraint (i.e. the\r\n     * axis specified by PhysicsConstraintParameters.axisA/axisB)\r\n     */\r\n    ANGULAR_X,\r\n    /*\r\n     * Rotation around the second axis of the constraint (i.e. the\r\n     * axis specified by PhysicsConstraintParameters.perpAxisA/perpAxisB)\r\n     */\r\n    ANGULAR_Y,\r\n    /*\r\n     * Rotation around the third axis of the constraint. This axis is\r\n     * computed from the cross product of axisA/axisB and perpAxisA/perpAxisB)\r\n     */\r\n    ANGULAR_Z,\r\n    /*\r\n     * A 3D distance limit; similar to specifying the LINEAR_X/Y/Z axes\r\n     * individually, but the distance calculation uses all three axes\r\n     * simultaneously, instead of individually.\r\n     */\r\n    LINEAR_DISTANCE,\r\n}\r\n\r\n/** Type of Constraint */\r\nexport enum PhysicsConstraintType {\r\n    /**\r\n     * A ball and socket constraint will attempt to line up the pivot\r\n     * positions in each body, and have no restrictions on rotation\r\n     */\r\n    BALL_AND_SOCKET = 1,\r\n    /**\r\n     * A distance constraint will attempt to keep the pivot locations\r\n     * within a specified distance.\r\n     */\r\n    DISTANCE = 2,\r\n    /**\r\n     * A hinge constraint will keep the pivot positions aligned as well\r\n     * as two angular axes. The remaining angular axis will be free to rotate.\r\n     */\r\n    HINGE = 3,\r\n    /**\r\n     * A slider constraint allows bodies to translate along one axis and\r\n     * rotate about the same axis. The remaining two axes are locked in\r\n     * place\r\n     */\r\n    SLIDER = 4,\r\n    /**\r\n     * A lock constraint will attempt to keep the pivots completely lined\r\n     * up between both bodies, allowing no relative movement.\r\n     */\r\n    LOCK = 5,\r\n    /*\r\n     * A prismatic will lock the rotations of the bodies, and allow translation\r\n     * only along one axis\r\n     */\r\n    PRISMATIC = 6,\r\n    /*\r\n     * A generic constraint; this starts with no limits on how the bodies can\r\n     * move relative to each other, but limits can be added via the PhysicsConstraint\r\n     * interfaces. This can be used to specify a large variety of constraints\r\n     */\r\n    SIX_DOF = 7,\r\n}\r\n\r\n/** Type of Shape */\r\nexport enum PhysicsShapeType {\r\n    SPHERE,\r\n    CAPSULE,\r\n    CYLINDER,\r\n    BOX,\r\n    CONVEX_HULL,\r\n    CONTAINER,\r\n    MESH,\r\n    HEIGHTFIELD,\r\n}\r\n\r\n/** Optional motor which attempts to move a body at a specific velocity, or at a specific position */\r\nexport enum PhysicsConstraintMotorType {\r\n    NONE,\r\n    VELOCITY,\r\n    POSITION,\r\n}\r\n\r\n/**\r\n * Collision object that is the parameter when notification for collision fires.\r\n */\r\nexport interface IPhysicsCollisionEvent {\r\n    /**\r\n     * 1st physics body that collided\r\n     */\r\n    collider: PhysicsBody;\r\n    /**\r\n     * 2nd physics body that collided\r\n     */\r\n    collidedAgainst: PhysicsBody;\r\n    /**\r\n     * index in instances array for the collider\r\n     */\r\n    colliderIndex: number;\r\n    /**\r\n     * index in instances array for the collidedAgainst\r\n     */\r\n    collidedAgainstIndex: number;\r\n    /**\r\n     * World position where the collision occured\r\n     */\r\n    point: Nullable<Vector3>;\r\n    /**\r\n     * Penetration distance\r\n     */\r\n    distance: number;\r\n    /**\r\n     * Impulse value computed by the solver response\r\n     */\r\n    impulse: number;\r\n    /**\r\n     * Collision world normal direction\r\n     */\r\n    normal: Nullable<Vector3>;\r\n}\r\n\r\n/**\r\n * Parameters used to describe the Shape\r\n */\r\nexport interface PhysicsShapeParameters {\r\n    /**\r\n     * Shape center position\r\n     */\r\n    center?: Vector3;\r\n    /**\r\n     * Radius for cylinder, shape and capsule\r\n     */\r\n    radius?: number;\r\n    /**\r\n     * First point position that defines the cylinder or capsule\r\n     */\r\n    pointA?: Vector3;\r\n    /**\r\n     * Second point position that defines the cylinder or capsule\r\n     */\r\n    pointB?: Vector3;\r\n    /**\r\n     * Shape orientation\r\n     */\r\n    rotation?: Quaternion;\r\n    /**\r\n     * Dimesion extention for the box\r\n     */\r\n    extents?: Vector3;\r\n    /**\r\n     * Mesh used for Mesh shape or convex hull. It can be different than the mesh the body is attached to.\r\n     */\r\n    mesh?: Mesh;\r\n    /**\r\n     * Use children hierarchy\r\n     */\r\n    includeChildMeshes?: boolean;\r\n}\r\n\r\n/**\r\n * Parameters used to describe a Constraint\r\n */\r\nexport interface PhysicsConstraintParameters {\r\n    /**\r\n     * Location of the constraint pivot in the space of first body\r\n     */\r\n    pivotA?: Vector3;\r\n    /**\r\n     * Location of the constraint pivot in the space of the second body\r\n     */\r\n    pivotB?: Vector3;\r\n    /**\r\n     * An axis in the space of the first body which determines how\r\n     * distances/angles are measured for LINEAR_X/ANGULAR_X limits.\r\n     */\r\n    axisA?: Vector3;\r\n    /**\r\n     * An axis in the space of the second body which determines how\r\n     * distances/angles are measured for LINEAR_X/ANGULAR_X limits.\r\n     */\r\n    axisB?: Vector3;\r\n\r\n    /**\r\n     * An axis in the space of the first body which determines how\r\n     * distances/angles are measured for LINEAR_Y/ANGULAR_Y limits.\r\n     */\r\n    perpAxisA?: Vector3;\r\n\r\n    /**\r\n     * An axis in the space of the second body which determines how\r\n     * distances/angles are measured for LINEAR_Y/ANGULAR_Y limits.\r\n     */\r\n    perpAxisB?: Vector3;\r\n\r\n    /**\r\n     * The maximum distance that can seperate the two pivots.\r\n     * Only used for DISTANCE constraints\r\n     */\r\n    maxDistance?: number;\r\n\r\n    /**\r\n     * Determines if the connected bodies should collide. Generally,\r\n     * it is preferable to set this to false, especially if the constraint\r\n     * positions the bodies so that they overlap. Otherwise, the constraint\r\n     * will \"fight\" the collision detection and may cause jitter.\r\n     */\r\n    collision?: boolean;\r\n}\r\n\r\n/**\r\n * Parameters used to describe mass and inertia of the Physics Body\r\n */\r\nexport interface PhysicsMassProperties {\r\n    /**\r\n     * The center of mass, in local space. This is The\r\n     * point the body will rotate around when applying\r\n     * an angular velocity.\r\n     *\r\n     * If not provided, the physics engine will compute\r\n     * an appropriate value.\r\n     */\r\n    centerOfMass?: Vector3;\r\n    /**\r\n     * The total mass of this object, in kilograms. This\r\n     * affects how easy it is to move the body. A value\r\n     * of zero will be used as an infinite mass.\r\n     *\r\n     * If not provided, the physics engine will compute\r\n     * an appropriate value.\r\n     */\r\n    mass?: number;\r\n    /**\r\n     * The principal moments of inertia of this object\r\n     * for a unit mass. This determines how easy it is\r\n     * for the body to rotate. A value of zero on any\r\n     * axis will be used as infinite interia about that\r\n     * axis.\r\n     *\r\n     * If not provided, the physics engine will compute\r\n     * an appropriate value.\r\n     */\r\n    inertia?: Vector3;\r\n    /**\r\n     * The rotation rotating from inertia major axis space\r\n     * to parent space (i.e., the rotation which, when\r\n     * applied to the 3x3 inertia tensor causes the inertia\r\n     * tensor to become a diagonal matrix). This determines\r\n     * how the values of inertia are aligned with the parent\r\n     * object.\r\n     *\r\n     * If not provided, the physics engine will compute\r\n     * an appropriate value.\r\n     */\r\n    inertiaOrientation?: Quaternion;\r\n}\r\n\r\n/**\r\n * Indicates how the body will behave.\r\n */\r\nexport enum PhysicsMotionType {\r\n    STATIC,\r\n    ANIMATED,\r\n    DYNAMIC,\r\n}\r\n\r\n/** @internal */\r\nexport interface IPhysicsEnginePluginV2 {\r\n    /**\r\n     * Physics plugin world instance\r\n     */\r\n    world: any;\r\n    /**\r\n     * Physics plugin name\r\n     */\r\n    name: string;\r\n\r\n    /**\r\n     * Collision observable\r\n     */\r\n    onCollisionObservable: Observable<IPhysicsCollisionEvent>;\r\n\r\n    setGravity(gravity: Vector3): void;\r\n    setTimeStep(timeStep: number): void;\r\n    getTimeStep(): number;\r\n    executeStep(delta: number, bodies: Array<PhysicsBody>): void; //not forgetting pre and post events\r\n    getPluginVersion(): number;\r\n\r\n    // body\r\n    initBody(body: PhysicsBody, motionType: PhysicsMotionType, position: Vector3, orientation: Quaternion): void;\r\n    initBodyInstances(body: PhysicsBody, motionType: PhysicsMotionType, mesh: Mesh): void;\r\n    updateBodyInstances(body: PhysicsBody, mesh: Mesh): void;\r\n    removeBody(body: PhysicsBody): void;\r\n    sync(body: PhysicsBody): void;\r\n    syncTransform(body: PhysicsBody, transformNode: TransformNode): void;\r\n    setShape(body: PhysicsBody, shape: Nullable<PhysicsShape>): void;\r\n    getShape(body: PhysicsBody): Nullable<PhysicsShape>;\r\n    getShapeType(shape: PhysicsShape): PhysicsShapeType;\r\n    setEventMask(body: PhysicsBody, eventMask: number, instanceIndex?: number): void;\r\n    getEventMask(body: PhysicsBody, instanceIndex?: number): number;\r\n    setMotionType(body: PhysicsBody, motionType: PhysicsMotionType, instanceIndex?: number): void;\r\n    getMotionType(body: PhysicsBody, instanceIndex?: number): PhysicsMotionType;\r\n    computeMassProperties(body: PhysicsBody, instanceIndex?: number): PhysicsMassProperties;\r\n    setMassProperties(body: PhysicsBody, massProps: PhysicsMassProperties, instanceIndex?: number): void;\r\n    getMassProperties(body: PhysicsBody, instanceIndex?: number): PhysicsMassProperties;\r\n    setLinearDamping(body: PhysicsBody, damping: number, instanceIndex?: number): void;\r\n    getLinearDamping(body: PhysicsBody, instanceIndex?: number): number;\r\n    setAngularDamping(body: PhysicsBody, damping: number, instanceIndex?: number): void;\r\n    getAngularDamping(body: PhysicsBody, instanceIndex?: number): number;\r\n    setLinearVelocity(body: PhysicsBody, linVel: Vector3, instanceIndex?: number): void;\r\n    getLinearVelocityToRef(body: PhysicsBody, linVel: Vector3, instanceIndex?: number): void;\r\n    applyImpulse(body: PhysicsBody, impulse: Vector3, location: Vector3, instanceIndex?: number): void;\r\n    applyForce(body: PhysicsBody, force: Vector3, location: Vector3, instanceIndex?: number): void;\r\n    setAngularVelocity(body: PhysicsBody, angVel: Vector3, instanceIndex?: number): void;\r\n    getAngularVelocityToRef(body: PhysicsBody, angVel: Vector3, instanceIndex?: number): void;\r\n    getBodyGeometry(body: PhysicsBody): {};\r\n    disposeBody(body: PhysicsBody): void;\r\n    setCollisionCallbackEnabled(body: PhysicsBody, enabled: boolean, instanceIndex?: number): void;\r\n    addConstraint(body: PhysicsBody, childBody: PhysicsBody, constraint: PhysicsConstraint, instanceIndex?: number, childInstanceIndex?: number): void;\r\n    getCollisionObservable(body: PhysicsBody, instanceIndex?: number): Observable<IPhysicsCollisionEvent>;\r\n\r\n    // shape\r\n    initShape(shape: PhysicsShape, type: PhysicsShapeType, options: PhysicsShapeParameters): void;\r\n    setShapeFilterMembershipMask(shape: PhysicsShape, membershipMask: number): void;\r\n    getShapeFilterMembershipMask(shape: PhysicsShape): number;\r\n    setShapeFilterCollideMask(shape: PhysicsShape, collideMask: number): void;\r\n    getShapeFilterCollideMask(shape: PhysicsShape): number;\r\n    setMaterial(shape: PhysicsShape, material: PhysicsMaterial): void;\r\n    setDensity(shape: PhysicsShape, density: number): void;\r\n    getDensity(shape: PhysicsShape): number;\r\n    addChild(shape: PhysicsShape, newChild: PhysicsShape, translation?: Vector3, rotation?: Quaternion, scale?: Vector3): void;\r\n    removeChild(shape: PhysicsShape, childIndex: number): void;\r\n    getNumChildren(shape: PhysicsShape): number;\r\n    getBoundingBox(shape: PhysicsShape): BoundingBox;\r\n    disposeShape(shape: PhysicsShape): void;\r\n\r\n    // constraint\r\n    initConstraint(constraint: PhysicsConstraint, body: PhysicsBody, childBody: PhysicsBody): void;\r\n    setEnabled(constraint: PhysicsConstraint, isEnabled: boolean): void;\r\n    getEnabled(constraint: PhysicsConstraint): boolean;\r\n    setCollisionsEnabled(constraint: PhysicsConstraint, isEnabled: boolean): void;\r\n    getCollisionsEnabled(constraint: PhysicsConstraint): boolean;\r\n    setAxisFriction(constraint: PhysicsConstraint, axis: PhysicsConstraintAxis, friction: number): void;\r\n    getAxisFriction(constraint: PhysicsConstraint, axis: PhysicsConstraintAxis): number;\r\n    setAxisMode(constraint: PhysicsConstraint, axis: PhysicsConstraintAxis, limitMode: PhysicsConstraintAxisLimitMode): void;\r\n    getAxisMode(constraint: PhysicsConstraint, axis: PhysicsConstraintAxis): PhysicsConstraintAxisLimitMode;\r\n    setAxisMinLimit(constraint: PhysicsConstraint, axis: PhysicsConstraintAxis, minLimit: number): void;\r\n    getAxisMinLimit(constraint: PhysicsConstraint, axis: PhysicsConstraintAxis): number;\r\n    setAxisMaxLimit(constraint: PhysicsConstraint, axis: PhysicsConstraintAxis, limit: number): void;\r\n    getAxisMaxLimit(constraint: PhysicsConstraint, axis: PhysicsConstraintAxis): number;\r\n    setAxisMotorType(constraint: PhysicsConstraint, axis: PhysicsConstraintAxis, motorType: PhysicsConstraintMotorType): void;\r\n    getAxisMotorType(constraint: PhysicsConstraint, axis: PhysicsConstraintAxis): PhysicsConstraintMotorType;\r\n    setAxisMotorTarget(constraint: PhysicsConstraint, axis: PhysicsConstraintAxis, target: number): void;\r\n    getAxisMotorTarget(constraint: PhysicsConstraint, axis: PhysicsConstraintAxis): number;\r\n    setAxisMotorMaxForce(constraint: PhysicsConstraint, axis: PhysicsConstraintAxis, maxForce: number): void;\r\n    getAxisMotorMaxForce(constraint: PhysicsConstraint, axis: PhysicsConstraintAxis): number;\r\n    disposeConstraint(constraint: PhysicsConstraint): void;\r\n\r\n    // raycast\r\n    raycast(from: Vector3, to: Vector3, result: PhysicsRaycastResult): void;\r\n\r\n    dispose(): void;\r\n}\r\n"]}