@babylonjs/core 5.35.0 → 5.36.0

package/Physics/v1/physicsJoint.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"physicsJoint.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Physics/v1/physicsJoint.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Vector3 } from \"../../Maths/math.vector\";\r\nimport type { IPhysicsEnginePlugin } from \"./IPhysicsEnginePlugin\";\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"]}

package/Physics/v2/IPhysicsEnginePlugin.d.ts

@@ -0,0 +1,170 @@
+import type { Vector3, Quaternion } from "../../Maths/math.vector";
+import type { AbstractMesh } from "../../Meshes/abstractMesh";
+import type { PhysicsRaycastResult } from "../physicsRaycastResult";
+import type { PhysicsBody } from "./physicsBody";
+import type { PhysicsShape } from "./physicsShape";
+import type { PhysicsConstraint } from "./physicsConstraint";
+import type { BoundingBox } from "../../Culling/boundingBox";
+import type { TransformNode } from "../../Meshes/transformNode";
+import type { PhysicsMaterial } from "./physicsMaterial";
+/** @internal */
+export declare enum ConstraintAxisLimitMode {
+    FREE = 0,
+    LIMITED = 1,
+    LOCKED = 2,
+    NONE = 3
+}
+/** @internal */
+export declare enum ConstraintAxis {
+    LINEAR_X = 0,
+    LINEAR_Y = 1,
+    LINEAR_Z = 2,
+    ANGULAR_X = 3,
+    ANGULAR_Y = 4,
+    ANGULAR_Z = 5,
+    LINEAR_DISTANCE = 6
+}
+/** @internal */
+export declare enum ConstraintType {
+    BALL_AND_SOCKET = 0,
+    DISTANCE = 1,
+    HINGE = 2,
+    SLIDER = 3,
+    LOCK = 4
+}
+/** @internal */
+export declare enum ShapeType {
+    SPHERE = 0,
+    CAPSULE = 1,
+    CYLINDER = 2,
+    BOX = 3,
+    CONVEX_HULL = 4,
+    CONTAINER = 5,
+    MESH = 6
+}
+/** @internal */
+export declare enum ConstraintMotorType {
+    NONE = 0,
+    VELOCITY = 1,
+    POSITION = 2
+}
+/** @internal */
+export interface PhysicsShapeParameters {
+    center?: Vector3;
+    radius?: number;
+    pointA?: Vector3;
+    pointB?: Vector3;
+    rotation?: Quaternion;
+    extents?: Vector3;
+    mesh?: AbstractMesh;
+}
+/** @internal */
+export interface PhysicsConstraintParameters {
+    pivotA?: Vector3;
+    pivotB?: Vector3;
+    axisA?: Vector3;
+    axisB?: Vector3;
+}
+/**
+ *
+ */
+/** @internal */
+export interface MassProperties {
+    /**
+     *
+     */
+    centerOfMass: Vector3;
+    /**
+     *
+     */
+    mass: number;
+    /**
+     *
+     */
+    intertia: Vector3;
+    /**
+     *
+     */
+    inertiaOrientation: Quaternion;
+}
+/** @internal */
+export interface IPhysicsEnginePlugin {
+    /**
+     *
+     */
+    world: any;
+    /**
+     *
+     */
+    name: string;
+    setGravity(gravity: Vector3): void;
+    setTimeStep(timeStep: number): void;
+    getTimeStep(): number;
+    executeStep(delta: number): void;
+    getPluginVersion(): number;
+    initBody(body: PhysicsBody): void;
+    setShape(body: PhysicsBody, shape: PhysicsShape): void;
+    getShape(body: PhysicsBody): PhysicsShape;
+    setFilterGroup(body: PhysicsBody, group: number): void;
+    getFilterGroup(body: PhysicsBody): number;
+    setEventMask(body: PhysicsBody, eventMask: number): void;
+    getEventMask(body: PhysicsBody): number;
+    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, location: Vector3, impulse: Vector3): void;
+    setAngularVelocity(body: PhysicsBody, angVel: Vector3): void;
+    getAngularVelocityToRef(body: PhysicsBody, angVel: Vector3): void;
+    disposeBody(body: PhysicsBody): void;
+    initShape(shape: PhysicsShape, type: ShapeType, options: PhysicsShapeParameters): void;
+    setFilterLayer(shape: PhysicsShape, layer: number): void;
+    getFilterLayer(shape: PhysicsShape): number;
+    setMaterial(shape: PhysicsShape, material: PhysicsMaterial): void;
+    getMaterial(shape: PhysicsShape): PhysicsMaterial;
+    setDensity(shape: PhysicsShape, density: number): void;
+    getDensity(shape: PhysicsShape): number;
+    addChild(shape: PhysicsShape, newChild: PhysicsShape, childTransform: TransformNode): void;
+    removeChild(shape: PhysicsShape, childIndex: number): void;
+    getNumChildren(shape: PhysicsShape): number;
+    getBoundingBox(shape: PhysicsShape): BoundingBox;
+    disposeShape(shape: PhysicsShape): void;
+    initMaterial(material: PhysicsMaterial): void;
+    setFriction(material: PhysicsMaterial, friction: number): void;
+    getFriction(material: PhysicsMaterial): number;
+    setRestitution(material: PhysicsMaterial, restitution: number): void;
+    getRestitution(material: PhysicsMaterial): number;
+    disposeMaterial(material: PhysicsMaterial): void;
+    initConstraint(constraint: PhysicsConstraint, type: ConstraintType, options: PhysicsConstraintParameters): void;
+    setParentBody(constraint: PhysicsConstraint, body: PhysicsBody): void;
+    getParentBody(constraint: PhysicsConstraint): PhysicsBody;
+    setChildBody(constraint: PhysicsConstraint, body: PhysicsBody): void;
+    getChildBody(constraint: PhysicsConstraint): PhysicsBody;
+    setAnchorInParent(constraint: PhysicsConstraint, pivot: Vector3, axisX: Vector3, axisY: Vector3): void;
+    setAnchorInChild(constraint: PhysicsConstraint, pivot: Vector3, axisX: Vector3, axisY: Vector3): void;
+    setEnabled(constraint: PhysicsConstraint, isEnabled: boolean): void;
+    getEnabled(constraint: PhysicsConstraint): boolean;
+    setCollisionsEnabled(constraint: PhysicsConstraint, isEnabled: boolean): void;
+    getCollisionsEnabled(constraint: PhysicsConstraint): boolean;
+    setAxisFriction(constraint: PhysicsConstraint, axis: 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;
+    disposeConstraint(constraint: PhysicsConstraint): void;
+    raycast(from: Vector3, to: Vector3, result: PhysicsRaycastResult): void;
+    dispose(): void;
+}

