@babylonjs/core 7.21.0 → 7.21.2

package/Physics/v1/physicsJoint.js

@@ -32,9 +32,6 @@ export class PhysicsJoint {
      * Sets the physics joint
      */
     set physicsJoint(newJoint) {
-        if (this._physicsJoint) {
-            //remove from the world
-        }
         this._physicsJoint = newJoint;
     }
     /**

package/Physics/v1/physicsJoint.js.map

@@ -1 +1 @@
-{"version":3,"file":"physicsJoint.js","sourceRoot":"","sources":["../../../../../dev/core/src/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 override 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 override 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 override 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 override setLimit(upperLimit: number, lowerLimit?: number, motorIndex: number = 0) {\r\n        this._physicsPlugin.setLimit(this, upperLimit, lowerLimit, motorIndex);\r\n    }\r\n}\r\n\r\n/**\r\n * Interface for a motor enabled joint\r\n * @see https://doc.babylonjs.com/features/featuresDeepDive/physics/usingPhysicsEngine\r\n */\r\nexport interface IMotorEnabledJoint {\r\n    /**\r\n     * Physics joint\r\n     */\r\n    physicsJoint: any;\r\n    /**\r\n     * Sets the motor of the motor-enabled joint\r\n     * @param force The force of the motor\r\n     * @param maxForce The maximum force of the motor\r\n     * @param motorIndex The index of the motor\r\n     */\r\n    setMotor(force?: number, maxForce?: number, motorIndex?: number): void;\r\n    /**\r\n     * Sets the limit of the motor\r\n     * @param upperLimit The upper limit of the motor\r\n     * @param lowerLimit The lower limit of the motor\r\n     * @param motorIndex The index of the motor\r\n     */\r\n    setLimit(upperLimit: number, lowerLimit?: number, motorIndex?: number): void;\r\n}\r\n\r\n/**\r\n * Joint data for a Distance-Joint\r\n * @see https://doc.babylonjs.com/features/featuresDeepDive/physics/usingPhysicsEngine\r\n */\r\nexport interface DistanceJointData extends PhysicsJointData {\r\n    /**\r\n     * Max distance the 2 joint objects can be apart\r\n     */\r\n    maxDistance: number;\r\n    //Oimo - minDistance\r\n    //Cannon - maxForce\r\n}\r\n\r\n/**\r\n * Joint data from a spring joint\r\n * @see https://doc.babylonjs.com/features/featuresDeepDive/physics/usingPhysicsEngine\r\n */\r\nexport interface SpringJointData extends PhysicsJointData {\r\n    /**\r\n     * Length of the spring\r\n     */\r\n    length: number;\r\n    /**\r\n     * Stiffness of the spring\r\n     */\r\n    stiffness: number;\r\n    /**\r\n     * Damping of the spring\r\n     */\r\n    damping: number;\r\n    /** this callback will be called when applying the force to the impostors. */\r\n    forceApplicationCallback: () => void;\r\n}\r\n"]}
+{"version":3,"file":"physicsJoint.js","sourceRoot":"","sources":["../../../../../dev/core/src/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        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 override 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 override 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 override 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 override 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/physicsConstraint.d.ts

@@ -233,29 +233,27 @@ export declare class Physics6DoFConstraint extends PhysicsConstraint {
 }
 /**
  * Represents a Ball and Socket Constraint, used to simulate a joint
- *
+ * This class is useful for simulating a joint between two bodies in a physics engine.
+ * It allows for the two bodies to move relative to each other in a way that mimics a ball and socket joint, such as a shoulder or hip joint.
  * @param pivotA - The first pivot, defined locally in the first body frame
  * @param pivotB - The second pivot, defined locally in the second body frame
  * @param axisA - The axis of the first body
  * @param axisB - The axis of the second body
  * @param scene - The scene the constraint is applied to
  * @returns The Ball and Socket Constraint
- *
- * This class is useful for simulating a joint between two bodies in a physics engine.
- * It allows for the two bodies to move relative to each other in a way that mimics a ball and socket joint, such as a shoulder or hip joint.
  */
 export declare class BallAndSocketConstraint extends PhysicsConstraint {
     constructor(pivotA: Vector3, pivotB: Vector3, axisA: Vector3, axisB: Vector3, scene: Scene);
 }
 /**
  * Creates a distance constraint.
- * @param maxDistance distance between bodies
- * @param scene The scene the constraint belongs to
- * @returns DistanceConstraint
  *
  * This code is useful for creating a distance constraint in a physics engine.
  * A distance constraint is a type of constraint that keeps two objects at a certain distance from each other.
  * The scene is used to add the constraint to the physics engine.
+ * @param maxDistance distance between bodies
+ * @param scene The scene the constraint belongs to
+ * @returns DistanceConstraint
  */
 export declare class DistanceConstraint extends PhysicsConstraint {
     constructor(maxDistance: number, scene: Scene);
@@ -263,13 +261,12 @@ export declare class DistanceConstraint extends PhysicsConstraint {
 /**
  * Creates a HingeConstraint, which is a type of PhysicsConstraint.
  *
+ * This code is useful for creating a HingeConstraint, which is a type of PhysicsConstraint.
+ * This constraint is used to simulate a hinge joint between two rigid bodies, allowing them to rotate around a single axis.
  * @param pivotA - The first pivot point, in world space.
  * @param pivotB - The second pivot point, in world space.
  * @param scene - The scene the constraint is used in.
  * @returns The new HingeConstraint.
- *
- * This code is useful for creating a HingeConstraint, which is a type of PhysicsConstraint.
- * This constraint is used to simulate a hinge joint between two rigid bodies, allowing them to rotate around a single axis.
  */
 export declare class HingeConstraint extends PhysicsConstraint {
     constructor(pivotA: Vector3, pivotB: Vector3, axisA: Vector3, axisB: Vector3, scene: Scene);
@@ -277,16 +274,15 @@ export declare class HingeConstraint extends PhysicsConstraint {
 /**
  * Creates a SliderConstraint, which is a type of PhysicsConstraint.
  *
+ * This code is useful for creating a SliderConstraint, which is a type of PhysicsConstraint.
+ * It allows the user to specify the two pivots and two axes of the constraint in world space, as well as the scene the constraint belongs to.
+ * This is useful for creating a constraint between two rigid bodies that allows them to move along a certain axis.
  * @param pivotA - The first pivot of the constraint, in world space.
  * @param pivotB - The second pivot of the constraint, in world space.
  * @param axisA - The first axis of the constraint, in world space.
  * @param axisB - The second axis of the constraint, in world space.
  * @param scene - The scene the constraint belongs to.
  * @returns The created SliderConstraint.
- *
- * This code is useful for creating a SliderConstraint, which is a type of PhysicsConstraint.
- * It allows the user to specify the two pivots and two axes of the constraint in world space, as well as the scene the constraint belongs to.
- * This is useful for creating a constraint between two rigid bodies that allows them to move along a certain axis.
  */
 export declare class SliderConstraint extends PhysicsConstraint {
     constructor(pivotA: Vector3, pivotB: Vector3, axisA: Vector3, axisB: Vector3, scene: Scene);
@@ -294,15 +290,14 @@ export declare class SliderConstraint extends PhysicsConstraint {
 /**
  * Creates a LockConstraint, which is a type of PhysicsConstraint.
  *
+ * This code is useful for creating a LockConstraint, which is a type of PhysicsConstraint.
+ * It takes in two pivots and two axes in local space, as well as the scene the constraint belongs to, and creates a LockConstraint.
  * @param pivotA - The first pivot of the constraint in local space.
  * @param pivotB - The second pivot of the constraint in local space.
  * @param axisA - The first axis of the constraint in local space.
  * @param axisB - The second axis of the constraint in local space.
  * @param scene - The scene the constraint belongs to.
  * @returns The created LockConstraint.
- *
- * This code is useful for creating a LockConstraint, which is a type of PhysicsConstraint.
- * It takes in two pivots and two axes in local space, as well as the scene the constraint belongs to, and creates a LockConstraint.
  */
 export declare class LockConstraint extends PhysicsConstraint {
     constructor(pivotA: Vector3, pivotB: Vector3, axisA: Vector3, axisB: Vector3, scene: Scene);
@@ -310,15 +305,14 @@ export declare class LockConstraint extends PhysicsConstraint {
 /**
  * Creates a PrismaticConstraint, which is a type of PhysicsConstraint.
  *
+ * This code is useful for creating a PrismaticConstraint, which is a type of PhysicsConstraint.
+ * It takes in two pivots and two axes in local space, as well as the scene the constraint belongs to, and creates a PrismaticConstraint.
  * @param pivotA - The first pivot of the constraint in local space.
  * @param pivotB - The second pivot of the constraint in local space.
  * @param axisA - The first axis of the constraint in local space.
  * @param axisB - The second axis of the constraint in local space.
  * @param scene - The scene the constraint belongs to.
  * @returns The created LockConstraint.
- *
- * This code is useful for creating a PrismaticConstraint, which is a type of PhysicsConstraint.
- * It takes in two pivots and two axes in local space, as well as the scene the constraint belongs to, and creates a PrismaticConstraint.
  */
 export declare class PrismaticConstraint extends PhysicsConstraint {
     constructor(pivotA: Vector3, pivotB: Vector3, axisA: Vector3, axisB: Vector3, scene: Scene);

package/Physics/v2/physicsConstraint.js

@@ -256,16 +256,14 @@ export class Physics6DoFConstraint extends PhysicsConstraint {
 }
 /**
  * Represents a Ball and Socket Constraint, used to simulate a joint
- *
+ * This class is useful for simulating a joint between two bodies in a physics engine.
+ * It allows for the two bodies to move relative to each other in a way that mimics a ball and socket joint, such as a shoulder or hip joint.
  * @param pivotA - The first pivot, defined locally in the first body frame
  * @param pivotB - The second pivot, defined locally in the second body frame
  * @param axisA - The axis of the first body
  * @param axisB - The axis of the second body
  * @param scene - The scene the constraint is applied to
  * @returns The Ball and Socket Constraint
- *
- * This class is useful for simulating a joint between two bodies in a physics engine.
- * It allows for the two bodies to move relative to each other in a way that mimics a ball and socket joint, such as a shoulder or hip joint.
  */
 export class BallAndSocketConstraint extends PhysicsConstraint {
     constructor(pivotA, pivotB, axisA, axisB, scene) {
@@ -274,13 +272,13 @@ export class BallAndSocketConstraint extends PhysicsConstraint {
 }
 /**
  * Creates a distance constraint.
- * @param maxDistance distance between bodies
- * @param scene The scene the constraint belongs to
- * @returns DistanceConstraint
  *
  * This code is useful for creating a distance constraint in a physics engine.
  * A distance constraint is a type of constraint that keeps two objects at a certain distance from each other.
  * The scene is used to add the constraint to the physics engine.
+ * @param maxDistance distance between bodies
+ * @param scene The scene the constraint belongs to
+ * @returns DistanceConstraint
  */
 export class DistanceConstraint extends PhysicsConstraint {
     constructor(maxDistance, scene) {
@@ -290,13 +288,12 @@ export class DistanceConstraint extends PhysicsConstraint {
 /**
  * Creates a HingeConstraint, which is a type of PhysicsConstraint.
  *
+ * This code is useful for creating a HingeConstraint, which is a type of PhysicsConstraint.
+ * This constraint is used to simulate a hinge joint between two rigid bodies, allowing them to rotate around a single axis.
  * @param pivotA - The first pivot point, in world space.
  * @param pivotB - The second pivot point, in world space.
  * @param scene - The scene the constraint is used in.
  * @returns The new HingeConstraint.
- *
- * This code is useful for creating a HingeConstraint, which is a type of PhysicsConstraint.
- * This constraint is used to simulate a hinge joint between two rigid bodies, allowing them to rotate around a single axis.
  */
 export class HingeConstraint extends PhysicsConstraint {
     constructor(pivotA, pivotB, axisA, axisB, scene) {
@@ -306,16 +303,15 @@ export class HingeConstraint extends PhysicsConstraint {
 /**
  * Creates a SliderConstraint, which is a type of PhysicsConstraint.
  *
+ * This code is useful for creating a SliderConstraint, which is a type of PhysicsConstraint.
+ * It allows the user to specify the two pivots and two axes of the constraint in world space, as well as the scene the constraint belongs to.
+ * This is useful for creating a constraint between two rigid bodies that allows them to move along a certain axis.
  * @param pivotA - The first pivot of the constraint, in world space.
  * @param pivotB - The second pivot of the constraint, in world space.
  * @param axisA - The first axis of the constraint, in world space.
  * @param axisB - The second axis of the constraint, in world space.
  * @param scene - The scene the constraint belongs to.
  * @returns The created SliderConstraint.
- *
- * This code is useful for creating a SliderConstraint, which is a type of PhysicsConstraint.
- * It allows the user to specify the two pivots and two axes of the constraint in world space, as well as the scene the constraint belongs to.
- * This is useful for creating a constraint between two rigid bodies that allows them to move along a certain axis.
  */
 export class SliderConstraint extends PhysicsConstraint {
     constructor(pivotA, pivotB, axisA, axisB, scene) {
@@ -325,15 +321,14 @@ export class SliderConstraint extends PhysicsConstraint {
 /**
  * Creates a LockConstraint, which is a type of PhysicsConstraint.
  *
+ * This code is useful for creating a LockConstraint, which is a type of PhysicsConstraint.
+ * It takes in two pivots and two axes in local space, as well as the scene the constraint belongs to, and creates a LockConstraint.
  * @param pivotA - The first pivot of the constraint in local space.
  * @param pivotB - The second pivot of the constraint in local space.
  * @param axisA - The first axis of the constraint in local space.
  * @param axisB - The second axis of the constraint in local space.
  * @param scene - The scene the constraint belongs to.
  * @returns The created LockConstraint.
- *
- * This code is useful for creating a LockConstraint, which is a type of PhysicsConstraint.
- * It takes in two pivots and two axes in local space, as well as the scene the constraint belongs to, and creates a LockConstraint.
  */
 export class LockConstraint extends PhysicsConstraint {
     constructor(pivotA, pivotB, axisA, axisB, scene) {
@@ -343,15 +338,14 @@ export class LockConstraint extends PhysicsConstraint {
 /**
  * Creates a PrismaticConstraint, which is a type of PhysicsConstraint.
  *
+ * This code is useful for creating a PrismaticConstraint, which is a type of PhysicsConstraint.
+ * It takes in two pivots and two axes in local space, as well as the scene the constraint belongs to, and creates a PrismaticConstraint.
  * @param pivotA - The first pivot of the constraint in local space.
  * @param pivotB - The second pivot of the constraint in local space.
  * @param axisA - The first axis of the constraint in local space.
  * @param axisB - The second axis of the constraint in local space.
  * @param scene - The scene the constraint belongs to.
  * @returns The created LockConstraint.
- *
- * This code is useful for creating a PrismaticConstraint, which is a type of PhysicsConstraint.
- * It takes in two pivots and two axes in local space, as well as the scene the constraint belongs to, and creates a PrismaticConstraint.
  */
 export class PrismaticConstraint extends PhysicsConstraint {
     constructor(pivotA, pivotB, axisA, axisB, scene) {

package/Physics/v2/physicsConstraint.js.map

@@ -1 +1 @@
-{"version":3,"file":"physicsConstraint.js","sourceRoot":"","sources":["../../../../../dev/core/src/Physics/v2/physicsConstraint.ts"],"names":[],"mappings":"AAMA;;;;GAIG;AACH,MAAM,OAAO,iBAAiB;IAiB1B;;;;;;;;OAQG;IACH,YAAY,IAA2B,EAAE,OAAoC,EAAE,KAAY;QAzB3F;;WAEG;QACI,gBAAW,GAAQ,SAAS,CAAC;QAuBhC,IAAI,CAAC,KAAK,EAAE;YACR,MAAM,IAAI,KAAK,CAAC,qDAAqD,CAAC,CAAC;SAC1E;QACD,MAAM,aAAa,GAAG,KAAK,CAAC,gBAAgB,EAAE,CAAC;QAC/C,IAAI,CAAC,aAAa,EAAE;YAChB,MAAM,IAAI,KAAK,CAAC,8BAA8B,CAAC,CAAC;SACnD;QACD,IAAI,aAAa,CAAC,gBAAgB,EAAE,IAAI,CAAC,EAAE;YACvC,MAAM,IAAI,KAAK,CAAC,kDAAkD,CAAC,CAAC;SACvE;QACD,MAAM,aAAa,GAAG,aAAa,CAAC,gBAAgB,EAAE,CAAC;QACvD,IAAI,CAAC,aAAa,EAAE;YAChB,MAAM,IAAI,KAAK,CAAC,8BAA8B,CAAC,CAAC;SACnD;QAED,IAAI,CAAC,cAAc,GAAG,aAAuC,CAAC;QAC9D,IAAI,CAAC,QAAQ,GAAG,OAAO,CAAC;QACxB,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC;IACtB,CAAC;IAED;;;;;OAKG;IACH,IAAW,IAAI;QACX,OAAO,IAAI,CAAC,KAAK,CAAC;IACtB,CAAC;IAED;;;;;OAKG;IACH,IAAW,OAAO;QACd,OAAO,IAAI,CAAC,QAAQ,CAAC;IACzB,CAAC;IAED;;;OAGG;IACH,IAAW,SAAS,CAAC,SAAkB;QACnC,IAAI,CAAC,cAAc,CAAC,UAAU,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC;IACpD,CAAC;IAED;;;OAGG;IACH,IAAW,SAAS;QAChB,OAAO,IAAI,CAAC,cAAc,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;IAChD,CAAC;IAED;;;;;OAKG;IACH,IAAW,mBAAmB,CAAC,SAAkB;QAC7C,IAAI,CAAC,cAAc,CAAC,oBAAoB,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC;IAC9D,CAAC;IAED;;;;;OAKG;IACH,IAAW,mBAAmB;QAC1B,OAAO,IAAI,CAAC,cAAc,CAAC,oBAAoB,CAAC,IAAI,CAAC,CAAC;IAC1D,CAAC;IAED;;;OAGG;IACI,wBAAwB;QAC3B,OAAO,IAAI,CAAC,cAAc,CAAC,wBAAwB,CAAC,IAAI,CAAC,CAAC;IAC9D,CAAC;IAED;;;;OAIG;IACI,OAAO;QACV,IAAI,CAAC,cAAc,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC;IAChD,CAAC;CACJ;AAED;;GAEG;AACH,MAAM,OAAO,gBAAgB;CAuB5B;AAED;;;;;GAKG;AACH,MAAM,OAAO,qBAAsB,SAAQ,iBAAiB;IAMxD,YAAY,gBAA6C,EAAE,MAA0B,EAAE,KAAY;QAC/F,KAAK,wCAAgC,gBAAgB,EAAE,KAAK,CAAC,CAAC;QAC9D,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;IACzB,CAAC;IAED;;;;;OAKG;IACI,eAAe,CAAC,IAA2B,EAAE,QAAgB;QAChE,IAAI,CAAC,cAAc,CAAC,eAAe,CAAC,IAAI,EAAE,IAAI,EAAE,QAAQ,CAAC,CAAC;IAC9D,CAAC;IAED;;;;;OAKG;IACI,eAAe,CAAC,IAA2B;QAC9C,OAAO,IAAI,CAAC,cAAc,CAAC,eAAe,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;IAC3D,CAAC;IAED;;;;;;;;;OASG;IACI,WAAW,CAAC,IAA2B,EAAE,SAAyC;QACrF,IAAI,CAAC,cAAc,CAAC,WAAW,CAAC,IAAI,EAAE,IAAI,EAAE,SAAS,CAAC,CAAC;IAC3D,CAAC;IAED;;;;;;OAMG;IACI,WAAW,CAAC,IAA2B;QAC1C,OAAO,IAAI,CAAC,cAAc,CAAC,WAAW,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;IACvD,CAAC;IAED;;;;;OAKG;IACI,eAAe,CAAC,IAA2B,EAAE,QAAgB;QAChE,IAAI,CAAC,cAAc,CAAC,eAAe,CAAC,IAAI,EAAE,IAAI,EAAE,QAAQ,CAAC,CAAC;IAC9D,CAAC;IAED;;;;;OAKG;IACI,eAAe,CAAC,IAA2B;QAC9C,OAAO,IAAI,CAAC,cAAc,CAAC,eAAe,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;IAC3D,CAAC;IAED;;;;;;;;OAQG;IACI,eAAe,CAAC,IAA2B,EAAE,KAAa;QAC7D,IAAI,CAAC,cAAc,CAAC,eAAe,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC;IAC3D,CAAC;IAED;;;;;OAKG;IACI,eAAe,CAAC,IAA2B;QAC9C,OAAO,IAAI,CAAC,cAAc,CAAC,eAAe,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;IAC3D,CAAC;IAED;;;;OAIG;IACI,gBAAgB,CAAC,IAA2B,EAAE,SAAqC;QACtF,IAAI,CAAC,cAAc,CAAC,gBAAgB,CAAC,IAAI,EAAE,IAAI,EAAE,SAAS,CAAC,CAAC;IAChE,CAAC;IAED;;;;;;OAMG;IACI,gBAAgB,CAAC,IAA2B;QAC/C,OAAO,IAAI,CAAC,cAAc,CAAC,gBAAgB,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;IAC5D,CAAC;IAED;;;;;;OAMG;IACI,kBAAkB,CAAC,IAA2B,EAAE,MAAc;QACjE,IAAI,CAAC,cAAc,CAAC,kBAAkB,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC;IAC/D,CAAC;IAED;;;;;OAKG;IACI,kBAAkB,CAAC,IAA2B;QACjD,OAAO,IAAI,CAAC,cAAc,CAAC,kBAAkB,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;IAC9D,CAAC;IAED;;;;;OAKG;IACI,oBAAoB,CAAC,IAA2B,EAAE,QAAgB;QACrE,IAAI,CAAC,cAAc,CAAC,oBAAoB,CAAC,IAAI,EAAE,IAAI,EAAE,QAAQ,CAAC,CAAC;IACnE,CAAC;IAED;;;;;OAKG;IACI,oBAAoB,CAAC,IAA2B;QACnD,OAAO,IAAI,CAAC,cAAc,CAAC,oBAAoB,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;IAChE,CAAC;CACJ;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,OAAO,uBAAwB,SAAQ,iBAAiB;IAC1D,YAAY,MAAe,EAAE,MAAe,EAAE,KAAc,EAAE,KAAc,EAAE,KAAY;QACtF,KAAK,gDAAwC,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE,KAAK,CAAC,CAAC;IACxH,CAAC;CACJ;AAED;;;;;;;;;GASG;AACH,MAAM,OAAO,kBAAmB,SAAQ,iBAAiB;IACrD,YAAY,WAAmB,EAAE,KAAY;QACzC,KAAK,yCAAiC,EAAE,WAAW,EAAE,WAAW,EAAE,EAAE,KAAK,CAAC,CAAC;IAC/E,CAAC;CACJ;AAED;;;;;;;;;;GAUG;AACH,MAAM,OAAO,eAAgB,SAAQ,iBAAiB;IAClD,YAAY,MAAe,EAAE,MAAe,EAAE,KAAc,EAAE,KAAc,EAAE,KAAY;QACtF,KAAK,sCAA8B,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE,KAAK,CAAC,CAAC;IAC9G,CAAC;CACJ;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,OAAO,gBAAiB,SAAQ,iBAAiB;IACnD,YAAY,MAAe,EAAE,MAAe,EAAE,KAAc,EAAE,KAAc,EAAE,KAAY;QACtF,KAAK,uCAA+B,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE,KAAK,CAAC,CAAC;IAC/G,CAAC;CACJ;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,OAAO,cAAe,SAAQ,iBAAiB;IACjD,YAAY,MAAe,EAAE,MAAe,EAAE,KAAc,EAAE,KAAc,EAAE,KAAY;QACtF,KAAK,qCAA6B,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE,KAAK,CAAC,CAAC;IAC7G,CAAC;CACJ;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,OAAO,mBAAoB,SAAQ,iBAAiB;IACtD,YAAY,MAAe,EAAE,MAAe,EAAE,KAAc,EAAE,KAAc,EAAE,KAAY;QACtF,KAAK,0CAAkC,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE,KAAK,CAAC,CAAC;IAClH,CAAC;CACJ;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,OAAO,gBAAiB,SAAQ,qBAAqB;IACvD,YAAY,MAAe,EAAE,MAAe,EAAE,KAAc,EAAE,KAAc,EAAE,WAAmB,EAAE,WAAmB,EAAE,SAAiB,EAAE,OAAe,EAAE,KAAY;QACpK,KAAK,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE,CAAC,EAAE,IAAI,+CAAuC,EAAE,QAAQ,EAAE,WAAW,EAAE,QAAQ,EAAE,WAAW,EAAE,SAAS,EAAE,OAAO,EAAE,CAAC,EAAE,KAAK,CAAC,CAAC;IACxK,CAAC;CACJ","sourcesContent":["import type { Scene } from \"../../scene\";\r\nimport type { Vector3 } from \"../../Maths/math.vector\";\r\nimport type { Nullable } from \"../../types\";\r\nimport type { IPhysicsEnginePluginV2, PhysicsConstraintParameters, PhysicsConstraintAxisLimitMode, PhysicsConstraintMotorType, ConstrainedBodyPair } from \"./IPhysicsEnginePlugin\";\r\nimport { PhysicsConstraintAxis, PhysicsConstraintType } from \"./IPhysicsEnginePlugin\";\r\n\r\n/**\r\n * This is a holder class for the physics constraint created by the physics plugin\r\n * It holds a set of functions to control the underlying constraint\r\n * @see https://doc.babylonjs.com/features/featuresDeepDive/physics/usingPhysicsEngine\r\n */\r\nexport class PhysicsConstraint {\r\n    /**\r\n     * V2 Physics plugin private data for a physics material\r\n     */\r\n    public _pluginData: any = undefined;\r\n    /**\r\n     * The V2 plugin used to create and manage this Physics Body\r\n     */\r\n    protected _physicsPlugin: IPhysicsEnginePluginV2;\r\n    protected _options: PhysicsConstraintParameters;\r\n    protected _type: PhysicsConstraintType;\r\n    /**\r\n     * @internal\r\n     * The internal options that were used to init the constraint\r\n     */\r\n    public _initOptions?: PhysicsConstraintParameters;\r\n\r\n    /**\r\n     * Constructs a new constraint for the physics constraint.\r\n     * @param type The type of constraint to create.\r\n     * @param options The options for the constraint.\r\n     * @param scene The scene the constraint belongs to.\r\n     *\r\n     * This code is useful for creating a new constraint for the physics engine. It checks if the scene has a physics engine, and if the plugin version is correct.\r\n     * If all checks pass, it initializes the constraint with the given type and options.\r\n     */\r\n    constructor(type: PhysicsConstraintType, options: PhysicsConstraintParameters, scene: Scene) {\r\n        if (!scene) {\r\n            throw new Error(\"Missing scene parameter for constraint constructor.\");\r\n        }\r\n        const physicsEngine = scene.getPhysicsEngine();\r\n        if (!physicsEngine) {\r\n            throw new Error(\"No Physics Engine available.\");\r\n        }\r\n        if (physicsEngine.getPluginVersion() != 2) {\r\n            throw new Error(\"Plugin version is incorrect. Expected version 2.\");\r\n        }\r\n        const physicsPlugin = physicsEngine.getPhysicsPlugin();\r\n        if (!physicsPlugin) {\r\n            throw new Error(\"No Physics Plugin available.\");\r\n        }\r\n\r\n        this._physicsPlugin = physicsPlugin as IPhysicsEnginePluginV2;\r\n        this._options = options;\r\n        this._type = type;\r\n    }\r\n\r\n    /**\r\n     * Gets the type of the constraint.\r\n     *\r\n     * @returns The type of the constraint.\r\n     *\r\n     */\r\n    public get type(): PhysicsConstraintType {\r\n        return this._type;\r\n    }\r\n\r\n    /**\r\n     * Retrieves the options of the physics constraint.\r\n     *\r\n     * @returns The physics constraint parameters.\r\n     *\r\n     */\r\n    public get options(): PhysicsConstraintParameters {\r\n        return this._options;\r\n    }\r\n\r\n    /**\r\n     * Enable/disable the constraint\r\n     * @param isEnabled value for the constraint\r\n     */\r\n    public set isEnabled(isEnabled: boolean) {\r\n        this._physicsPlugin.setEnabled(this, isEnabled);\r\n    }\r\n\r\n    /**\r\n     *\r\n     * @returns true if constraint is enabled\r\n     */\r\n    public get isEnabled(): boolean {\r\n        return this._physicsPlugin.getEnabled(this);\r\n    }\r\n\r\n    /**\r\n     * Enables or disables collisions for the physics engine.\r\n     *\r\n     * @param isEnabled - A boolean value indicating whether collisions should be enabled or disabled.\r\n     *\r\n     */\r\n    public set isCollisionsEnabled(isEnabled: boolean) {\r\n        this._physicsPlugin.setCollisionsEnabled(this, isEnabled);\r\n    }\r\n\r\n    /**\r\n     * Gets whether collisions are enabled for this physics object.\r\n     *\r\n     * @returns `true` if collisions are enabled, `false` otherwise.\r\n     *\r\n     */\r\n    public get isCollisionsEnabled(): boolean {\r\n        return this._physicsPlugin.getCollisionsEnabled(this);\r\n    }\r\n\r\n    /**\r\n     * Gets all bodies that are using this constraint\r\n     * @returns\r\n     */\r\n    public getBodiesUsingConstraint(): ConstrainedBodyPair[] {\r\n        return this._physicsPlugin.getBodiesUsingConstraint(this);\r\n    }\r\n\r\n    /**\r\n     * Disposes the constraint from the physics engine.\r\n     *\r\n     * This method is useful for cleaning up the physics engine when a body is no longer needed. Disposing the body will free up resources and prevent memory leaks.\r\n     */\r\n    public dispose(): void {\r\n        this._physicsPlugin.disposeConstraint(this);\r\n    }\r\n}\r\n\r\n/**\r\n * This describes a single limit used by Physics6DoFConstraint\r\n */\r\nexport class Physics6DoFLimit {\r\n    /**\r\n     * The axis ID to limit\r\n     */\r\n    axis: PhysicsConstraintAxis;\r\n    /**\r\n     * An optional minimum limit for the axis.\r\n     * Corresponds to a distance in meters for linear axes, an angle in radians for angular axes.\r\n     */\r\n    minLimit?: number;\r\n    /**\r\n     * An optional maximum limit for the axis.\r\n     * Corresponds to a distance in meters for linear axes, an angle in radians for angular axes.\r\n     */\r\n    maxLimit?: number;\r\n    /**\r\n     * The stiffness of the constraint.\r\n     */\r\n    stiffness?: number;\r\n    /**\r\n     * A constraint parameter that specifies damping.\r\n     */\r\n    damping?: number;\r\n}\r\n\r\n/**\r\n * A generic constraint, which can be used to build more complex constraints than those specified\r\n * in PhysicsConstraintType. The axis and pivot options in PhysicsConstraintParameters define the space\r\n * the constraint operates in. This constraint contains a set of limits, which restrict the\r\n * relative movement of the bodies in that coordinate system\r\n */\r\nexport class Physics6DoFConstraint extends PhysicsConstraint {\r\n    /**\r\n     * The collection of limits which this constraint will apply\r\n     */\r\n    public limits: Physics6DoFLimit[];\r\n\r\n    constructor(constraintParams: PhysicsConstraintParameters, limits: Physics6DoFLimit[], scene: Scene) {\r\n        super(PhysicsConstraintType.SIX_DOF, constraintParams, scene);\r\n        this.limits = limits;\r\n    }\r\n\r\n    /**\r\n     * Sets the friction of the given axis of the physics engine.\r\n     * @param axis - The axis of the physics engine to set the friction for.\r\n     * @param friction - The friction to set for the given axis.\r\n     *\r\n     */\r\n    public setAxisFriction(axis: PhysicsConstraintAxis, friction: number): void {\r\n        this._physicsPlugin.setAxisFriction(this, axis, friction);\r\n    }\r\n\r\n    /**\r\n     * Gets the friction of the given axis of the physics engine.\r\n     * @param axis - The axis of the physics engine.\r\n     * @returns The friction of the given axis, or null if the constraint hasn't been initialized yet.\r\n     *\r\n     */\r\n    public getAxisFriction(axis: PhysicsConstraintAxis): Nullable<number> {\r\n        return this._physicsPlugin.getAxisFriction(this, axis);\r\n    }\r\n\r\n    /**\r\n     * Sets the limit mode for the given axis of the constraint.\r\n     * @param axis The axis to set the limit mode for.\r\n     * @param limitMode The limit mode to set.\r\n     *\r\n     * This method is useful for setting the limit mode for a given axis of the constraint. This is important for\r\n     * controlling the behavior of the physics engine when the constraint is reached. By setting the limit mode,\r\n     * the engine can be configured to either stop the motion of the objects, or to allow them to continue\r\n     * moving beyond the constraint.\r\n     */\r\n    public setAxisMode(axis: PhysicsConstraintAxis, limitMode: PhysicsConstraintAxisLimitMode): void {\r\n        this._physicsPlugin.setAxisMode(this, axis, limitMode);\r\n    }\r\n\r\n    /**\r\n     * Gets the limit mode of the given axis of the constraint.\r\n     *\r\n     * @param axis - The axis of the constraint.\r\n     * @returns The limit mode of the given axis, or null if the constraint hasn't been initialized yet.\r\n     *\r\n     */\r\n    public getAxisMode(axis: PhysicsConstraintAxis): Nullable<PhysicsConstraintAxisLimitMode> {\r\n        return this._physicsPlugin.getAxisMode(this, axis);\r\n    }\r\n\r\n    /**\r\n     * Sets the minimum limit of a given axis of a constraint.\r\n     * @param axis - The axis of the constraint.\r\n     * @param minLimit - The minimum limit of the axis.\r\n     *\r\n     */\r\n    public setAxisMinLimit(axis: PhysicsConstraintAxis, minLimit: number): void {\r\n        this._physicsPlugin.setAxisMinLimit(this, axis, minLimit);\r\n    }\r\n\r\n    /**\r\n     * Gets the minimum limit of the given axis of the physics engine.\r\n     * @param axis - The axis of the physics engine.\r\n     * @returns The minimum limit of the given axis, or null if the constraint hasn't been initialized yet.\r\n     *\r\n     */\r\n    public getAxisMinLimit(axis: PhysicsConstraintAxis): Nullable<number> {\r\n        return this._physicsPlugin.getAxisMinLimit(this, axis);\r\n    }\r\n\r\n    /**\r\n     * Sets the maximum limit of the given axis for the physics engine.\r\n     * @param axis - The axis to set the limit for.\r\n     * @param limit - The maximum limit of the axis.\r\n     *\r\n     * This method is useful for setting the maximum limit of the given axis for the physics engine,\r\n     * which can be used to control the movement of the physics object. This helps to ensure that the\r\n     * physics object does not move beyond the given limit.\r\n     */\r\n    public setAxisMaxLimit(axis: PhysicsConstraintAxis, limit: number): void {\r\n        this._physicsPlugin.setAxisMaxLimit(this, axis, limit);\r\n    }\r\n\r\n    /**\r\n     * Gets the maximum limit of the given axis of the physics engine.\r\n     * @param axis - The axis of the physics engine.\r\n     * @returns The maximum limit of the given axis, or null if the constraint hasn't been initialized yet.\r\n     *\r\n     */\r\n    public getAxisMaxLimit(axis: PhysicsConstraintAxis): Nullable<number> {\r\n        return this._physicsPlugin.getAxisMaxLimit(this, axis);\r\n    }\r\n\r\n    /**\r\n     * Sets the motor type of the given axis of the constraint.\r\n     * @param axis - The axis of the constraint.\r\n     * @param motorType - The type of motor to use.\r\n     */\r\n    public setAxisMotorType(axis: PhysicsConstraintAxis, motorType: PhysicsConstraintMotorType): void {\r\n        this._physicsPlugin.setAxisMotorType(this, axis, motorType);\r\n    }\r\n\r\n    /**\r\n     * Gets the motor type of the specified axis of the constraint.\r\n     *\r\n     * @param axis - The axis of the constraint.\r\n     * @returns The motor type of the specified axis, or null if the constraint hasn't been initialized yet.\r\n     *\r\n     */\r\n    public getAxisMotorType(axis: PhysicsConstraintAxis): Nullable<PhysicsConstraintMotorType> {\r\n        return this._physicsPlugin.getAxisMotorType(this, axis);\r\n    }\r\n\r\n    /**\r\n     * Sets the target velocity of the motor associated with the given axis of the constraint.\r\n     * @param axis - The axis of the constraint.\r\n     * @param target - The target velocity of the motor.\r\n     *\r\n     * This method is useful for setting the target velocity of the motor associated with the given axis of the constraint.\r\n     */\r\n    public setAxisMotorTarget(axis: PhysicsConstraintAxis, target: number): void {\r\n        this._physicsPlugin.setAxisMotorTarget(this, axis, target);\r\n    }\r\n\r\n    /**\r\n     * Gets the target velocity of the motor associated to the given constraint axis.\r\n     * @param axis - The constraint axis associated to the motor.\r\n     * @returns The target velocity of the motor, or null if the constraint hasn't been initialized yet.\r\n     *\r\n     */\r\n    public getAxisMotorTarget(axis: PhysicsConstraintAxis): Nullable<number> {\r\n        return this._physicsPlugin.getAxisMotorTarget(this, axis);\r\n    }\r\n\r\n    /**\r\n     * Sets the maximum force of the motor of the given axis of the constraint.\r\n     * @param axis - The axis of the constraint.\r\n     * @param maxForce - The maximum force of the motor.\r\n     *\r\n     */\r\n    public setAxisMotorMaxForce(axis: PhysicsConstraintAxis, maxForce: number): void {\r\n        this._physicsPlugin.setAxisMotorMaxForce(this, axis, maxForce);\r\n    }\r\n\r\n    /**\r\n     * Gets the maximum force of the motor of the given axis of the constraint.\r\n     * @param axis - The axis of the constraint.\r\n     * @returns The maximum force of the motor, or null if the constraint hasn't been initialized yet.\r\n     *\r\n     */\r\n    public getAxisMotorMaxForce(axis: PhysicsConstraintAxis): Nullable<number> {\r\n        return this._physicsPlugin.getAxisMotorMaxForce(this, axis);\r\n    }\r\n}\r\n\r\n/**\r\n * Represents a Ball and Socket Constraint, used to simulate a joint\r\n *\r\n * @param pivotA - The first pivot, defined locally in the first body frame\r\n * @param pivotB - The second pivot, defined locally in the second body frame\r\n * @param axisA - The axis of the first body\r\n * @param axisB - The axis of the second body\r\n * @param scene - The scene the constraint is applied to\r\n * @returns The Ball and Socket Constraint\r\n *\r\n * This class is useful for simulating a joint between two bodies in a physics engine.\r\n * It allows for the two bodies to move relative to each other in a way that mimics a ball and socket joint, such as a shoulder or hip joint.\r\n */\r\nexport class BallAndSocketConstraint extends PhysicsConstraint {\r\n    constructor(pivotA: Vector3, pivotB: Vector3, axisA: Vector3, axisB: Vector3, scene: Scene) {\r\n        super(PhysicsConstraintType.BALL_AND_SOCKET, { pivotA: pivotA, pivotB: pivotB, axisA: axisA, axisB: axisB }, scene);\r\n    }\r\n}\r\n\r\n/**\r\n * Creates a distance constraint.\r\n * @param maxDistance distance between bodies\r\n * @param scene The scene the constraint belongs to\r\n * @returns DistanceConstraint\r\n *\r\n * This code is useful for creating a distance constraint in a physics engine.\r\n * A distance constraint is a type of constraint that keeps two objects at a certain distance from each other.\r\n * The scene is used to add the constraint to the physics engine.\r\n */\r\nexport class DistanceConstraint extends PhysicsConstraint {\r\n    constructor(maxDistance: number, scene: Scene) {\r\n        super(PhysicsConstraintType.DISTANCE, { maxDistance: maxDistance }, scene);\r\n    }\r\n}\r\n\r\n/**\r\n * Creates a HingeConstraint, which is a type of PhysicsConstraint.\r\n *\r\n * @param pivotA - The first pivot point, in world space.\r\n * @param pivotB - The second pivot point, in world space.\r\n * @param scene - The scene the constraint is used in.\r\n * @returns The new HingeConstraint.\r\n *\r\n * This code is useful for creating a HingeConstraint, which is a type of PhysicsConstraint.\r\n * This constraint is used to simulate a hinge joint between two rigid bodies, allowing them to rotate around a single axis.\r\n */\r\nexport class HingeConstraint extends PhysicsConstraint {\r\n    constructor(pivotA: Vector3, pivotB: Vector3, axisA: Vector3, axisB: Vector3, scene: Scene) {\r\n        super(PhysicsConstraintType.HINGE, { pivotA: pivotA, pivotB: pivotB, axisA: axisA, axisB: axisB }, scene);\r\n    }\r\n}\r\n\r\n/**\r\n * Creates a SliderConstraint, which is a type of PhysicsConstraint.\r\n *\r\n * @param pivotA - The first pivot of the constraint, in world space.\r\n * @param pivotB - The second pivot of the constraint, in world space.\r\n * @param axisA - The first axis of the constraint, in world space.\r\n * @param axisB - The second axis of the constraint, in world space.\r\n * @param scene - The scene the constraint belongs to.\r\n * @returns The created SliderConstraint.\r\n *\r\n * This code is useful for creating a SliderConstraint, which is a type of PhysicsConstraint.\r\n * It allows the user to specify the two pivots and two axes of the constraint in world space, as well as the scene the constraint belongs to.\r\n * This is useful for creating a constraint between two rigid bodies that allows them to move along a certain axis.\r\n */\r\nexport class SliderConstraint extends PhysicsConstraint {\r\n    constructor(pivotA: Vector3, pivotB: Vector3, axisA: Vector3, axisB: Vector3, scene: Scene) {\r\n        super(PhysicsConstraintType.SLIDER, { pivotA: pivotA, pivotB: pivotB, axisA: axisA, axisB: axisB }, scene);\r\n    }\r\n}\r\n\r\n/**\r\n * Creates a LockConstraint, which is a type of PhysicsConstraint.\r\n *\r\n * @param pivotA - The first pivot of the constraint in local space.\r\n * @param pivotB - The second pivot of the constraint in local space.\r\n * @param axisA - The first axis of the constraint in local space.\r\n * @param axisB - The second axis of the constraint in local space.\r\n * @param scene - The scene the constraint belongs to.\r\n * @returns The created LockConstraint.\r\n *\r\n * This code is useful for creating a LockConstraint, which is a type of PhysicsConstraint.\r\n * It takes in two pivots and two axes in local space, as well as the scene the constraint belongs to, and creates a LockConstraint.\r\n */\r\nexport class LockConstraint extends PhysicsConstraint {\r\n    constructor(pivotA: Vector3, pivotB: Vector3, axisA: Vector3, axisB: Vector3, scene: Scene) {\r\n        super(PhysicsConstraintType.LOCK, { pivotA: pivotA, pivotB: pivotB, axisA: axisA, axisB: axisB }, scene);\r\n    }\r\n}\r\n\r\n/**\r\n * Creates a PrismaticConstraint, which is a type of PhysicsConstraint.\r\n *\r\n * @param pivotA - The first pivot of the constraint in local space.\r\n * @param pivotB - The second pivot of the constraint in local space.\r\n * @param axisA - The first axis of the constraint in local space.\r\n * @param axisB - The second axis of the constraint in local space.\r\n * @param scene - The scene the constraint belongs to.\r\n * @returns The created LockConstraint.\r\n *\r\n * This code is useful for creating a PrismaticConstraint, which is a type of PhysicsConstraint.\r\n * It takes in two pivots and two axes in local space, as well as the scene the constraint belongs to, and creates a PrismaticConstraint.\r\n */\r\nexport class PrismaticConstraint extends PhysicsConstraint {\r\n    constructor(pivotA: Vector3, pivotB: Vector3, axisA: Vector3, axisB: Vector3, scene: Scene) {\r\n        super(PhysicsConstraintType.PRISMATIC, { pivotA: pivotA, pivotB: pivotB, axisA: axisA, axisB: axisB }, scene);\r\n    }\r\n}\r\n\r\n/**\r\n * Creates a SpringConstraint, which is a type of Physics6DoFConstraint. This constraint applies a force at the ends which is proportional\r\n * to the distance between ends, and a stiffness and damping factor. The force is calculated as (stiffness * positionError) - (damping * velocity)\r\n *\r\n * @param pivotA - The first pivot of the constraint in local space.\r\n * @param pivotB - The second pivot of the constraint in local space.\r\n * @param axisA - The first axis of the constraint in local space.\r\n * @param axisB - The second axis of the constraint in local space.\r\n * @param minDistance - The minimum distance between the two pivots.\r\n * @param maxDistance - The maximum distance between the two pivots.\r\n * @param stiffness - The stiffness of the spring.\r\n * @param damping - The damping of the spring.\r\n * @param scene - The scene the constraint belongs to.\r\n * @returns The created SpringConstraint.\r\n */\r\nexport class SpringConstraint extends Physics6DoFConstraint {\r\n    constructor(pivotA: Vector3, pivotB: Vector3, axisA: Vector3, axisB: Vector3, minDistance: number, maxDistance: number, stiffness: number, damping: number, scene: Scene) {\r\n        super({ pivotA, pivotB, axisA, axisB }, [{ axis: PhysicsConstraintAxis.LINEAR_DISTANCE, minLimit: minDistance, maxLimit: maxDistance, stiffness, damping }], scene);\r\n    }\r\n}\r\n"]}
+{"version":3,"file":"physicsConstraint.js","sourceRoot":"","sources":["../../../../../dev/core/src/Physics/v2/physicsConstraint.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Scene } from \"../../scene\";\r\nimport type { Vector3 } from \"../../Maths/math.vector\";\r\nimport type { Nullable } from \"../../types\";\r\nimport type { IPhysicsEnginePluginV2, PhysicsConstraintParameters, PhysicsConstraintAxisLimitMode, PhysicsConstraintMotorType, ConstrainedBodyPair } from \"./IPhysicsEnginePlugin\";\r\nimport { PhysicsConstraintAxis, PhysicsConstraintType } from \"./IPhysicsEnginePlugin\";\r\n\r\n/**\r\n * This is a holder class for the physics constraint created by the physics plugin\r\n * It holds a set of functions to control the underlying constraint\r\n * @see https://doc.babylonjs.com/features/featuresDeepDive/physics/usingPhysicsEngine\r\n */\r\nexport class PhysicsConstraint {\r\n    /**\r\n     * V2 Physics plugin private data for a physics material\r\n     */\r\n    public _pluginData: any = undefined;\r\n    /**\r\n     * The V2 plugin used to create and manage this Physics Body\r\n     */\r\n    protected _physicsPlugin: IPhysicsEnginePluginV2;\r\n    protected _options: PhysicsConstraintParameters;\r\n    protected _type: PhysicsConstraintType;\r\n    /**\r\n     * @internal\r\n     * The internal options that were used to init the constraint\r\n     */\r\n    public _initOptions?: PhysicsConstraintParameters;\r\n\r\n    /**\r\n     * Constructs a new constraint for the physics constraint.\r\n     * @param type The type of constraint to create.\r\n     * @param options The options for the constraint.\r\n     * @param scene The scene the constraint belongs to.\r\n     *\r\n     * This code is useful for creating a new constraint for the physics engine. It checks if the scene has a physics engine, and if the plugin version is correct.\r\n     * If all checks pass, it initializes the constraint with the given type and options.\r\n     */\r\n    constructor(type: PhysicsConstraintType, options: PhysicsConstraintParameters, scene: Scene) {\r\n        if (!scene) {\r\n            throw new Error(\"Missing scene parameter for constraint constructor.\");\r\n        }\r\n        const physicsEngine = scene.getPhysicsEngine();\r\n        if (!physicsEngine) {\r\n            throw new Error(\"No Physics Engine available.\");\r\n        }\r\n        if (physicsEngine.getPluginVersion() != 2) {\r\n            throw new Error(\"Plugin version is incorrect. Expected version 2.\");\r\n        }\r\n        const physicsPlugin = physicsEngine.getPhysicsPlugin();\r\n        if (!physicsPlugin) {\r\n            throw new Error(\"No Physics Plugin available.\");\r\n        }\r\n\r\n        this._physicsPlugin = physicsPlugin as IPhysicsEnginePluginV2;\r\n        this._options = options;\r\n        this._type = type;\r\n    }\r\n\r\n    /**\r\n     * Gets the type of the constraint.\r\n     *\r\n     * @returns The type of the constraint.\r\n     *\r\n     */\r\n    public get type(): PhysicsConstraintType {\r\n        return this._type;\r\n    }\r\n\r\n    /**\r\n     * Retrieves the options of the physics constraint.\r\n     *\r\n     * @returns The physics constraint parameters.\r\n     *\r\n     */\r\n    public get options(): PhysicsConstraintParameters {\r\n        return this._options;\r\n    }\r\n\r\n    /**\r\n     * Enable/disable the constraint\r\n     * @param isEnabled value for the constraint\r\n     */\r\n    public set isEnabled(isEnabled: boolean) {\r\n        this._physicsPlugin.setEnabled(this, isEnabled);\r\n    }\r\n\r\n    /**\r\n     *\r\n     * @returns true if constraint is enabled\r\n     */\r\n    public get isEnabled(): boolean {\r\n        return this._physicsPlugin.getEnabled(this);\r\n    }\r\n\r\n    /**\r\n     * Enables or disables collisions for the physics engine.\r\n     *\r\n     * @param isEnabled - A boolean value indicating whether collisions should be enabled or disabled.\r\n     *\r\n     */\r\n    public set isCollisionsEnabled(isEnabled: boolean) {\r\n        this._physicsPlugin.setCollisionsEnabled(this, isEnabled);\r\n    }\r\n\r\n    /**\r\n     * Gets whether collisions are enabled for this physics object.\r\n     *\r\n     * @returns `true` if collisions are enabled, `false` otherwise.\r\n     *\r\n     */\r\n    public get isCollisionsEnabled(): boolean {\r\n        return this._physicsPlugin.getCollisionsEnabled(this);\r\n    }\r\n\r\n    /**\r\n     * Gets all bodies that are using this constraint\r\n     * @returns\r\n     */\r\n    public getBodiesUsingConstraint(): ConstrainedBodyPair[] {\r\n        return this._physicsPlugin.getBodiesUsingConstraint(this);\r\n    }\r\n\r\n    /**\r\n     * Disposes the constraint from the physics engine.\r\n     *\r\n     * This method is useful for cleaning up the physics engine when a body is no longer needed. Disposing the body will free up resources and prevent memory leaks.\r\n     */\r\n    public dispose(): void {\r\n        this._physicsPlugin.disposeConstraint(this);\r\n    }\r\n}\r\n\r\n/**\r\n * This describes a single limit used by Physics6DoFConstraint\r\n */\r\nexport class Physics6DoFLimit {\r\n    /**\r\n     * The axis ID to limit\r\n     */\r\n    axis: PhysicsConstraintAxis;\r\n    /**\r\n     * An optional minimum limit for the axis.\r\n     * Corresponds to a distance in meters for linear axes, an angle in radians for angular axes.\r\n     */\r\n    minLimit?: number;\r\n    /**\r\n     * An optional maximum limit for the axis.\r\n     * Corresponds to a distance in meters for linear axes, an angle in radians for angular axes.\r\n     */\r\n    maxLimit?: number;\r\n    /**\r\n     * The stiffness of the constraint.\r\n     */\r\n    stiffness?: number;\r\n    /**\r\n     * A constraint parameter that specifies damping.\r\n     */\r\n    damping?: number;\r\n}\r\n\r\n/**\r\n * A generic constraint, which can be used to build more complex constraints than those specified\r\n * in PhysicsConstraintType. The axis and pivot options in PhysicsConstraintParameters define the space\r\n * the constraint operates in. This constraint contains a set of limits, which restrict the\r\n * relative movement of the bodies in that coordinate system\r\n */\r\nexport class Physics6DoFConstraint extends PhysicsConstraint {\r\n    /**\r\n     * The collection of limits which this constraint will apply\r\n     */\r\n    public limits: Physics6DoFLimit[];\r\n\r\n    constructor(constraintParams: PhysicsConstraintParameters, limits: Physics6DoFLimit[], scene: Scene) {\r\n        super(PhysicsConstraintType.SIX_DOF, constraintParams, scene);\r\n        this.limits = limits;\r\n    }\r\n\r\n    /**\r\n     * Sets the friction of the given axis of the physics engine.\r\n     * @param axis - The axis of the physics engine to set the friction for.\r\n     * @param friction - The friction to set for the given axis.\r\n     *\r\n     */\r\n    public setAxisFriction(axis: PhysicsConstraintAxis, friction: number): void {\r\n        this._physicsPlugin.setAxisFriction(this, axis, friction);\r\n    }\r\n\r\n    /**\r\n     * Gets the friction of the given axis of the physics engine.\r\n     * @param axis - The axis of the physics engine.\r\n     * @returns The friction of the given axis, or null if the constraint hasn't been initialized yet.\r\n     *\r\n     */\r\n    public getAxisFriction(axis: PhysicsConstraintAxis): Nullable<number> {\r\n        return this._physicsPlugin.getAxisFriction(this, axis);\r\n    }\r\n\r\n    /**\r\n     * Sets the limit mode for the given axis of the constraint.\r\n     * @param axis The axis to set the limit mode for.\r\n     * @param limitMode The limit mode to set.\r\n     *\r\n     * This method is useful for setting the limit mode for a given axis of the constraint. This is important for\r\n     * controlling the behavior of the physics engine when the constraint is reached. By setting the limit mode,\r\n     * the engine can be configured to either stop the motion of the objects, or to allow them to continue\r\n     * moving beyond the constraint.\r\n     */\r\n    public setAxisMode(axis: PhysicsConstraintAxis, limitMode: PhysicsConstraintAxisLimitMode): void {\r\n        this._physicsPlugin.setAxisMode(this, axis, limitMode);\r\n    }\r\n\r\n    /**\r\n     * Gets the limit mode of the given axis of the constraint.\r\n     *\r\n     * @param axis - The axis of the constraint.\r\n     * @returns The limit mode of the given axis, or null if the constraint hasn't been initialized yet.\r\n     *\r\n     */\r\n    public getAxisMode(axis: PhysicsConstraintAxis): Nullable<PhysicsConstraintAxisLimitMode> {\r\n        return this._physicsPlugin.getAxisMode(this, axis);\r\n    }\r\n\r\n    /**\r\n     * Sets the minimum limit of a given axis of a constraint.\r\n     * @param axis - The axis of the constraint.\r\n     * @param minLimit - The minimum limit of the axis.\r\n     *\r\n     */\r\n    public setAxisMinLimit(axis: PhysicsConstraintAxis, minLimit: number): void {\r\n        this._physicsPlugin.setAxisMinLimit(this, axis, minLimit);\r\n    }\r\n\r\n    /**\r\n     * Gets the minimum limit of the given axis of the physics engine.\r\n     * @param axis - The axis of the physics engine.\r\n     * @returns The minimum limit of the given axis, or null if the constraint hasn't been initialized yet.\r\n     *\r\n     */\r\n    public getAxisMinLimit(axis: PhysicsConstraintAxis): Nullable<number> {\r\n        return this._physicsPlugin.getAxisMinLimit(this, axis);\r\n    }\r\n\r\n    /**\r\n     * Sets the maximum limit of the given axis for the physics engine.\r\n     * @param axis - The axis to set the limit for.\r\n     * @param limit - The maximum limit of the axis.\r\n     *\r\n     * This method is useful for setting the maximum limit of the given axis for the physics engine,\r\n     * which can be used to control the movement of the physics object. This helps to ensure that the\r\n     * physics object does not move beyond the given limit.\r\n     */\r\n    public setAxisMaxLimit(axis: PhysicsConstraintAxis, limit: number): void {\r\n        this._physicsPlugin.setAxisMaxLimit(this, axis, limit);\r\n    }\r\n\r\n    /**\r\n     * Gets the maximum limit of the given axis of the physics engine.\r\n     * @param axis - The axis of the physics engine.\r\n     * @returns The maximum limit of the given axis, or null if the constraint hasn't been initialized yet.\r\n     *\r\n     */\r\n    public getAxisMaxLimit(axis: PhysicsConstraintAxis): Nullable<number> {\r\n        return this._physicsPlugin.getAxisMaxLimit(this, axis);\r\n    }\r\n\r\n    /**\r\n     * Sets the motor type of the given axis of the constraint.\r\n     * @param axis - The axis of the constraint.\r\n     * @param motorType - The type of motor to use.\r\n     */\r\n    public setAxisMotorType(axis: PhysicsConstraintAxis, motorType: PhysicsConstraintMotorType): void {\r\n        this._physicsPlugin.setAxisMotorType(this, axis, motorType);\r\n    }\r\n\r\n    /**\r\n     * Gets the motor type of the specified axis of the constraint.\r\n     *\r\n     * @param axis - The axis of the constraint.\r\n     * @returns The motor type of the specified axis, or null if the constraint hasn't been initialized yet.\r\n     *\r\n     */\r\n    public getAxisMotorType(axis: PhysicsConstraintAxis): Nullable<PhysicsConstraintMotorType> {\r\n        return this._physicsPlugin.getAxisMotorType(this, axis);\r\n    }\r\n\r\n    /**\r\n     * Sets the target velocity of the motor associated with the given axis of the constraint.\r\n     * @param axis - The axis of the constraint.\r\n     * @param target - The target velocity of the motor.\r\n     *\r\n     * This method is useful for setting the target velocity of the motor associated with the given axis of the constraint.\r\n     */\r\n    public setAxisMotorTarget(axis: PhysicsConstraintAxis, target: number): void {\r\n        this._physicsPlugin.setAxisMotorTarget(this, axis, target);\r\n    }\r\n\r\n    /**\r\n     * Gets the target velocity of the motor associated to the given constraint axis.\r\n     * @param axis - The constraint axis associated to the motor.\r\n     * @returns The target velocity of the motor, or null if the constraint hasn't been initialized yet.\r\n     *\r\n     */\r\n    public getAxisMotorTarget(axis: PhysicsConstraintAxis): Nullable<number> {\r\n        return this._physicsPlugin.getAxisMotorTarget(this, axis);\r\n    }\r\n\r\n    /**\r\n     * Sets the maximum force of the motor of the given axis of the constraint.\r\n     * @param axis - The axis of the constraint.\r\n     * @param maxForce - The maximum force of the motor.\r\n     *\r\n     */\r\n    public setAxisMotorMaxForce(axis: PhysicsConstraintAxis, maxForce: number): void {\r\n        this._physicsPlugin.setAxisMotorMaxForce(this, axis, maxForce);\r\n    }\r\n\r\n    /**\r\n     * Gets the maximum force of the motor of the given axis of the constraint.\r\n     * @param axis - The axis of the constraint.\r\n     * @returns The maximum force of the motor, or null if the constraint hasn't been initialized yet.\r\n     *\r\n     */\r\n    public getAxisMotorMaxForce(axis: PhysicsConstraintAxis): Nullable<number> {\r\n        return this._physicsPlugin.getAxisMotorMaxForce(this, axis);\r\n    }\r\n}\r\n\r\n/**\r\n * Represents a Ball and Socket Constraint, used to simulate a joint\r\n * This class is useful for simulating a joint between two bodies in a physics engine.\r\n * It allows for the two bodies to move relative to each other in a way that mimics a ball and socket joint, such as a shoulder or hip joint.\r\n * @param pivotA - The first pivot, defined locally in the first body frame\r\n * @param pivotB - The second pivot, defined locally in the second body frame\r\n * @param axisA - The axis of the first body\r\n * @param axisB - The axis of the second body\r\n * @param scene - The scene the constraint is applied to\r\n * @returns The Ball and Socket Constraint\r\n */\r\nexport class BallAndSocketConstraint extends PhysicsConstraint {\r\n    constructor(pivotA: Vector3, pivotB: Vector3, axisA: Vector3, axisB: Vector3, scene: Scene) {\r\n        super(PhysicsConstraintType.BALL_AND_SOCKET, { pivotA: pivotA, pivotB: pivotB, axisA: axisA, axisB: axisB }, scene);\r\n    }\r\n}\r\n\r\n/**\r\n * Creates a distance constraint.\r\n *\r\n * This code is useful for creating a distance constraint in a physics engine.\r\n * A distance constraint is a type of constraint that keeps two objects at a certain distance from each other.\r\n * The scene is used to add the constraint to the physics engine.\r\n * @param maxDistance distance between bodies\r\n * @param scene The scene the constraint belongs to\r\n * @returns DistanceConstraint\r\n */\r\nexport class DistanceConstraint extends PhysicsConstraint {\r\n    constructor(maxDistance: number, scene: Scene) {\r\n        super(PhysicsConstraintType.DISTANCE, { maxDistance: maxDistance }, scene);\r\n    }\r\n}\r\n\r\n/**\r\n * Creates a HingeConstraint, which is a type of PhysicsConstraint.\r\n *\r\n * This code is useful for creating a HingeConstraint, which is a type of PhysicsConstraint.\r\n * This constraint is used to simulate a hinge joint between two rigid bodies, allowing them to rotate around a single axis.\r\n * @param pivotA - The first pivot point, in world space.\r\n * @param pivotB - The second pivot point, in world space.\r\n * @param scene - The scene the constraint is used in.\r\n * @returns The new HingeConstraint.\r\n */\r\nexport class HingeConstraint extends PhysicsConstraint {\r\n    constructor(pivotA: Vector3, pivotB: Vector3, axisA: Vector3, axisB: Vector3, scene: Scene) {\r\n        super(PhysicsConstraintType.HINGE, { pivotA: pivotA, pivotB: pivotB, axisA: axisA, axisB: axisB }, scene);\r\n    }\r\n}\r\n\r\n/**\r\n * Creates a SliderConstraint, which is a type of PhysicsConstraint.\r\n *\r\n * This code is useful for creating a SliderConstraint, which is a type of PhysicsConstraint.\r\n * It allows the user to specify the two pivots and two axes of the constraint in world space, as well as the scene the constraint belongs to.\r\n * This is useful for creating a constraint between two rigid bodies that allows them to move along a certain axis.\r\n * @param pivotA - The first pivot of the constraint, in world space.\r\n * @param pivotB - The second pivot of the constraint, in world space.\r\n * @param axisA - The first axis of the constraint, in world space.\r\n * @param axisB - The second axis of the constraint, in world space.\r\n * @param scene - The scene the constraint belongs to.\r\n * @returns The created SliderConstraint.\r\n */\r\nexport class SliderConstraint extends PhysicsConstraint {\r\n    constructor(pivotA: Vector3, pivotB: Vector3, axisA: Vector3, axisB: Vector3, scene: Scene) {\r\n        super(PhysicsConstraintType.SLIDER, { pivotA: pivotA, pivotB: pivotB, axisA: axisA, axisB: axisB }, scene);\r\n    }\r\n}\r\n\r\n/**\r\n * Creates a LockConstraint, which is a type of PhysicsConstraint.\r\n *\r\n * This code is useful for creating a LockConstraint, which is a type of PhysicsConstraint.\r\n * It takes in two pivots and two axes in local space, as well as the scene the constraint belongs to, and creates a LockConstraint.\r\n * @param pivotA - The first pivot of the constraint in local space.\r\n * @param pivotB - The second pivot of the constraint in local space.\r\n * @param axisA - The first axis of the constraint in local space.\r\n * @param axisB - The second axis of the constraint in local space.\r\n * @param scene - The scene the constraint belongs to.\r\n * @returns The created LockConstraint.\r\n */\r\nexport class LockConstraint extends PhysicsConstraint {\r\n    constructor(pivotA: Vector3, pivotB: Vector3, axisA: Vector3, axisB: Vector3, scene: Scene) {\r\n        super(PhysicsConstraintType.LOCK, { pivotA: pivotA, pivotB: pivotB, axisA: axisA, axisB: axisB }, scene);\r\n    }\r\n}\r\n\r\n/**\r\n * Creates a PrismaticConstraint, which is a type of PhysicsConstraint.\r\n *\r\n * This code is useful for creating a PrismaticConstraint, which is a type of PhysicsConstraint.\r\n * It takes in two pivots and two axes in local space, as well as the scene the constraint belongs to, and creates a PrismaticConstraint.\r\n * @param pivotA - The first pivot of the constraint in local space.\r\n * @param pivotB - The second pivot of the constraint in local space.\r\n * @param axisA - The first axis of the constraint in local space.\r\n * @param axisB - The second axis of the constraint in local space.\r\n * @param scene - The scene the constraint belongs to.\r\n * @returns The created LockConstraint.\r\n */\r\nexport class PrismaticConstraint extends PhysicsConstraint {\r\n    constructor(pivotA: Vector3, pivotB: Vector3, axisA: Vector3, axisB: Vector3, scene: Scene) {\r\n        super(PhysicsConstraintType.PRISMATIC, { pivotA: pivotA, pivotB: pivotB, axisA: axisA, axisB: axisB }, scene);\r\n    }\r\n}\r\n\r\n/**\r\n * Creates a SpringConstraint, which is a type of Physics6DoFConstraint. This constraint applies a force at the ends which is proportional\r\n * to the distance between ends, and a stiffness and damping factor. The force is calculated as (stiffness * positionError) - (damping * velocity)\r\n *\r\n * @param pivotA - The first pivot of the constraint in local space.\r\n * @param pivotB - The second pivot of the constraint in local space.\r\n * @param axisA - The first axis of the constraint in local space.\r\n * @param axisB - The second axis of the constraint in local space.\r\n * @param minDistance - The minimum distance between the two pivots.\r\n * @param maxDistance - The maximum distance between the two pivots.\r\n * @param stiffness - The stiffness of the spring.\r\n * @param damping - The damping of the spring.\r\n * @param scene - The scene the constraint belongs to.\r\n * @returns The created SpringConstraint.\r\n */\r\nexport class SpringConstraint extends Physics6DoFConstraint {\r\n    constructor(pivotA: Vector3, pivotB: Vector3, axisA: Vector3, axisB: Vector3, minDistance: number, maxDistance: number, stiffness: number, damping: number, scene: Scene) {\r\n        super({ pivotA, pivotB, axisA, axisB }, [{ axis: PhysicsConstraintAxis.LINEAR_DISTANCE, minLimit: minDistance, maxLimit: maxDistance, stiffness, damping }], scene);\r\n    }\r\n}\r\n"]}

package/PostProcesses/anaglyphPostProcess.d.ts

@@ -2,7 +2,6 @@ import type { Engine } from "../Engines/engine";
 import type { PostProcessOptions } from "./postProcess";
 import { PostProcess } from "./postProcess";
 import type { Camera } from "../Cameras/camera";
-import "../Shaders/anaglyph.fragment";
 /**
  * Postprocess used to generate anaglyphic rendering
  */
@@ -23,5 +22,5 @@ export declare class AnaglyphPostProcess extends PostProcess {
      * @param reusable defines if the postprocess will be reused multiple times per frame
      */
     constructor(name: string, options: number | PostProcessOptions, rigCameras: Camera[], samplingMode?: number, engine?: Engine, reusable?: boolean);
-    protected _initShaderSourceAsync(useWebGPU: boolean): Promise<void>;
+    protected _gatherImports(useWebGPU: boolean, list: Promise<any>[]): void;
 }

package/PostProcesses/anaglyphPostProcess.js

@@ -1,5 +1,4 @@
 import { PostProcess } from "./postProcess.js";
-import "../Shaders/anaglyph.fragment.js";
 import { RegisterClass } from "../Misc/typeStore.js";
 /**
  * Postprocess used to generate anaglyphic rendering
@@ -28,15 +27,15 @@ export class AnaglyphPostProcess extends PostProcess {
             effect.setTextureFromPostProcess("leftSampler", this._passedProcess);
         });
     }
-    async _initShaderSourceAsync(useWebGPU) {
+    _gatherImports(useWebGPU, list) {
         if (useWebGPU) {
             this._webGPUReady = true;
-            await import("../ShadersWGSL/anaglyph.fragment.js");
+            list.push(import("../ShadersWGSL/anaglyph.fragment.js"));
         }
         else {
-            await import("../Shaders/anaglyph.fragment.js");
+            list.push(import("../Shaders/anaglyph.fragment.js"));
         }
-        super._initShaderSourceAsync(useWebGPU);
+        super._gatherImports(useWebGPU, list);
     }
 }
 RegisterClass("BABYLON.AnaglyphPostProcess", AnaglyphPostProcess);

package/PostProcesses/anaglyphPostProcess.js.map

@@ -1 +1 @@
-{"version":3,"file":"anaglyphPostProcess.js","sourceRoot":"","sources":["../../../../dev/core/src/PostProcesses/anaglyphPostProcess.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAI5C,OAAO,8BAA8B,CAAC;AACtC,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAElD;;GAEG;AACH,MAAM,OAAO,mBAAoB,SAAQ,WAAW;IAGhD;;;OAGG;IACa,YAAY;QACxB,OAAO,qBAAqB,CAAC;IACjC,CAAC;IAED;;;;;;;;OAQG;IACH,YAAY,IAAY,EAAE,OAAoC,EAAE,UAAoB,EAAE,YAAqB,EAAE,MAAe,EAAE,QAAkB;QAC5I,KAAK,CAAC,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,CAAC,aAAa,CAAC,EAAE,OAAO,EAAE,UAAU,CAAC,CAAC,CAAC,EAAE,YAAY,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC;QACvG,IAAI,CAAC,cAAc,GAAG,UAAU,CAAC,CAAC,CAAC,CAAC,eAAe,CAAC;QAEpD,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,CAAC,MAAc,EAAE,EAAE;YAC1C,MAAM,CAAC,yBAAyB,CAAC,aAAa,EAAE,IAAI,CAAC,cAAc,CAAC,CAAC;QACzE,CAAC,CAAC,CAAC;IACP,CAAC;IAEkB,KAAK,CAAC,sBAAsB,CAAC,SAAkB;QAC9D,IAAI,SAAS,EAAE;YACX,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC;YACzB,MAAM,MAAM,CAAC,kCAAkC,CAAC,CAAC;SACpD;aAAM;YACH,MAAM,MAAM,CAAC,8BAA8B,CAAC,CAAC;SAChD;QAED,KAAK,CAAC,sBAAsB,CAAC,SAAS,CAAC,CAAC;IAC5C,CAAC;CACJ;AAED,aAAa,CAAC,6BAA6B,EAAE,mBAAmB,CAAC,CAAC","sourcesContent":["import type { Nullable } from \"../types\";\r\nimport type { Engine } from \"../Engines/engine\";\r\nimport type { PostProcessOptions } from \"./postProcess\";\r\nimport { PostProcess } from \"./postProcess\";\r\nimport type { Camera } from \"../Cameras/camera\";\r\nimport type { Effect } from \"../Materials/effect\";\r\n\r\nimport \"../Shaders/anaglyph.fragment\";\r\nimport { RegisterClass } from \"../Misc/typeStore\";\r\n\r\n/**\r\n * Postprocess used to generate anaglyphic rendering\r\n */\r\nexport class AnaglyphPostProcess extends PostProcess {\r\n    private _passedProcess: Nullable<PostProcess>;\r\n\r\n    /**\r\n     * Gets a string identifying the name of the class\r\n     * @returns \"AnaglyphPostProcess\" string\r\n     */\r\n    public override getClassName(): string {\r\n        return \"AnaglyphPostProcess\";\r\n    }\r\n\r\n    /**\r\n     * Creates a new AnaglyphPostProcess\r\n     * @param name defines postprocess name\r\n     * @param options defines creation options or target ratio scale\r\n     * @param rigCameras defines cameras using this postprocess\r\n     * @param samplingMode defines required sampling mode (BABYLON.Texture.NEAREST_SAMPLINGMODE by default)\r\n     * @param engine defines hosting engine\r\n     * @param reusable defines if the postprocess will be reused multiple times per frame\r\n     */\r\n    constructor(name: string, options: number | PostProcessOptions, rigCameras: Camera[], samplingMode?: number, engine?: Engine, reusable?: boolean) {\r\n        super(name, \"anaglyph\", null, [\"leftSampler\"], options, rigCameras[1], samplingMode, engine, reusable);\r\n        this._passedProcess = rigCameras[0]._rigPostProcess;\r\n\r\n        this.onApplyObservable.add((effect: Effect) => {\r\n            effect.setTextureFromPostProcess(\"leftSampler\", this._passedProcess);\r\n        });\r\n    }\r\n\r\n    protected override async _initShaderSourceAsync(useWebGPU: boolean) {\r\n        if (useWebGPU) {\r\n            this._webGPUReady = true;\r\n            await import(\"../ShadersWGSL/anaglyph.fragment\");\r\n        } else {\r\n            await import(\"../Shaders/anaglyph.fragment\");\r\n        }\r\n\r\n        super._initShaderSourceAsync(useWebGPU);\r\n    }\r\n}\r\n\r\nRegisterClass(\"BABYLON.AnaglyphPostProcess\", AnaglyphPostProcess);\r\n"]}
+{"version":3,"file":"anaglyphPostProcess.js","sourceRoot":"","sources":["../../../../dev/core/src/PostProcesses/anaglyphPostProcess.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAG5C,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAElD;;GAEG;AACH,MAAM,OAAO,mBAAoB,SAAQ,WAAW;IAGhD;;;OAGG;IACa,YAAY;QACxB,OAAO,qBAAqB,CAAC;IACjC,CAAC;IAED;;;;;;;;OAQG;IACH,YAAY,IAAY,EAAE,OAAoC,EAAE,UAAoB,EAAE,YAAqB,EAAE,MAAe,EAAE,QAAkB;QAC5I,KAAK,CAAC,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,CAAC,aAAa,CAAC,EAAE,OAAO,EAAE,UAAU,CAAC,CAAC,CAAC,EAAE,YAAY,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC;QACvG,IAAI,CAAC,cAAc,GAAG,UAAU,CAAC,CAAC,CAAC,CAAC,eAAe,CAAC;QAEpD,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,CAAC,MAAc,EAAE,EAAE;YAC1C,MAAM,CAAC,yBAAyB,CAAC,aAAa,EAAE,IAAI,CAAC,cAAc,CAAC,CAAC;QACzE,CAAC,CAAC,CAAC;IACP,CAAC;IAEkB,cAAc,CAAC,SAAkB,EAAE,IAAoB;QACtE,IAAI,SAAS,EAAE;YACX,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC;YACzB,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,kCAAkC,CAAC,CAAC,CAAC;SACzD;aAAM;YACH,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,8BAA8B,CAAC,CAAC,CAAC;SACrD;QAED,KAAK,CAAC,cAAc,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC;IAC1C,CAAC;CACJ;AAED,aAAa,CAAC,6BAA6B,EAAE,mBAAmB,CAAC,CAAC","sourcesContent":["import type { Nullable } from \"../types\";\r\nimport type { Engine } from \"../Engines/engine\";\r\nimport type { PostProcessOptions } from \"./postProcess\";\r\nimport { PostProcess } from \"./postProcess\";\r\nimport type { Camera } from \"../Cameras/camera\";\r\nimport type { Effect } from \"../Materials/effect\";\r\nimport { RegisterClass } from \"../Misc/typeStore\";\r\n\r\n/**\r\n * Postprocess used to generate anaglyphic rendering\r\n */\r\nexport class AnaglyphPostProcess extends PostProcess {\r\n    private _passedProcess: Nullable<PostProcess>;\r\n\r\n    /**\r\n     * Gets a string identifying the name of the class\r\n     * @returns \"AnaglyphPostProcess\" string\r\n     */\r\n    public override getClassName(): string {\r\n        return \"AnaglyphPostProcess\";\r\n    }\r\n\r\n    /**\r\n     * Creates a new AnaglyphPostProcess\r\n     * @param name defines postprocess name\r\n     * @param options defines creation options or target ratio scale\r\n     * @param rigCameras defines cameras using this postprocess\r\n     * @param samplingMode defines required sampling mode (BABYLON.Texture.NEAREST_SAMPLINGMODE by default)\r\n     * @param engine defines hosting engine\r\n     * @param reusable defines if the postprocess will be reused multiple times per frame\r\n     */\r\n    constructor(name: string, options: number | PostProcessOptions, rigCameras: Camera[], samplingMode?: number, engine?: Engine, reusable?: boolean) {\r\n        super(name, \"anaglyph\", null, [\"leftSampler\"], options, rigCameras[1], samplingMode, engine, reusable);\r\n        this._passedProcess = rigCameras[0]._rigPostProcess;\r\n\r\n        this.onApplyObservable.add((effect: Effect) => {\r\n            effect.setTextureFromPostProcess(\"leftSampler\", this._passedProcess);\r\n        });\r\n    }\r\n\r\n    protected override _gatherImports(useWebGPU: boolean, list: Promise<any>[]) {\r\n        if (useWebGPU) {\r\n            this._webGPUReady = true;\r\n            list.push(import(\"../ShadersWGSL/anaglyph.fragment\"));\r\n        } else {\r\n            list.push(import(\"../Shaders/anaglyph.fragment\"));\r\n        }\r\n\r\n        super._gatherImports(useWebGPU, list);\r\n    }\r\n}\r\n\r\nRegisterClass(\"BABYLON.AnaglyphPostProcess\", AnaglyphPostProcess);\r\n"]}

package/PostProcesses/blackAndWhitePostProcess.d.ts

@@ -28,7 +28,7 @@ export declare class BlackAndWhitePostProcess extends PostProcess {
      * @param reusable If the post process can be reused on the same frame. (default: false)
      */
     constructor(name: string, options: number | PostProcessOptions, camera: Nullable<Camera>, samplingMode?: number, engine?: AbstractEngine, reusable?: boolean);
-    protected _initShaderSourceAsync(useWebGPU: boolean): Promise<void>;
+    protected _gatherImports(useWebGPU: boolean, list: Promise<any>[]): void;
     /**
      * @internal
      */

package/PostProcesses/blackAndWhitePostProcess.js

@@ -34,15 +34,15 @@ export class BlackAndWhitePostProcess extends PostProcess {
             effect.setFloat("degree", this.degree);
         });
     }
-    async _initShaderSourceAsync(useWebGPU) {
+    _gatherImports(useWebGPU, list) {
         if (useWebGPU) {
             this._webGPUReady = true;
-            await import("../ShadersWGSL/blackAndWhite.fragment.js");
+            list.push(import("../ShadersWGSL/blackAndWhite.fragment.js"));
         }
         else {
-            await import("../Shaders/blackAndWhite.fragment.js");
+            list.push(import("../Shaders/blackAndWhite.fragment.js"));
         }
-        super._initShaderSourceAsync(useWebGPU);
+        super._gatherImports(useWebGPU, list);
     }
     /**
      * @internal

package/PostProcesses/blackAndWhitePostProcess.js.map

@@ -1 +1 @@
-{"version":3,"file":"blackAndWhitePostProcess.js","sourceRoot":"","sources":["../../../../dev/core/src/PostProcesses/blackAndWhitePostProcess.ts"],"names":[],"mappings":";AACA,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAK5C,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAClD,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAC/C,OAAO,EAAE,mBAAmB,EAAE,MAAM,kCAAkC,CAAC;AAKvE;;GAEG;AACH,MAAM,OAAO,wBAAyB,SAAQ,WAAW;IAOrD;;;OAGG;IACa,YAAY;QACxB,OAAO,0BAA0B,CAAC;IACtC,CAAC;IAED;;;;;;;;;OASG;IACH,YAAY,IAAY,EAAE,OAAoC,EAAE,MAAwB,EAAE,YAAqB,EAAE,MAAuB,EAAE,QAAkB;QACxJ,KAAK,CAAC,IAAI,EAAE,eAAe,EAAE,CAAC,QAAQ,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC;QAzBpG;;WAEG;QAEI,WAAM,GAAG,CAAC,CAAC;QAuBd,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,CAAC,MAAc,EAAE,EAAE;YAC1C,MAAM,CAAC,QAAQ,CAAC,QAAQ,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;QAC3C,CAAC,CAAC,CAAC;IACP,CAAC;IAEkB,KAAK,CAAC,sBAAsB,CAAC,SAAkB;QAC9D,IAAI,SAAS,EAAE;YACX,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC;YACzB,MAAM,MAAM,CAAC,uCAAuC,CAAC,CAAC;SACzD;aAAM;YACH,MAAM,MAAM,CAAC,mCAAmC,CAAC,CAAC;SACrD;QAED,KAAK,CAAC,sBAAsB,CAAC,SAAS,CAAC,CAAC;IAC5C,CAAC;IAED;;OAEG;IACI,MAAM,CAAU,MAAM,CAAC,iBAAsB,EAAE,YAAoB,EAAE,KAAY,EAAE,OAAe;QACrG,OAAO,mBAAmB,CAAC,KAAK,CAC5B,GAAG,EAAE;YACD,OAAO,IAAI,wBAAwB,CAC/B,iBAAiB,CAAC,IAAI,EACtB,iBAAiB,CAAC,OAAO,EACzB,YAAY,EACZ,iBAAiB,CAAC,wBAAwB,EAC1C,KAAK,CAAC,SAAS,EAAE,EACjB,iBAAiB,CAAC,QAAQ,CAC7B,CAAC;QACN,CAAC,EACD,iBAAiB,EACjB,KAAK,EACL,OAAO,CACV,CAAC;IACN,CAAC;CACJ;AA3DU;IADN,SAAS,EAAE;wDACM;AA6DtB,aAAa,CAAC,kCAAkC,EAAE,wBAAwB,CAAC,CAAC","sourcesContent":["import type { PostProcessOptions } from \"./postProcess\";\r\nimport { PostProcess } from \"./postProcess\";\r\nimport type { Camera } from \"../Cameras/camera\";\r\nimport type { Effect } from \"../Materials/effect\";\r\nimport type { AbstractEngine } from \"../Engines/abstractEngine\";\r\n\r\nimport { RegisterClass } from \"../Misc/typeStore\";\r\nimport { serialize } from \"../Misc/decorators\";\r\nimport { SerializationHelper } from \"../Misc/decorators.serialization\";\r\nimport type { Nullable } from \"../types\";\r\n\r\nimport type { Scene } from \"../scene\";\r\n\r\n/**\r\n * Post process used to render in black and white\r\n */\r\nexport class BlackAndWhitePostProcess extends PostProcess {\r\n    /**\r\n     * Linear about to convert he result to black and white (default: 1)\r\n     */\r\n    @serialize()\r\n    public degree = 1;\r\n\r\n    /**\r\n     * Gets a string identifying the name of the class\r\n     * @returns \"BlackAndWhitePostProcess\" string\r\n     */\r\n    public override getClassName(): string {\r\n        return \"BlackAndWhitePostProcess\";\r\n    }\r\n\r\n    /**\r\n     * Creates a black and white post process\r\n     * @see https://doc.babylonjs.com/features/featuresDeepDive/postProcesses/usePostProcesses#black-and-white\r\n     * @param name The name of the effect.\r\n     * @param options The required width/height ratio to downsize to before computing the render pass.\r\n     * @param camera The camera to apply the render pass to.\r\n     * @param samplingMode The sampling mode to be used when computing the pass. (default: 0)\r\n     * @param engine The engine which the post process will be applied. (default: current engine)\r\n     * @param reusable If the post process can be reused on the same frame. (default: false)\r\n     */\r\n    constructor(name: string, options: number | PostProcessOptions, camera: Nullable<Camera>, samplingMode?: number, engine?: AbstractEngine, reusable?: boolean) {\r\n        super(name, \"blackAndWhite\", [\"degree\"], null, options, camera, samplingMode, engine, reusable);\r\n\r\n        this.onApplyObservable.add((effect: Effect) => {\r\n            effect.setFloat(\"degree\", this.degree);\r\n        });\r\n    }\r\n\r\n    protected override async _initShaderSourceAsync(useWebGPU: boolean) {\r\n        if (useWebGPU) {\r\n            this._webGPUReady = true;\r\n            await import(\"../ShadersWGSL/blackAndWhite.fragment\");\r\n        } else {\r\n            await import(\"../Shaders/blackAndWhite.fragment\");\r\n        }\r\n\r\n        super._initShaderSourceAsync(useWebGPU);\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    public static override _Parse(parsedPostProcess: any, targetCamera: Camera, scene: Scene, rootUrl: string): Nullable<BlackAndWhitePostProcess> {\r\n        return SerializationHelper.Parse(\r\n            () => {\r\n                return new BlackAndWhitePostProcess(\r\n                    parsedPostProcess.name,\r\n                    parsedPostProcess.options,\r\n                    targetCamera,\r\n                    parsedPostProcess.renderTargetSamplingMode,\r\n                    scene.getEngine(),\r\n                    parsedPostProcess.reusable\r\n                );\r\n            },\r\n            parsedPostProcess,\r\n            scene,\r\n            rootUrl\r\n        );\r\n    }\r\n}\r\n\r\nRegisterClass(\"BABYLON.BlackAndWhitePostProcess\", BlackAndWhitePostProcess);\r\n"]}
+{"version":3,"file":"blackAndWhitePostProcess.js","sourceRoot":"","sources":["../../../../dev/core/src/PostProcesses/blackAndWhitePostProcess.ts"],"names":[],"mappings":";AACA,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAK5C,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAClD,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAC/C,OAAO,EAAE,mBAAmB,EAAE,MAAM,kCAAkC,CAAC;AAKvE;;GAEG;AACH,MAAM,OAAO,wBAAyB,SAAQ,WAAW;IAOrD;;;OAGG;IACa,YAAY;QACxB,OAAO,0BAA0B,CAAC;IACtC,CAAC;IAED;;;;;;;;;OASG;IACH,YAAY,IAAY,EAAE,OAAoC,EAAE,MAAwB,EAAE,YAAqB,EAAE,MAAuB,EAAE,QAAkB;QACxJ,KAAK,CAAC,IAAI,EAAE,eAAe,EAAE,CAAC,QAAQ,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC;QAzBpG;;WAEG;QAEI,WAAM,GAAG,CAAC,CAAC;QAuBd,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,CAAC,MAAc,EAAE,EAAE;YAC1C,MAAM,CAAC,QAAQ,CAAC,QAAQ,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;QAC3C,CAAC,CAAC,CAAC;IACP,CAAC;IAEkB,cAAc,CAAC,SAAkB,EAAE,IAAoB;QACtE,IAAI,SAAS,EAAE;YACX,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC;YACzB,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,uCAAuC,CAAC,CAAC,CAAC;SAC9D;aAAM;YACH,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,mCAAmC,CAAC,CAAC,CAAC;SAC1D;QAED,KAAK,CAAC,cAAc,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC;IAC1C,CAAC;IAED;;OAEG;IACI,MAAM,CAAU,MAAM,CAAC,iBAAsB,EAAE,YAAoB,EAAE,KAAY,EAAE,OAAe;QACrG,OAAO,mBAAmB,CAAC,KAAK,CAC5B,GAAG,EAAE;YACD,OAAO,IAAI,wBAAwB,CAC/B,iBAAiB,CAAC,IAAI,EACtB,iBAAiB,CAAC,OAAO,EACzB,YAAY,EACZ,iBAAiB,CAAC,wBAAwB,EAC1C,KAAK,CAAC,SAAS,EAAE,EACjB,iBAAiB,CAAC,QAAQ,CAC7B,CAAC;QACN,CAAC,EACD,iBAAiB,EACjB,KAAK,EACL,OAAO,CACV,CAAC;IACN,CAAC;CACJ;AA3DU;IADN,SAAS,EAAE;wDACM;AA6DtB,aAAa,CAAC,kCAAkC,EAAE,wBAAwB,CAAC,CAAC","sourcesContent":["import type { PostProcessOptions } from \"./postProcess\";\r\nimport { PostProcess } from \"./postProcess\";\r\nimport type { Camera } from \"../Cameras/camera\";\r\nimport type { Effect } from \"../Materials/effect\";\r\nimport type { AbstractEngine } from \"../Engines/abstractEngine\";\r\n\r\nimport { RegisterClass } from \"../Misc/typeStore\";\r\nimport { serialize } from \"../Misc/decorators\";\r\nimport { SerializationHelper } from \"../Misc/decorators.serialization\";\r\nimport type { Nullable } from \"../types\";\r\n\r\nimport type { Scene } from \"../scene\";\r\n\r\n/**\r\n * Post process used to render in black and white\r\n */\r\nexport class BlackAndWhitePostProcess extends PostProcess {\r\n    /**\r\n     * Linear about to convert he result to black and white (default: 1)\r\n     */\r\n    @serialize()\r\n    public degree = 1;\r\n\r\n    /**\r\n     * Gets a string identifying the name of the class\r\n     * @returns \"BlackAndWhitePostProcess\" string\r\n     */\r\n    public override getClassName(): string {\r\n        return \"BlackAndWhitePostProcess\";\r\n    }\r\n\r\n    /**\r\n     * Creates a black and white post process\r\n     * @see https://doc.babylonjs.com/features/featuresDeepDive/postProcesses/usePostProcesses#black-and-white\r\n     * @param name The name of the effect.\r\n     * @param options The required width/height ratio to downsize to before computing the render pass.\r\n     * @param camera The camera to apply the render pass to.\r\n     * @param samplingMode The sampling mode to be used when computing the pass. (default: 0)\r\n     * @param engine The engine which the post process will be applied. (default: current engine)\r\n     * @param reusable If the post process can be reused on the same frame. (default: false)\r\n     */\r\n    constructor(name: string, options: number | PostProcessOptions, camera: Nullable<Camera>, samplingMode?: number, engine?: AbstractEngine, reusable?: boolean) {\r\n        super(name, \"blackAndWhite\", [\"degree\"], null, options, camera, samplingMode, engine, reusable);\r\n\r\n        this.onApplyObservable.add((effect: Effect) => {\r\n            effect.setFloat(\"degree\", this.degree);\r\n        });\r\n    }\r\n\r\n    protected override _gatherImports(useWebGPU: boolean, list: Promise<any>[]) {\r\n        if (useWebGPU) {\r\n            this._webGPUReady = true;\r\n            list.push(import(\"../ShadersWGSL/blackAndWhite.fragment\"));\r\n        } else {\r\n            list.push(import(\"../Shaders/blackAndWhite.fragment\"));\r\n        }\r\n\r\n        super._gatherImports(useWebGPU, list);\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    public static override _Parse(parsedPostProcess: any, targetCamera: Camera, scene: Scene, rootUrl: string): Nullable<BlackAndWhitePostProcess> {\r\n        return SerializationHelper.Parse(\r\n            () => {\r\n                return new BlackAndWhitePostProcess(\r\n                    parsedPostProcess.name,\r\n                    parsedPostProcess.options,\r\n                    targetCamera,\r\n                    parsedPostProcess.renderTargetSamplingMode,\r\n                    scene.getEngine(),\r\n                    parsedPostProcess.reusable\r\n                );\r\n            },\r\n            parsedPostProcess,\r\n            scene,\r\n            rootUrl\r\n        );\r\n    }\r\n}\r\n\r\nRegisterClass(\"BABYLON.BlackAndWhitePostProcess\", BlackAndWhitePostProcess);\r\n"]}

package/PostProcesses/bloomMergePostProcess.d.ts

@@ -31,5 +31,5 @@ export declare class BloomMergePostProcess extends PostProcess {
     constructor(name: string, originalFromInput: PostProcess, blurred: PostProcess, 
     /** Weight of the bloom to be added to the original input. */
     weight: number, options: number | PostProcessOptions, camera: Nullable<Camera>, samplingMode?: number, engine?: AbstractEngine, reusable?: boolean, textureType?: number, blockCompilation?: boolean);
-    protected _initShaderSourceAsync(useWebGPU: boolean): Promise<void>;
+    protected _gatherImports(useWebGPU: boolean, list: Promise<any>[]): void;
 }

package/PostProcesses/bloomMergePostProcess.js

@@ -45,15 +45,15 @@ export class BloomMergePostProcess extends PostProcess {
             this.updateEffect();
         }
     }
-    async _initShaderSourceAsync(useWebGPU) {
+    _gatherImports(useWebGPU, list) {
         if (useWebGPU) {
             this._webGPUReady = true;
-            await import("../ShadersWGSL/bloomMerge.fragment.js");
+            list.push(import("../ShadersWGSL/bloomMerge.fragment.js"));
         }
         else {
-            await import("../Shaders/bloomMerge.fragment.js");
+            list.push(import("../Shaders/bloomMerge.fragment.js"));
         }
-        super._initShaderSourceAsync(useWebGPU);
+        super._gatherImports(useWebGPU, list);
     }
 }
 __decorate([

package/PostProcesses/bloomMergePostProcess.js.map

@@ -1 +1 @@
-{"version":3,"file":"bloomMergePostProcess.js","sourceRoot":"","sources":["../../../../dev/core/src/PostProcesses/bloomMergePostProcess.ts"],"names":[],"mappings":";AACA,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAK5C,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAEjD,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAClD,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAE/C;;GAEG;AACH,MAAM,OAAO,qBAAsB,SAAQ,WAAW;IAKlD;;;OAGG;IACa,YAAY;QACxB,OAAO,uBAAuB,CAAC;IACnC,CAAC;IAED;;;;;;;;;;;;;OAaG;IACH,YACI,IAAY,EACZ,iBAA8B,EAC9B,OAAoB;IACpB,6DAA6D;IAC7D,MAAc,EACd,OAAoC,EACpC,MAAwB,EACxB,YAAqB,EACrB,MAAuB,EACvB,QAAkB,EAClB,cAAsB,SAAS,CAAC,wBAAwB,EACxD,gBAAgB,GAAG,KAAK;QAExB,KAAK,CAAC,IAAI,EAAE,YAAY,EAAE,CAAC,aAAa,CAAC,EAAE,CAAC,WAAW,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,QAAQ,EAAE,IAAI,EAAE,WAAW,EAAE,SAAS,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC;QAxCzJ,6DAA6D;QAEtD,WAAM,GAAG,CAAC,CAAC;QAuCd,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,IAAI,CAAC,6BAA6B,GAAG,IAAI,CAAC;QAC1C,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,CAAC,MAAc,EAAE,EAAE;YAC1C,MAAM,CAAC,yBAAyB,CAAC,gBAAgB,EAAE,iBAAiB,CAAC,CAAC;YACtE,MAAM,CAAC,+BAA+B,CAAC,WAAW,EAAE,OAAO,CAAC,CAAC;YAC7D,MAAM,CAAC,QAAQ,CAAC,aAAa,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;QAChD,CAAC,CAAC,CAAC;QAEH,IAAI,CAAC,gBAAgB,EAAE;YACnB,IAAI,CAAC,YAAY,EAAE,CAAC;SACvB;IACL,CAAC;IAEkB,KAAK,CAAC,sBAAsB,CAAC,SAAkB;QAC9D,IAAI,SAAS,EAAE;YACX,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC;YACzB,MAAM,MAAM,CAAC,oCAAoC,CAAC,CAAC;SACtD;aAAM;YACH,MAAM,MAAM,CAAC,gCAAgC,CAAC,CAAC;SAClD;QAED,KAAK,CAAC,sBAAsB,CAAC,SAAS,CAAC,CAAC;IAC5C,CAAC;CACJ;AA9DU;IADN,SAAS,EAAE;qDACM;AAgEtB,aAAa,CAAC,+BAA+B,EAAE,qBAAqB,CAAC,CAAC","sourcesContent":["import type { PostProcessOptions } from \"./postProcess\";\r\nimport { PostProcess } from \"./postProcess\";\r\nimport type { Nullable } from \"../types\";\r\nimport type { AbstractEngine } from \"../Engines/abstractEngine\";\r\nimport type { Effect } from \"../Materials/effect\";\r\nimport type { Camera } from \"../Cameras/camera\";\r\nimport { Constants } from \"../Engines/constants\";\r\n\r\nimport { RegisterClass } from \"../Misc/typeStore\";\r\nimport { serialize } from \"../Misc/decorators\";\r\n\r\n/**\r\n * The BloomMergePostProcess merges blurred images with the original based on the values of the circle of confusion.\r\n */\r\nexport class BloomMergePostProcess extends PostProcess {\r\n    /** Weight of the bloom to be added to the original input. */\r\n    @serialize()\r\n    public weight = 1;\r\n\r\n    /**\r\n     * Gets a string identifying the name of the class\r\n     * @returns \"BloomMergePostProcess\" string\r\n     */\r\n    public override getClassName(): string {\r\n        return \"BloomMergePostProcess\";\r\n    }\r\n\r\n    /**\r\n     * Creates a new instance of @see BloomMergePostProcess\r\n     * @param name The name of the effect.\r\n     * @param originalFromInput Post process which's input will be used for the merge.\r\n     * @param blurred Blurred highlights post process which's output will be used.\r\n     * @param weight Weight of the bloom to be added to the original input.\r\n     * @param options The required width/height ratio to downsize to before computing the render pass.\r\n     * @param camera The camera to apply the render pass to.\r\n     * @param samplingMode The sampling mode to be used when computing the pass. (default: 0)\r\n     * @param engine The engine which the post process will be applied. (default: current engine)\r\n     * @param reusable If the post process can be reused on the same frame. (default: false)\r\n     * @param textureType Type of textures used when performing the post process. (default: 0)\r\n     * @param blockCompilation If compilation of the shader should not be done in the constructor. The updateEffect method can be used to compile the shader at a later time. (default: false)\r\n     */\r\n    constructor(\r\n        name: string,\r\n        originalFromInput: PostProcess,\r\n        blurred: PostProcess,\r\n        /** Weight of the bloom to be added to the original input. */\r\n        weight: number,\r\n        options: number | PostProcessOptions,\r\n        camera: Nullable<Camera>,\r\n        samplingMode?: number,\r\n        engine?: AbstractEngine,\r\n        reusable?: boolean,\r\n        textureType: number = Constants.TEXTURETYPE_UNSIGNED_INT,\r\n        blockCompilation = false\r\n    ) {\r\n        super(name, \"bloomMerge\", [\"bloomWeight\"], [\"bloomBlur\"], options, camera, samplingMode, engine, reusable, null, textureType, undefined, null, true);\r\n        this.weight = weight;\r\n        this.externalTextureSamplerBinding = true;\r\n        this.onApplyObservable.add((effect: Effect) => {\r\n            effect.setTextureFromPostProcess(\"textureSampler\", originalFromInput);\r\n            effect.setTextureFromPostProcessOutput(\"bloomBlur\", blurred);\r\n            effect.setFloat(\"bloomWeight\", this.weight);\r\n        });\r\n\r\n        if (!blockCompilation) {\r\n            this.updateEffect();\r\n        }\r\n    }\r\n\r\n    protected override async _initShaderSourceAsync(useWebGPU: boolean) {\r\n        if (useWebGPU) {\r\n            this._webGPUReady = true;\r\n            await import(\"../ShadersWGSL/bloomMerge.fragment\");\r\n        } else {\r\n            await import(\"../Shaders/bloomMerge.fragment\");\r\n        }\r\n\r\n        super._initShaderSourceAsync(useWebGPU);\r\n    }\r\n}\r\n\r\nRegisterClass(\"BABYLON.BloomMergePostProcess\", BloomMergePostProcess);\r\n"]}
+{"version":3,"file":"bloomMergePostProcess.js","sourceRoot":"","sources":["../../../../dev/core/src/PostProcesses/bloomMergePostProcess.ts"],"names":[],"mappings":";AACA,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAK5C,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAEjD,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAClD,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAE/C;;GAEG;AACH,MAAM,OAAO,qBAAsB,SAAQ,WAAW;IAKlD;;;OAGG;IACa,YAAY;QACxB,OAAO,uBAAuB,CAAC;IACnC,CAAC;IAED;;;;;;;;;;;;;OAaG;IACH,YACI,IAAY,EACZ,iBAA8B,EAC9B,OAAoB;IACpB,6DAA6D;IAC7D,MAAc,EACd,OAAoC,EACpC,MAAwB,EACxB,YAAqB,EACrB,MAAuB,EACvB,QAAkB,EAClB,cAAsB,SAAS,CAAC,wBAAwB,EACxD,gBAAgB,GAAG,KAAK;QAExB,KAAK,CAAC,IAAI,EAAE,YAAY,EAAE,CAAC,aAAa,CAAC,EAAE,CAAC,WAAW,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,QAAQ,EAAE,IAAI,EAAE,WAAW,EAAE,SAAS,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC;QAxCzJ,6DAA6D;QAEtD,WAAM,GAAG,CAAC,CAAC;QAuCd,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,IAAI,CAAC,6BAA6B,GAAG,IAAI,CAAC;QAC1C,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,CAAC,MAAc,EAAE,EAAE;YAC1C,MAAM,CAAC,yBAAyB,CAAC,gBAAgB,EAAE,iBAAiB,CAAC,CAAC;YACtE,MAAM,CAAC,+BAA+B,CAAC,WAAW,EAAE,OAAO,CAAC,CAAC;YAC7D,MAAM,CAAC,QAAQ,CAAC,aAAa,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;QAChD,CAAC,CAAC,CAAC;QAEH,IAAI,CAAC,gBAAgB,EAAE;YACnB,IAAI,CAAC,YAAY,EAAE,CAAC;SACvB;IACL,CAAC;IAEkB,cAAc,CAAC,SAAkB,EAAE,IAAoB;QACtE,IAAI,SAAS,EAAE;YACX,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC;YACzB,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,oCAAoC,CAAC,CAAC,CAAC;SAC3D;aAAM;YACH,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,gCAAgC,CAAC,CAAC,CAAC;SACvD;QAED,KAAK,CAAC,cAAc,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC;IAC1C,CAAC;CACJ;AA9DU;IADN,SAAS,EAAE;qDACM;AAgEtB,aAAa,CAAC,+BAA+B,EAAE,qBAAqB,CAAC,CAAC","sourcesContent":["import type { PostProcessOptions } from \"./postProcess\";\r\nimport { PostProcess } from \"./postProcess\";\r\nimport type { Nullable } from \"../types\";\r\nimport type { AbstractEngine } from \"../Engines/abstractEngine\";\r\nimport type { Effect } from \"../Materials/effect\";\r\nimport type { Camera } from \"../Cameras/camera\";\r\nimport { Constants } from \"../Engines/constants\";\r\n\r\nimport { RegisterClass } from \"../Misc/typeStore\";\r\nimport { serialize } from \"../Misc/decorators\";\r\n\r\n/**\r\n * The BloomMergePostProcess merges blurred images with the original based on the values of the circle of confusion.\r\n */\r\nexport class BloomMergePostProcess extends PostProcess {\r\n    /** Weight of the bloom to be added to the original input. */\r\n    @serialize()\r\n    public weight = 1;\r\n\r\n    /**\r\n     * Gets a string identifying the name of the class\r\n     * @returns \"BloomMergePostProcess\" string\r\n     */\r\n    public override getClassName(): string {\r\n        return \"BloomMergePostProcess\";\r\n    }\r\n\r\n    /**\r\n     * Creates a new instance of @see BloomMergePostProcess\r\n     * @param name The name of the effect.\r\n     * @param originalFromInput Post process which's input will be used for the merge.\r\n     * @param blurred Blurred highlights post process which's output will be used.\r\n     * @param weight Weight of the bloom to be added to the original input.\r\n     * @param options The required width/height ratio to downsize to before computing the render pass.\r\n     * @param camera The camera to apply the render pass to.\r\n     * @param samplingMode The sampling mode to be used when computing the pass. (default: 0)\r\n     * @param engine The engine which the post process will be applied. (default: current engine)\r\n     * @param reusable If the post process can be reused on the same frame. (default: false)\r\n     * @param textureType Type of textures used when performing the post process. (default: 0)\r\n     * @param blockCompilation If compilation of the shader should not be done in the constructor. The updateEffect method can be used to compile the shader at a later time. (default: false)\r\n     */\r\n    constructor(\r\n        name: string,\r\n        originalFromInput: PostProcess,\r\n        blurred: PostProcess,\r\n        /** Weight of the bloom to be added to the original input. */\r\n        weight: number,\r\n        options: number | PostProcessOptions,\r\n        camera: Nullable<Camera>,\r\n        samplingMode?: number,\r\n        engine?: AbstractEngine,\r\n        reusable?: boolean,\r\n        textureType: number = Constants.TEXTURETYPE_UNSIGNED_INT,\r\n        blockCompilation = false\r\n    ) {\r\n        super(name, \"bloomMerge\", [\"bloomWeight\"], [\"bloomBlur\"], options, camera, samplingMode, engine, reusable, null, textureType, undefined, null, true);\r\n        this.weight = weight;\r\n        this.externalTextureSamplerBinding = true;\r\n        this.onApplyObservable.add((effect: Effect) => {\r\n            effect.setTextureFromPostProcess(\"textureSampler\", originalFromInput);\r\n            effect.setTextureFromPostProcessOutput(\"bloomBlur\", blurred);\r\n            effect.setFloat(\"bloomWeight\", this.weight);\r\n        });\r\n\r\n        if (!blockCompilation) {\r\n            this.updateEffect();\r\n        }\r\n    }\r\n\r\n    protected override _gatherImports(useWebGPU: boolean, list: Promise<any>[]) {\r\n        if (useWebGPU) {\r\n            this._webGPUReady = true;\r\n            list.push(import(\"../ShadersWGSL/bloomMerge.fragment\"));\r\n        } else {\r\n            list.push(import(\"../Shaders/bloomMerge.fragment\"));\r\n        }\r\n\r\n        super._gatherImports(useWebGPU, list);\r\n    }\r\n}\r\n\r\nRegisterClass(\"BABYLON.BloomMergePostProcess\", BloomMergePostProcess);\r\n"]}