@babylonjs/core 5.29.0 → 5.31.0

package/Maths/math.vector.d.ts

@@ -703,11 +703,16 @@ export declare class Vector3 {
     scaleToRef<T extends Vector3>(scale: number, result: T): T;
     /**
      * Creates a vector normal (perpendicular) to the current Vector3 and stores the result in the given vector
+     * Out of the infinite possibilities the normal chosen is the one formed by rotating the current vector
+     * 90 degrees about an axis which lies perpendicular to the current vector
+     * and its projection on the xz plane. In the case of a current vector in the xz plane
+     * the normal is calculated to be along the y axis.
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#230
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#231
      * @param result defines the Vector3 object where to store the resultant normal
      * returns the result
-     * @hidden
      */
-    _getNormalToRef(result: DeepImmutable<Vector3>): Vector3;
+    getNormalToRef(result: DeepImmutable<Vector3>): Vector3;
     /**
      * Rotates the vector using the given unit quaternion and stores the new vector in result
      * Example Playground https://playground.babylonjs.com/#R1F8YU#9
@@ -2034,6 +2039,7 @@ export declare class Vector4 {
 }
 /**
  * Class used to store quaternion data
+ * Example Playground - Overview - https://playground.babylonjs.com/#L49EJ7#100
  * @see https://en.wikipedia.org/wiki/Quaternion
  * @see https://doc.babylonjs.com/features/position,_rotation,_scaling
  */
@@ -2085,11 +2091,13 @@ export declare class Quaternion {
     getHashCode(): number;
     /**
      * Copy the quaternion to an array
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#13
      * @returns a new array populated with 4 elements from the quaternion coordinates
      */
     asArray(): number[];
     /**
      * Stores from the starting index in the given array the Quaternion successive values
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#59
      * @param array defines the array where to store the x,y,z,w components
      * @param index defines an optional index in the target array to define where to start storing values
      * @returns the current Quaternion object
@@ -2097,12 +2105,14 @@ export declare class Quaternion {
     toArray(array: FloatArray, index?: number): Quaternion;
     /**
      * Check if two quaternions are equals
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#38
      * @param otherQuaternion defines the second operand
      * @returns true if the current quaternion and the given one coordinates are strictly equals
      */
     equals(otherQuaternion: DeepImmutable<Quaternion>): boolean;
     /**
      * Gets a boolean if two quaternions are equals (using an epsilon value)
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#37
      * @param otherQuaternion defines the other quaternion
      * @param epsilon defines the minimal distance to consider equality
      * @returns true if the given quaternion coordinates are close to the current ones by a distance of epsilon.
@@ -2110,17 +2120,20 @@ export declare class Quaternion {
     equalsWithEpsilon(otherQuaternion: DeepImmutable<Quaternion>, epsilon?: number): boolean;
     /**
      * Clone the current quaternion
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#12
      * @returns a new quaternion copied from the current one
      */
     clone(): this;
     /**
      * Copy a quaternion to the current one
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#86
      * @param other defines the other quaternion
      * @returns the updated current quaternion
      */
     copyFrom(other: DeepImmutable<Quaternion>): this;
     /**
      * Updates the current quaternion with the given float coordinates
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#87
      * @param x defines the x coordinate
      * @param y defines the y coordinate
      * @param z defines the z coordinate
@@ -2130,6 +2143,7 @@ export declare class Quaternion {
     copyFromFloats(x: number, y: number, z: number, w: number): this;
     /**
      * Updates the current quaternion from the given float coordinates
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#56
      * @param x defines the x coordinate
      * @param y defines the y coordinate
      * @param z defines the z coordinate
@@ -2139,36 +2153,42 @@ export declare class Quaternion {
     set(x: number, y: number, z: number, w: number): this;
     /**
      * Adds two quaternions
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#10
      * @param other defines the second operand
      * @returns a new quaternion as the addition result of the given one and the current quaternion
      */
     add(other: DeepImmutable<Quaternion>): this;
     /**
      * Add a quaternion to the current one
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#11
      * @param other defines the quaternion to add
      * @returns the current quaternion
      */
     addInPlace(other: DeepImmutable<Quaternion>): this;
     /**
      * Subtract two quaternions
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#57
      * @param other defines the second operand
      * @returns a new quaternion as the subtraction result of the given one from the current one
      */
     subtract(other: Quaternion): this;
     /**
      * Subtract a quaternion to the current one
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#58
      * @param other defines the quaternion to subtract
      * @returns the current quaternion
      */
     subtractInPlace(other: DeepImmutable<Quaternion>): this;
     /**
      * Multiplies the current quaternion by a scale factor
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#88
      * @param value defines the scale factor
      * @returns a new quaternion set by multiplying the current quaternion coordinates by the float "scale"
      */
     scale(value: number): this;
     /**
      * Scale the current quaternion values by a factor and stores the result to a given quaternion
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#89
      * @param scale defines the scale factor
      * @param result defines the Quaternion object where to store the result
      * @returns result input
@@ -2176,12 +2196,14 @@ export declare class Quaternion {
     scaleToRef<T extends Quaternion>(scale: number, result: T): T;
     /**
      * Multiplies in place the current quaternion by a scale factor
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#90
      * @param value defines the scale factor
      * @returns the current modified quaternion
      */
     scaleInPlace(value: number): this;
     /**
      * Scale the current quaternion values by a factor and add the result to a given quaternion
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#91
      * @param scale defines the scale factor
      * @param result defines the Quaternion object where to store the result
      * @returns result input
@@ -2189,12 +2211,14 @@ export declare class Quaternion {
     scaleAndAddToRef<T extends Quaternion>(scale: number, result: T): T;
     /**
      * Multiplies two quaternions
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#43
      * @param q1 defines the second operand
      * @returns a new quaternion set as the multiplication result of the current one with the given one "q1"
      */
     multiply(q1: DeepImmutable<Quaternion>): this;
     /**
      * Sets the given "result" as the the multiplication result of the current one with the given one "q1"
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#45
      * @param q1 defines the second operand
      * @param result defines the target quaternion
      * @returns the current quaternion
@@ -2202,64 +2226,76 @@ export declare class Quaternion {
     multiplyToRef<T extends Quaternion>(q1: DeepImmutable<Quaternion>, result: T): T;
     /**
      * Updates the current quaternion with the multiplication of itself with the given one "q1"
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#46
      * @param q1 defines the second operand
      * @returns the currentupdated quaternion
      */
     multiplyInPlace(q1: DeepImmutable<Quaternion>): this;
     /**
      * Conjugates the current quaternion and stores the result in the given quaternion
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#81
      * @param ref defines the target quaternion
      * @returns result input
      */
     conjugateToRef<T extends Quaternion>(ref: T): T;
     /**
      * Conjugates in place the current quaternion
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#82
      * @returns the current updated quaternion
      */
     conjugateInPlace(): this;
     /**
      * Conjugates (1-q) the current quaternion
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#83
      * @returns a new quaternion
      */
     conjugate(): this;
     /**
      * Returns the inverse of the current quaternion
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#84
      * @returns a new quaternion
      */
     invert(): this;
     /**
      * Invert in place the current quaternion
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#85
      * @returns this quaternion
      */
     invertInPlace(): this;
     /**
      * Gets squared length of current quaternion
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#29
      * @returns the quaternion length (float)
      */
     lengthSquared(): number;
     /**
      * Gets length of current quaternion
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#28
      * @returns the quaternion length (float)
      */
     length(): number;
     /**
      * Normalize in place the current quaternion
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#54
      * @returns the current updated quaternion
      */
     normalize(): this;
     /**
      * Normalize a copy of the current quaternion
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#55
      * @returns the normalized quaternion
      */
     normalizeToNew(): this;
     /**
      * Returns a new Vector3 set with the Euler angles translated from the current quaternion
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#32
      * @returns a new Vector3 containing the Euler angles
      * @see https://doc.babylonjs.com/divingDeeper/mesh/transforms/center_origin/rotation_conventions
      */
     toEulerAngles(): Vector3;
     /**
      * Sets the given vector3 "result" with the Euler angles translated from the current quaternion
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#31
      * @param result defines the vector which will be filled with the Euler angles
      * @returns result input
      * @see https://doc.babylonjs.com/divingDeeper/mesh/transforms/center_origin/rotation_conventions
@@ -2267,48 +2303,36 @@ export declare class Quaternion {
     toEulerAnglesToRef<T extends Vector3>(result: T): T;
     /**
      * Updates the given rotation matrix with the current quaternion values
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#67
      * @param result defines the target matrix
      * @returns the current unchanged quaternion
      */
     toRotationMatrix<T extends Matrix>(result: T): T;
     /**
      * Updates the current quaternion from the given rotation matrix values
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#41
      * @param matrix defines the source matrix
      * @returns the current updated quaternion
      */
     fromRotationMatrix(matrix: DeepImmutable<Matrix>): this;
     /**
      * Creates a new quaternion from a rotation matrix
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#101
      * @param matrix defines the source matrix
      * @returns a new quaternion created from the given rotation matrix values
      */
     static FromRotationMatrix(matrix: DeepImmutable<Matrix>): Quaternion;
     /**
      * Updates the given quaternion with the given rotation matrix values
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#102
      * @param matrix defines the source matrix
      * @param result defines the target quaternion
      * @returns result input
      */
     static FromRotationMatrixToRef<T extends Quaternion>(matrix: DeepImmutable<Matrix>, result: T): T;
-    /**
-     * Creates the rotation quaternion needed to rotate from one Vector3 onto another Vector3
-     * Example PG https://playground.babylonjs.com/#L49EJ7#2
-     * @param fromVector the starting vector
-     * @param toVector the ending vector
-     * @returns the rotation quaternion needed
-     */
-    static RotationQuaternionFromOnto(fromVector: DeepImmutable<Vector3>, toVector: DeepImmutable<Vector3>): import("../types").DeepImmutableObject<Quaternion>;
-    /**
-     * Creates the rotation quaternion needed to rotate from one Vector3 onto another Vector3 and stores in a result Quaternion
-     * Example PG https://playground.babylonjs.com/#L49EJ7#3
-     * @param fromVector the starting vector
-     * @param toVector the ending vector
-     * @param result the rotation quaternion needed
-     * @returns the result
-     */
-    static RotationQuaternionFromOntoToRef(fromVector: DeepImmutable<Vector3>, toVector: DeepImmutable<Vector3>, result: DeepImmutable<Quaternion>): import("../types").DeepImmutableObject<Quaternion>;
     /**
      * Returns the dot product (float) between the quaternions "left" and "right"
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#61
      * @param left defines the left operand
      * @param right defines the right operand
      * @returns the dot product
@@ -2316,6 +2340,7 @@ export declare class Quaternion {
     static Dot(left: DeepImmutable<Quaternion>, right: DeepImmutable<Quaternion>): number;
     /**
      * Checks if the orientations of two rotation quaternions are close to each other
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#60
      * @param quat0 defines the first quaternion to check
      * @param quat1 defines the second quaternion to check
      * @param epsilon defines closeness, 0 same orientation, 1 PI apart, default 0.1
@@ -2324,7 +2349,7 @@ export declare class Quaternion {
     static AreClose(quat0: DeepImmutable<Quaternion>, quat1: DeepImmutable<Quaternion>, epsilon?: number): boolean;
     /**
      * Smooth interpolation between two quaternions using Slerp
-     *
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#93
      * @param source source quaternion
      * @param goal goal quaternion
      * @param deltaTime current interpolation frame
@@ -2339,12 +2364,14 @@ export declare class Quaternion {
     static Zero(): Quaternion;
     /**
      * Inverse a given quaternion
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#103
      * @param q defines the source quaternion
      * @returns a new quaternion as the inverted current quaternion
      */
     static Inverse<T extends Quaternion>(q: DeepImmutable<T>): T;
     /**
      * Inverse a given quaternion
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#104
      * @param q defines the source quaternion
      * @param result the quaternion the result will be stored in
      * @returns the result quaternion
@@ -2363,6 +2390,7 @@ export declare class Quaternion {
     static IsIdentity(quaternion: DeepImmutable<Quaternion>): boolean;
     /**
      * Creates a quaternion from a rotation around an axis
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#72
      * @param axis defines the axis to use
      * @param angle defines the angle to use
      * @returns a new quaternion created from the given axis (Vector3) and angle in radians (float)
@@ -2370,6 +2398,7 @@ export declare class Quaternion {
     static RotationAxis(axis: DeepImmutable<Vector3>, angle: number): Quaternion;
     /**
      * Creates a rotation around an axis and stores it into the given quaternion
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#73
      * @param axis defines the axis to use
      * @param angle defines the angle to use
      * @param result defines the target quaternion
@@ -2378,6 +2407,7 @@ export declare class Quaternion {
     static RotationAxisToRef<T extends Quaternion>(axis: DeepImmutable<Vector3>, angle: number, result: T): T;
     /**
      * Creates a new quaternion from data stored into an array
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#63
      * @param array defines the data source
      * @param offset defines the offset in the source array where the data starts
      * @returns a new quaternion
@@ -2385,6 +2415,7 @@ export declare class Quaternion {
     static FromArray(array: DeepImmutable<ArrayLike<number>>, offset?: number): Quaternion;
     /**
      * Updates the given quaternion "result" from the starting index of the given array.
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#64
      * @param array the array to pull values from
      * @param offset the offset into the array to start at
      * @param result the quaternion to store the result in
@@ -2393,6 +2424,7 @@ export declare class Quaternion {
     static FromArrayToRef<T extends Quaternion>(array: DeepImmutable<ArrayLike<number>>, offset: number, result: T): T;
     /**
      * Create a quaternion from Euler rotation angles
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#33
      * @param x Pitch
      * @param y Yaw
      * @param z Roll
@@ -2401,6 +2433,7 @@ export declare class Quaternion {
     static FromEulerAngles(x: number, y: number, z: number): Quaternion;
     /**
      * Updates a quaternion from Euler rotation angles
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#34
      * @param x Pitch
      * @param y Yaw
      * @param z Roll
@@ -2410,12 +2443,14 @@ export declare class Quaternion {
     static FromEulerAnglesToRef<T extends Quaternion>(x: number, y: number, z: number, result: T): T;
     /**
      * Create a quaternion from Euler rotation vector
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#35
      * @param vec the Euler vector (x Pitch, y Yaw, z Roll)
      * @returns the new Quaternion
      */
     static FromEulerVector(vec: DeepImmutable<Vector3>): Quaternion;
     /**
      * Updates a quaternion from Euler rotation vector
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#36
      * @param vec the Euler vector (x Pitch, y Yaw, z Roll)
      * @param result the quaternion to store the result
      * @returns the updated quaternion
@@ -2423,6 +2458,7 @@ export declare class Quaternion {
     static FromEulerVectorToRef<T extends Quaternion>(vec: DeepImmutable<Vector3>, result: T): T;
     /**
      * Updates a quaternion so that it rotates vector vecFrom to vector vecTo
+     * Example Playground - https://playground.babylonjs.com/#L49EJ7#70
      * @param vecFrom defines the direction vector from which to rotate
      * @param vecTo defines the direction vector to which to rotate
      * @param result the quaternion to store the result
@@ -2431,6 +2467,7 @@ export declare class Quaternion {
     static FromUnitVectorsToRef<T extends Quaternion>(vecFrom: DeepImmutable<Vector3>, vecTo: DeepImmutable<Vector3>, result: T): T;
     /**
      * Creates a new quaternion from the given Euler float angles (y, x, z)
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#77
      * @param yaw defines the rotation around Y axis
      * @param pitch defines the rotation around X axis
      * @param roll defines the rotation around Z axis
@@ -2439,6 +2476,7 @@ export declare class Quaternion {
     static RotationYawPitchRoll(yaw: number, pitch: number, roll: number): Quaternion;
     /**
      * Creates a new rotation from the given Euler float angles (y, x, z) and stores it in the target quaternion
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#78
      * @param yaw defines the rotation around Y axis
      * @param pitch defines the rotation around X axis
      * @param roll defines the rotation around Z axis
@@ -2448,6 +2486,7 @@ export declare class Quaternion {
     static RotationYawPitchRollToRef<T extends Quaternion>(yaw: number, pitch: number, roll: number, result: T): T;
     /**
      * Creates a new quaternion from the given Euler float angles expressed in z-x-z orientation
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#68
      * @param alpha defines the rotation around first axis
      * @param beta defines the rotation around second axis
      * @param gamma defines the rotation around third axis
@@ -2456,6 +2495,7 @@ export declare class Quaternion {
     static RotationAlphaBetaGamma(alpha: number, beta: number, gamma: number): Quaternion;
     /**
      * Creates a new quaternion from the given Euler float angles expressed in z-x-z orientation and stores it in the target quaternion
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#69
      * @param alpha defines the rotation around first axis
      * @param beta defines the rotation around second axis
      * @param gamma defines the rotation around third axis
@@ -2465,6 +2505,7 @@ export declare class Quaternion {
     static RotationAlphaBetaGammaToRef<T extends Quaternion>(alpha: number, beta: number, gamma: number, result: T): T;
     /**
      * Creates a new quaternion containing the rotation value to reach the target (axis1, axis2, axis3) orientation as a rotated XYZ system (axis1, axis2 and axis3 are normalized during this operation)
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#75
      * @param axis1 defines the first axis
      * @param axis2 defines the second axis
      * @param axis3 defines the third axis
@@ -2473,6 +2514,7 @@ export declare class Quaternion {
     static RotationQuaternionFromAxis(axis1: DeepImmutable<Vector3>, axis2: DeepImmutable<Vector3>, axis3: DeepImmutable<Vector3>): Quaternion;
     /**
      * Creates a rotation value to reach the target (axis1, axis2, axis3) orientation as a rotated XYZ system (axis1, axis2 and axis3 are normalized during this operation) and stores it in the target quaternion
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#76
      * @param axis1 defines the first axis
      * @param axis2 defines the second axis
      * @param axis3 defines the third axis
@@ -2483,6 +2525,7 @@ export declare class Quaternion {
     /**
      * Creates a new rotation value to orient an object to look towards the given forward direction, the up direction being oriented like "up".
      * This function works in left handed mode
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#96
      * @param forward defines the forward direction - Must be normalized and orthogonal to up.
      * @param up defines the up vector for the entity - Must be normalized and orthogonal to forward.
      * @returns A new quaternion oriented toward the specified forward and up.
@@ -2491,6 +2534,7 @@ export declare class Quaternion {
     /**
      * Creates a new rotation value to orient an object to look towards the given forward direction with the up direction being oriented like "up", and stores it in the target quaternion.
      * This function works in left handed mode
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#97
      * @param forward defines the forward direction - Must be normalized and orthogonal to up.
      * @param up defines the up vector for the entity - Must be normalized and orthogonal to forward.
      * @param ref defines the target quaternion.
@@ -2500,6 +2544,7 @@ export declare class Quaternion {
     /**
      * Creates a new rotation value to orient an object to look towards the given forward direction, the up direction being oriented like "up".
      * This function works in right handed mode
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#98
      * @param forward defines the forward direction - Must be normalized and orthogonal to up.
      * @param up defines the up vector for the entity - Must be normalized and orthogonal to forward.
      * @returns A new quaternion oriented toward the specified forward and up.
@@ -2508,6 +2553,7 @@ export declare class Quaternion {
     /**
      * Creates a new rotation value to orient an object to look towards the given forward direction with the up direction being oriented like "up", and stores it in the target quaternion.
      * This function works in right handed mode
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#105
      * @param forward defines the forward direction - Must be normalized and orthogonal to up.
      * @param up defines the up vector for the entity - Must be normalized and orthogonal to forward.
      * @param ref defines the target quaternion.
@@ -2516,6 +2562,7 @@ export declare class Quaternion {
     static FromLookDirectionRHToRef<T extends Quaternion>(forward: DeepImmutable<Vector3>, up: DeepImmutable<Vector3>, ref: T): T;
     /**
      * Interpolates between two quaternions
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#79
      * @param left defines first quaternion
      * @param right defines second quaternion
      * @param amount defines the gradient to use
@@ -2524,6 +2571,7 @@ export declare class Quaternion {
     static Slerp(left: DeepImmutable<Quaternion>, right: DeepImmutable<Quaternion>, amount: number): Quaternion;
     /**
      * Interpolates between two quaternions and stores it into a target quaternion
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#92
      * @param left defines first quaternion
      * @param right defines second quaternion
      * @param amount defines the gradient to use
@@ -2533,6 +2581,8 @@ export declare class Quaternion {
     static SlerpToRef<T extends Quaternion>(left: DeepImmutable<Quaternion>, right: DeepImmutable<Quaternion>, amount: number, result: T): T;
     /**
      * Interpolate between two quaternions using Hermite interpolation
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#47
+     * @see https://doc.babylonjs.com/features/featuresDeepDive/mesh/drawCurves#hermite-quaternion-spline
      * @param value1 defines first quaternion
      * @param tangent1 defines the incoming tangent
      * @param value2 defines second quaternion
@@ -2543,6 +2593,7 @@ export declare class Quaternion {
     static Hermite<T extends Quaternion>(value1: DeepImmutable<T>, tangent1: DeepImmutable<Quaternion>, value2: DeepImmutable<Quaternion>, tangent2: DeepImmutable<Quaternion>, amount: number): T;
     /**
      * Returns a new Quaternion which is the 1st derivative of the Hermite spline defined by the quaternions "value1", "value2", "tangent1", "tangent2".
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#48
      * @param value1 defines the first control point
      * @param tangent1 defines the first tangent
      * @param value2 defines the second control point
@@ -2553,6 +2604,7 @@ export declare class Quaternion {
     static Hermite1stDerivative<T extends Quaternion>(value1: DeepImmutable<T>, tangent1: DeepImmutable<Quaternion>, value2: DeepImmutable<Quaternion>, tangent2: DeepImmutable<Quaternion>, time: number): T;
     /**
      * Update a Quaternion with the 1st derivative of the Hermite spline defined by the quaternions "value1", "value2", "tangent1", "tangent2".
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#49
      * @param value1 defines the first control point
      * @param tangent1 defines the first tangent
      * @param value2 defines the second control point
@@ -2565,6 +2617,20 @@ export declare class Quaternion {
 }
 /**
  * Class used to store matrix data (4x4)
+ * Note on matrix definitions in Babylon.js for setting values directly rather than using one of the methods available.
+ * Matrix size is given by rows x columns.
+ * A Vector3 is a 1 X 3 matrix [x, y, z].
+ * In Babylon.js multiplying a 1 x 3 matrix by a 4 x 4 matrix
+ * is done using BABYLON.Vector4.TransformCoordinates(vector3, matrix)
+ * and extending the passed Vector3 to a Vector4 [x, y, z, w] with w = 1.
+ * The multiplication has this form
+ * [x, y, z, w] |m0,  m1,  m2,  m3 |
+ *              |m4,  m5,  m6,  m7 |
+ *              |m8,  m9,  m10, m11|
+ *              |m12, m13, m14, m15|
+ *
+ * = [xm0 + ym4 + zm8 + wm12, xm1 + ym5 + zm9 + wm13, xm2 + ym6 + zm10 + wm14, xm3 + ym7 + zm11 + wm15]
+ *
  */
 export declare class Matrix {
     /**
@@ -2711,6 +2777,7 @@ export declare class Matrix {
     removeRotationAndScaling(): this;
     /**
      * Multiply two matrices
+     * A.multiply(B) means apply B to A so result is B x A
      * @param other defines the second operand
      * @returns a new matrix set with the multiplication result of the current Matrix and the given one
      */
@@ -2730,6 +2797,7 @@ export declare class Matrix {
     copyToArray(array: Float32Array | Array<number>, offset?: number): this;
     /**
      * Sets the given matrix "result" with the multiplication result of the current Matrix and the given one
+     * A.multiplyToRef(B, R) means apply B to A and store in R and R = B x A
      * @param other defines the second operand
      * @param result defines the matrix where to store the multiplication
      * @returns result input