@babylonjs/core 5.46.0 → 5.47.0

package/Physics/v2/physicsConstraint.d.ts

@@ -2,7 +2,6 @@ import type { Scene } from "../../scene";
 import type { Vector3 } from "../../Maths/math.vector";
 import type { IPhysicsEnginePluginV2, ConstraintAxis, PhysicsConstraintParameters, ConstraintAxisLimitMode, ConstraintMotorType } from "./IPhysicsEnginePlugin";
 import { ConstraintType } from "./IPhysicsEnginePlugin";
-import type { PhysicsBody } from "./physicsBody";
 /**
  * This is a holder class for the physics constraint created by the physics plugin
  * It holds a set of functions to control the underlying constraint
@@ -17,6 +16,8 @@ export declare class PhysicsConstraint {
      * The V2 plugin used to create and manage this Physics Body
      */
     protected _physicsPlugin: IPhysicsEnginePluginV2;
+    protected _options: PhysicsConstraintParameters;
+    protected _type: ConstraintType;
     /**
      * Constructs a new constraint for the physics constraint.
      * @param type The type of constraint to create.
@@ -28,176 +29,248 @@ export declare class PhysicsConstraint {
      */
     constructor(type: ConstraintType, options: PhysicsConstraintParameters, scene: Scene);
     /**
-     * Sets the parent body of this body.
-     * @param body - The parent body to set.
+     * Gets the type of the constraint.
      *
-     * This method is useful for setting the parent body of a physics body in a physics engine.
-     * This allows the engine to accurately simulate the motion of the body in relation to its parent body.
-     * For example, if the parent body is a planet, the engine can accurately simulate the motion of the body in relation to the planet's gravity.
-     */
-    setParentBody(body: PhysicsBody): void;
-    /**
-     * Retrieves the parent body of the current physics constraint.
+     * @returns The type of the constraint.
      *
-     * @returns The parent body of the current physics constraint, or `undefined` if the
-     * current constraint does not have a parent body.
      */
-    getParentBody(): PhysicsBody | undefined;
+    getType(): ConstraintType;
     /**
-     * Sets the child body of the current body.
+     * Retrieves the options of the physics constraint.
      *
-     * @param body - The child body to set.
+     * @returns The physics constraint parameters.
      *
-     * This method is useful for setting the child body of the current body in a physics engine.
-     * This allows for the creation of complex structures of bodies that interact with each other in a realistic way.
      */