package/Physics/v2/IPhysicsEnginePlugin.js

@@ -0,0 +1,47 @@
+/** @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"] = 0] = "BALL_AND_SOCKET";
+    ConstraintType[ConstraintType["DISTANCE"] = 1] = "DISTANCE";
+    ConstraintType[ConstraintType["HINGE"] = 2] = "HINGE";
+    ConstraintType[ConstraintType["SLIDER"] = 3] = "SLIDER";
+    ConstraintType[ConstraintType["LOCK"] = 4] = "LOCK";
+})(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 = {}));
+/** @internal */
+export var ConstraintMotorType;
+(function (ConstraintMotorType) {
+    ConstraintMotorType[ConstraintMotorType["NONE"] = 0] = "NONE";
+    ConstraintMotorType[ConstraintMotorType["VELOCITY"] = 1] = "VELOCITY";
+    ConstraintMotorType[ConstraintMotorType["POSITION"] = 2] = "POSITION";
+})(ConstraintMotorType || (ConstraintMotorType = {}));
+//# sourceMappingURL=IPhysicsEnginePlugin.js.map

package/Physics/v2/IPhysicsEnginePlugin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IPhysicsEnginePlugin.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Physics/v2/IPhysicsEnginePlugin.ts"],"names":[],"mappings":"AAUA,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,cAMX;AAND,WAAY,cAAc;IACtB,yEAAe,CAAA;IACf,2DAAQ,CAAA;IACR,qDAAK,CAAA;IACL,uDAAM,CAAA;IACN,mDAAI,CAAA;AACR,CAAC,EANW,cAAc,KAAd,cAAc,QAMzB;AAED,gBAAgB;AAChB,MAAM,CAAN,IAAY,SAQX;AARD,WAAY,SAAS;IACjB,6CAAM,CAAA;IACN,+CAAO,CAAA;IACP,iDAAQ,CAAA;IACR,uCAAG,CAAA;IACH,uDAAW,CAAA;IACX,mDAAS,CAAA;IACT,yCAAI,CAAA;AACR,CAAC,EARW,SAAS,KAAT,SAAS,QAQpB;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","sourcesContent":["import type { Vector3, Quaternion } from \"../../Maths/math.vector\";\r\nimport type { AbstractMesh } from \"../../Meshes/abstractMesh\";\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\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,\r\n    DISTANCE,\r\n    HINGE,\r\n    SLIDER,\r\n    LOCK,\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}\r\n\r\n/** @internal */\r\nexport enum ConstraintMotorType {\r\n    NONE,\r\n    VELOCITY,\r\n    POSITION,\r\n}\r\n\r\n/** @internal */\r\nexport interface PhysicsShapeParameters {\r\n    center?: Vector3;\r\n    radius?: number;\r\n    pointA?: Vector3;\r\n    pointB?: Vector3;\r\n    rotation?: Quaternion;\r\n    extents?: Vector3;\r\n    mesh?: AbstractMesh;\r\n}\r\n\r\n/** @internal */\r\nexport interface PhysicsConstraintParameters {\r\n    pivotA?: Vector3;\r\n    pivotB?: Vector3;\r\n    axisA?: Vector3;\r\n    axisB?: Vector3;\r\n}\r\n\r\n/**\r\n *\r\n */\r\n/** @internal */\r\nexport interface MassProperties {\r\n    /**\r\n     *\r\n     */\r\n    centerOfMass: Vector3;\r\n    /**\r\n     *\r\n     */\r\n    mass: number;\r\n    /**\r\n     *\r\n     */\r\n    intertia: Vector3;\r\n    /**\r\n     *\r\n     */\r\n    inertiaOrientation: Quaternion;\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): void; //not forgetting pre and post events\r\n    getPluginVersion(): number;\r\n\r\n    // body\r\n    initBody(body: PhysicsBody): void;\r\n    setShape(body: PhysicsBody, shape: PhysicsShape): void;\r\n    getShape(body: PhysicsBody): PhysicsShape;\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    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, location: Vector3, impulse: Vector3): void;\r\n    setAngularVelocity(body: PhysicsBody, angVel: Vector3): void;\r\n    getAngularVelocityToRef(body: PhysicsBody, angVel: Vector3): void;\r\n    disposeBody(body: PhysicsBody): void;\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    getMaterial(shape: PhysicsShape): PhysicsMaterial;\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    // material\r\n    initMaterial(material: PhysicsMaterial): void;\r\n    setFriction(material: PhysicsMaterial, friction: number): void;\r\n    getFriction(material: PhysicsMaterial): number;\r\n    setRestitution(material: PhysicsMaterial, restitution: number): void;\r\n    getRestitution(material: PhysicsMaterial): number;\r\n    disposeMaterial(material: PhysicsMaterial): void;\r\n\r\n    // constraint\r\n    initConstraint(constraint: PhysicsConstraint, type: ConstraintType, options: PhysicsConstraintParameters): void;\r\n    setParentBody(constraint: PhysicsConstraint, body: PhysicsBody): void;\r\n    getParentBody(constraint: PhysicsConstraint): PhysicsBody;\r\n    setChildBody(constraint: PhysicsConstraint, body: PhysicsBody): void;\r\n    getChildBody(constraint: PhysicsConstraint): PhysicsBody;\r\n    setAnchorInParent(constraint: PhysicsConstraint, pivot: Vector3, axisX: Vector3, axisY: Vector3): void;\r\n    setAnchorInChild(constraint: PhysicsConstraint, pivot: Vector3, axisX: Vector3, axisY: Vector3): 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"]}