-    setChildBody(body: PhysicsBody): void;
+    getOptions(): PhysicsConstraintParameters;
     /**
-     * Retrieves the child body of the current physics constraint.
-     *
-     * @returns The child body of the current physics constraint, or `undefined` if no
-     * child body is present.
-     */
-    getChildBody(): PhysicsBody | undefined;
-    /**
-     *
-     * @param pivot +
-     * @param axisX
-     * @param axisY
-     */
-    setAnchorInParent(pivot: Vector3, axisX: Vector3, axisY: Vector3): void;
-    /**
-     *
-     * @param pivot
-     * @param axisX
-     * @param axisY
-     */
-    setAnchorInChild(pivot: Vector3, axisX: Vector3, axisY: Vector3): void;
-    /**
-     *
-     * @param isEnabled
+     * Enable/disable the constraint
+     * @param isEnabled value for the constraint
      */
     setEnabled(isEnabled: boolean): void;
     /**
      *
-     * @returns
+     * @returns true if constraint is enabled
      */
     getEnabled(): boolean;
     /**
+     * Enables or disables collisions for the physics engine.
+     *
+     * @param isEnabled - A boolean value indicating whether collisions should be enabled or disabled.
      *
-     * @param isEnabled
      */
     setCollisionsEnabled(isEnabled: boolean): void;
     /**
+     * Gets whether collisions are enabled for this physics object.
+     *
+     * @returns `true` if collisions are enabled, `false` otherwise.
      *
-     * @returns
      */
     getCollisionsEnabled(): boolean;
     /**
+     * Sets the friction of the given axis of the physics engine.
+     * @param axis - The axis of the physics engine to set the friction for.
+     * @param friction - The friction to set for the given axis.
      *
-     * @param axis
-     * @param friction
      */
     setAxisFriction(axis: ConstraintAxis, friction: number): void;
     /**
+     * Gets the friction of the given axis of the physics engine.
+     * @param axis - The axis of the physics engine.
+     * @returns The friction of the given axis.
      *
-     * @param axis
-     * @returns
      */
     getAxisFriction(axis: ConstraintAxis): number;
     /**
+     * Sets the limit mode for the given axis of the constraint.
+     * @param axis The axis to set the limit mode for.
+     * @param limitMode The limit mode to set.
      *
-     * @param axis
-     * @param limitMode
+     * This method is useful for setting the limit mode for a given axis of the constraint. This is important for
+     * controlling the behavior of the physics engine when the constraint is reached. By setting the limit mode,
+     * the engine can be configured to either stop the motion of the objects, or to allow them to continue
+     * moving beyond the constraint.
      */
     setAxisMode(axis: ConstraintAxis, limitMode: ConstraintAxisLimitMode): void;
     /**
+     * Gets the limit mode of the given axis of the constraint.
+     *
+     * @param axis - The axis of the constraint.
+     * @returns The limit mode of the given axis.
      *
-     * @param axis
      */
     getAxisMode(axis: ConstraintAxis): ConstraintAxisLimitMode;
     /**
+     * Sets the minimum limit of a given axis of a constraint.
+     * @param axis - The axis of the constraint.
+     * @param minLimit - The minimum limit of the axis.
      *
      */
     setAxisMinLimit(axis: ConstraintAxis, minLimit: number): void;
     /**
+     * Gets the minimum limit of the given axis of the physics engine.
+     * @param axis - The axis of the physics engine.
+     * @returns The minimum limit of the given axis.
      *
      */
     getAxisMinLimit(axis: ConstraintAxis): number;
     /**
+     * Sets the maximum limit of the given axis for the physics engine.
+     * @param axis - The axis to set the limit for.
+     * @param limit - The maximum limit of the axis.
      *
+     * This method is useful for setting the maximum limit of the given axis for the physics engine,
+     * which can be used to control the movement of the physics object. This helps to ensure that the
+     * physics object does not move beyond the given limit.
      */
     setAxisMaxLimit(axis: ConstraintAxis, limit: number): void;
     /**
+     * Gets the maximum limit of the given axis of the physics engine.
+     * @param axis - The axis of the physics engine.
+     * @returns The maximum limit of the given axis.
      *
      */
     getAxisMaxLimit(axis: ConstraintAxis): number;
     /**
+     * Sets the motor type of the given axis of the constraint.
+     * @param axis - The axis of the constraint.
+     * @param motorType - The type of motor to use.
+     * @returns void
      *
      */
     setAxisMotorType(axis: ConstraintAxis, motorType: ConstraintMotorType): void;
     /**
+     * Gets the motor type of the specified axis of the constraint.
+     *
+     * @param axis - The axis of the constraint.
+     * @returns The motor type of the specified axis.
      *
      */
     getAxisMotorType(axis: ConstraintAxis): ConstraintMotorType;
     /**
+     * Sets the target velocity of the motor associated with the given axis of the constraint.
+     * @param axis - The axis of the constraint.
+     * @param target - The target velocity of the motor.
      *
+     * This method is useful for setting the target velocity of the motor associated with the given axis of the constraint.
      */
     setAxisMotorTarget(axis: ConstraintAxis, target: number): void;
     /**
+     * Gets the target velocity of the motor associated to the given constraint axis.
+     * @param axis - The constraint axis associated to the motor.
+     * @returns The target velocity of the motor.
      *
      */
     getAxisMotorTarget(axis: ConstraintAxis): number;
     /**
+     * Sets the maximum force of the motor of the given axis of the constraint.
+     * @param axis - The axis of the constraint.
+     * @param maxForce - The maximum force of the motor.
      *
      */
     setAxisMotorMaxForce(axis: ConstraintAxis, maxForce: number): void;
     /**
+     * Gets the maximum force of the motor of the given axis of the constraint.
+     * @param axis - The axis of the constraint.
+     * @returns The maximum force of the motor.
      *
      */
     getAxisMotorMaxForce(axis: ConstraintAxis): number;
     /**
+     * Disposes the constraint from the physics engine.
      *
+     * 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.
      */
     dispose(): void;
 }
 /**
+ * Represents a Ball and Socket Constraint, used to simulate a 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.
  */
-/** @internal */
-export declare class PhysicsConstraintBallAndSocket extends PhysicsConstraint {
-    /** @internal */
+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.
+ */
+export declare class DistanceConstraint extends PhysicsConstraint {
+    constructor(maxDistance: number, scene: Scene);
+}
+/**
+ * Creates a HingeConstraint, which is a type of PhysicsConstraint.
+ *
+ * @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.
  */
-/** @internal */
-export declare class PhysicsConstraintDistance extends PhysicsConstraint {
-    /** @internal */
+export declare class HingeConstraint extends PhysicsConstraint {
     constructor(pivotA: Vector3, pivotB: Vector3, axisA: Vector3, axisB: Vector3, scene: Scene);
 }
 /**
+ * Creates a SliderConstraint, which is a type of PhysicsConstraint.
  *
+ * @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.
  */
-/** @internal */
-export declare class PhysicsConstraintHinge extends PhysicsConstraint {
-    /** @internal */
+export declare class SliderConstraint extends PhysicsConstraint {
     constructor(pivotA: Vector3, pivotB: Vector3, axisA: Vector3, axisB: Vector3, scene: Scene);
 }
 /**
+ * Creates a LockConstraint, which is a type of PhysicsConstraint.
+ *
+ * @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.
  */
-/** @internal */
-export declare class PhysicsConstraintSlider extends PhysicsConstraint {
-    /** @internal */
+export declare class LockConstraint extends PhysicsConstraint {
     constructor(pivotA: Vector3, pivotB: Vector3, axisA: Vector3, axisB: Vector3, scene: Scene);
 }
 /**
+ * Creates a PrismaticConstraint, which is a type of PhysicsConstraint.
+ *
+ * @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.
  */
-/** @internal */
-export declare class PhysicsConstraintLock extends PhysicsConstraint {
-    /** @internal */
+export declare class PrismaticConstraint extends PhysicsConstraint {
     constructor(pivotA: Vector3, pivotB: Vector3, axisA: Vector3, axisB: Vector3, scene: Scene);
 }