package/Physics/v2/Plugins/index.js

@@ -0,0 +1,2 @@
+// TODO
+//# sourceMappingURL=index.js.map

package/Physics/v2/Plugins/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../../lts/core/generated/Physics/v2/Plugins/index.ts"],"names":[],"mappings":"AAAA,OAAO","sourcesContent":["// TODO\r\n"]}

package/Physics/v2/index.d.ts

@@ -0,0 +1,6 @@
+export { PhysicsEngine as PhysicsEngineV2 } from "./physicsEngine";
+export * from "./physicsBody";
+export * from "./physicsShape";
+export * from "./physicsConstraint";
+export * from "./physicsMaterial";
+export * from "./physicsAggregate";

package/Physics/v2/index.js

@@ -0,0 +1,8 @@
+/* eslint-disable import/no-internal-modules */
+export { PhysicsEngine as PhysicsEngineV2 } from "./physicsEngine.js";
+export * from "./physicsBody.js";
+export * from "./physicsShape.js";
+export * from "./physicsConstraint.js";
+export * from "./physicsMaterial.js";
+export * from "./physicsAggregate.js";
+//# sourceMappingURL=index.js.map

package/Physics/v2/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Physics/v2/index.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,OAAO,EAAE,aAAa,IAAI,eAAe,EAAE,MAAM,iBAAiB,CAAC;AACnE,cAAc,eAAe,CAAC;AAC9B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,qBAAqB,CAAC;AACpC,cAAc,mBAAmB,CAAC;AAClC,cAAc,oBAAoB,CAAC","sourcesContent":["/* eslint-disable import/no-internal-modules */\r\nexport { PhysicsEngine as PhysicsEngineV2 } from \"./physicsEngine\";\r\nexport * from \"./physicsBody\";\r\nexport * from \"./physicsShape\";\r\nexport * from \"./physicsConstraint\";\r\nexport * from \"./physicsMaterial\";\r\nexport * from \"./physicsAggregate\";\r\n"]}

package/Physics/v2/physicsAggregate.d.ts

@@ -0,0 +1,114 @@
+import type { PhysicsBody } from "./physicsBody";
+import { PhysicsMaterial } from "./physicsMaterial";
+import type { PhysicsShape } from "./physicsShape";
+import type { Scene } from "../../scene";
+import type { TransformNode } from "../../Meshes/transformNode";
+/**
+ * The interface for the physics aggregate parameters
+ */
+/** @internal */
+export interface PhysicsAggregateParameters {
+    /** @internal */
+    /**
+     * The mass of the physics imposter
+     */
+    mass: number;
+    /**
+     * The friction of the physics imposter
+     */
+    friction?: number;
+    /**
+     * The coefficient of restitution of the physics imposter
+     */
+    restitution?: number;
+    /**
+     * The native options of the physics imposter
+     */
+    nativeOptions?: any;
+    /**
+     * Specifies if the parent should be ignored
+     */
+    ignoreParent?: boolean;
+    /**
+     * Specifies if bi-directional transformations should be disabled
+     */
+    disableBidirectionalTransformation?: boolean;
+    /**
+     * The pressure inside the physics imposter, soft object only
+     */
+    pressure?: number;
+    /**
+     * The stiffness the physics imposter, soft object only
+     */
+    stiffness?: number;
+    /**
+     * The number of iterations used in maintaining consistent vertex velocities, soft object only
+     */
+    velocityIterations?: number;
+    /**
+     * The number of iterations used in maintaining consistent vertex positions, soft object only
+     */
+    positionIterations?: number;
+    /**
+     * The number used to fix points on a cloth (0, 1, 2, 4, 8) or rope (0, 1, 2) only
+     * 0 None, 1, back left or top, 2, back right or bottom, 4, front left, 8, front right
+     * Add to fix multiple points
+     */
+    fixedPoints?: number;
+    /**
+     * The collision margin around a soft object
+     */
+    margin?: number;
+    /**
+     * The collision margin around a soft object
+     */
+    damping?: number;
+    /**
+     * The path for a rope based on an extrusion
+     */
+    path?: any;
+    /**
+     * The shape of an extrusion used for a rope based on an extrusion
+     */
+    shape?: any;
+}
+/**
+ *
+ */
+export declare class PhysicsAggregate {
+    /**
+     * The physics-enabled object used as the physics imposter
+     */
+    transformNode: TransformNode;
+    /**
+     * The type of the physics imposter
+     */
+    type: number;
+    private _options;
+    private _scene?;
+    /**
+     *
+     */
+    body: PhysicsBody;
+    /**
+     *
+     */
+    shape: PhysicsShape;
+    /**
+     *
+     */
+    material: PhysicsMaterial;
+    constructor(
+    /**
+     * The physics-enabled object used as the physics imposter
+     */
+    transformNode: TransformNode, 
+    /**
+     * The type of the physics imposter
+     */
+    type: number, _options?: PhysicsAggregateParameters, _scene?: Scene | undefined);
+    /**
+     *
+     */
+    dispose(): void;
+}

package/Physics/v2/physicsAggregate.js

@@ -0,0 +1,46 @@
+import { PhysicsMaterial } from "./physicsMaterial.js";
+import { Logger } from "../../Misc/logger.js";
+/**
+ *
+ */
+export class PhysicsAggregate {
+    constructor(
+    /**
+     * The physics-enabled object used as the physics imposter
+     */
+    transformNode, 
+    /**
+     * The type of the physics imposter
+     */
+    type, _options = { mass: 0 }, _scene) {
+        this.transformNode = transformNode;
+        this.type = type;
+        this._options = _options;
+        this._scene = _scene;
+        //sanity check!
+        if (!this.transformNode) {
+            Logger.Error("No object was provided. A physics object is obligatory");
+            return;
+        }
+        if (this.transformNode.parent && this._options.mass !== 0) {
+            Logger.Warn("A physics impostor has been created for an object which has a parent. Babylon physics currently works in local space so unexpected issues may occur.");
+        }
+        // Legacy support for old syntax.
+        if (!this._scene && transformNode.getScene) {
+            this._scene = transformNode.getScene();
+        }
+        if (!this._scene) {
+            return;
+        }
+        this.material = new PhysicsMaterial(this._options.friction ? this._options.friction : 0, this._options.restitution ? this._options.restitution : 0, this._scene);
+    }
+    /**
+     *
+     */
+    dispose() {
+        this.body.dispose();
+        this.material.dispose();
+        this.shape.dispose();
+    }
+}
+//# sourceMappingURL=physicsAggregate.js.map

package/Physics/v2/physicsAggregate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"physicsAggregate.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Physics/v2/physicsAggregate.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAEpD,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAyE3C;;GAEG;AACH,MAAM,OAAO,gBAAgB;IAgBzB;IACI;;OAEG;IACI,aAA4B;IACnC;;OAEG;IACI,IAAY,EACX,WAAuC,EAAE,IAAI,EAAE,CAAC,EAAE,EAClD,MAAc;QANf,kBAAa,GAAb,aAAa,CAAe;QAI5B,SAAI,GAAJ,IAAI,CAAQ;QACX,aAAQ,GAAR,QAAQ,CAA0C;QAClD,WAAM,GAAN,MAAM,CAAQ;QAEtB,eAAe;QACf,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE;YACrB,MAAM,CAAC,KAAK,CAAC,wDAAwD,CAAC,CAAC;YACvE,OAAO;SACV;QACD,IAAI,IAAI,CAAC,aAAa,CAAC,MAAM,IAAI,IAAI,CAAC,QAAQ,CAAC,IAAI,KAAK,CAAC,EAAE;YACvD,MAAM,CAAC,IAAI,CAAC,sJAAsJ,CAAC,CAAC;SACvK;QAED,iCAAiC;QACjC,IAAI,CAAC,IAAI,CAAC,MAAM,IAAI,aAAa,CAAC,QAAQ,EAAE;YACxC,IAAI,CAAC,MAAM,GAAG,aAAa,CAAC,QAAQ,EAAE,CAAC;SAC1C;QAED,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE;YACd,OAAO;SACV;QAED,IAAI,CAAC,QAAQ,GAAG,IAAI,eAAe,CAAC,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;IACrK,CAAC;IAED;;OAEG;IACI,OAAO;QACV,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC;QACpB,IAAI,CAAC,QAAQ,CAAC,OAAO,EAAE,CAAC;QACxB,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC;IACzB,CAAC;CACJ","sourcesContent":["import type { PhysicsBody } from \"./physicsBody\";\r\nimport { PhysicsMaterial } from \"./physicsMaterial\";\r\nimport type { PhysicsShape } from \"./physicsShape\";\r\nimport { Logger } from \"../../Misc/logger\";\r\nimport type { Scene } from \"../../scene\";\r\nimport type { TransformNode } from \"../../Meshes/transformNode\";\r\n\r\n/**\r\n * The interface for the physics aggregate parameters\r\n */\r\n/** @internal */\r\nexport interface PhysicsAggregateParameters {\r\n    /** @internal */\r\n    /**\r\n     * The mass of the physics imposter\r\n     */\r\n    mass: number;\r\n    /**\r\n     * The friction of the physics imposter\r\n     */\r\n    friction?: number;\r\n    /**\r\n     * The coefficient of restitution of the physics imposter\r\n     */\r\n    restitution?: number;\r\n    /**\r\n     * The native options of the physics imposter\r\n     */\r\n    nativeOptions?: any;\r\n    /**\r\n     * Specifies if the parent should be ignored\r\n     */\r\n    ignoreParent?: boolean;\r\n    /**\r\n     * Specifies if bi-directional transformations should be disabled\r\n     */\r\n    disableBidirectionalTransformation?: boolean;\r\n    /**\r\n     * The pressure inside the physics imposter, soft object only\r\n     */\r\n    pressure?: number;\r\n    /**\r\n     * The stiffness the physics imposter, soft object only\r\n     */\r\n    stiffness?: number;\r\n    /**\r\n     * The number of iterations used in maintaining consistent vertex velocities, soft object only\r\n     */\r\n    velocityIterations?: number;\r\n    /**\r\n     * The number of iterations used in maintaining consistent vertex positions, soft object only\r\n     */\r\n    positionIterations?: number;\r\n    /**\r\n     * The number used to fix points on a cloth (0, 1, 2, 4, 8) or rope (0, 1, 2) only\r\n     * 0 None, 1, back left or top, 2, back right or bottom, 4, front left, 8, front right\r\n     * Add to fix multiple points\r\n     */\r\n    fixedPoints?: number;\r\n    /**\r\n     * The collision margin around a soft object\r\n     */\r\n    margin?: number;\r\n    /**\r\n     * The collision margin around a soft object\r\n     */\r\n    damping?: number;\r\n    /**\r\n     * The path for a rope based on an extrusion\r\n     */\r\n    path?: any;\r\n    /**\r\n     * The shape of an extrusion used for a rope based on an extrusion\r\n     */\r\n    shape?: any;\r\n}\r\n/**\r\n *\r\n */\r\nexport class PhysicsAggregate {\r\n    /**\r\n     *\r\n     */\r\n    public body: PhysicsBody;\r\n\r\n    /**\r\n     *\r\n     */\r\n    public shape: PhysicsShape;\r\n\r\n    /**\r\n     *\r\n     */\r\n    public material: PhysicsMaterial;\r\n\r\n    constructor(\r\n        /**\r\n         * The physics-enabled object used as the physics imposter\r\n         */\r\n        public transformNode: TransformNode,\r\n        /**\r\n         * The type of the physics imposter\r\n         */\r\n        public type: number,\r\n        private _options: PhysicsAggregateParameters = { mass: 0 },\r\n        private _scene?: Scene\r\n    ) {\r\n        //sanity check!\r\n        if (!this.transformNode) {\r\n            Logger.Error(\"No object was provided. A physics object is obligatory\");\r\n            return;\r\n        }\r\n        if (this.transformNode.parent && this._options.mass !== 0) {\r\n            Logger.Warn(\"A physics impostor has been created for an object which has a parent. Babylon physics currently works in local space so unexpected issues may occur.\");\r\n        }\r\n\r\n        // Legacy support for old syntax.\r\n        if (!this._scene && transformNode.getScene) {\r\n            this._scene = transformNode.getScene();\r\n        }\r\n\r\n        if (!this._scene) {\r\n            return;\r\n        }\r\n\r\n        this.material = new PhysicsMaterial(this._options.friction ? this._options.friction : 0, this._options.restitution ? this._options.restitution : 0, this._scene);\r\n    }\r\n\r\n    /**\r\n     *\r\n     */\r\n    public dispose(): void {\r\n        this.body.dispose();\r\n        this.material.dispose();\r\n        this.shape.dispose();\r\n    }\r\n}\r\n"]}

package/Physics/v2/physicsBody.d.ts

@@ -0,0 +1,109 @@
+import type { MassProperties } from "./IPhysicsEnginePlugin";
+import type { PhysicsShape } from "./physicsShape";
+import type { Vector3 } from "../../Maths/math.vector";
+import type { Scene } from "../../scene";
+/**
+ *
+ */
+/** @internal */
+export declare class PhysicsBody {
+    /** @internal */
+    _pluginData: any;
+    private _physicsPlugin;
+    /**
+     *
+     * @param scene
+     * @returns
+     */
+    constructor(scene: Scene);
+    /**
+     *
+     * @param shape
+     */
+    setShape(shape: PhysicsShape): void;
+    /**
+     *
+     * @returns
+     */
+    getShape(): PhysicsShape | undefined;
+    /**
+     *
+     * @param group
+     */
+    setFilterGroup(group: number): void;
+    /**
+     *
+     * @returns
+     */
+    getFilterGroup(): number;
+    /**
+     *
+     * @param eventMask
+     */
+    setEventMask(eventMask: number): void;
+    /**
+     *
+     * @returns
+     */
+    getEventMask(): number;
+    /**
+     *
+     * @param massProps
+     */
+    setMassProperties(massProps: MassProperties): void;
+    /**
+     *
+     * @returns
+     */
+    getMassProperties(): MassProperties | undefined;
+    /**
+     *
+     * @param damping
+     */
+    setLinearDamping(damping: number): void;
+    /**
+     *
+     * @returns
+     */
+    getLinearDamping(): number;
+    /**
+     *
+     * @param damping
+     */
+    setAngularDamping(damping: number): void;
+    /**
+     *
+     * @returns
+     */
+    getAngularDamping(): number;
+    /**
+     *
+     * @param linVel
+     */
+    setLinearVelocity(linVel: Vector3): void;
+    /**
+     *
+     * @returns
+     */
+    getLinearVelocityToRef(linVel: Vector3): void;
+    /**
+     *
+     * @param angVel
+     */
+    setAngularVelocity(angVel: Vector3): void;
+    /**
+     *
+     * @returns
+     */
+    getAngularVelocityToRef(angVel: Vector3): void;
+    /**
+     *
+     * @param location
+     * @param impulse
+     */
+    applyImpulse(location: Vector3, impulse: Vector3): void;
+    /**
+     *
+     */
+    dispose(): void;
+}