@babylonjs/core 6.45.0 → 6.46.0

package/Maths/math.vector.js

@@ -1,10 +1,10 @@
 /* eslint-disable @typescript-eslint/naming-convention */
-import { Scalar } from "./math.scalar.js";
 import { Epsilon } from "./math.constants.js";
 import { ArrayTools } from "../Misc/arrayTools.js";
 import { RegisterClass } from "../Misc/typeStore.js";
 import { PerformanceConfigurator } from "../Engines/performanceConfigurator.js";
 import { EngineStore } from "../Engines/engineStore.js";
+import { Clamp, Lerp, NormalizeRadians, RandomRange, WithinEpsilon } from "./math.scalar.functions.js";
 // eslint-disable-next-line @typescript-eslint/naming-convention
 const _ExtractAsInt = (value) => {
     return parseInt(value.toString().replace(/\W/g, ""));
@@ -69,11 +69,11 @@ export class Vector2 {
      * Update the current vector from an array
      * Example Playground https://playground.babylonjs.com/#QYBWV4#39
      * @param array defines the destination array
-     * @param index defines the offset in the destination array
+     * @param offset defines the offset in the destination array
      * @returns the current Vector2
      */
-    fromArray(array, index = 0) {
-        Vector2.FromArrayToRef(array, index, this);
+    fromArray(array, offset = 0) {
+        Vector2.FromArrayToRef(array, offset, this);
         return this;
     }
     /**
@@ -82,9 +82,7 @@ export class Vector2 {
      * @returns a new array with 2 elements: the Vector2 coordinates.
      */
     asArray() {
-        const result = [];
-        this.toArray(result, 0);
-        return result;
+        return [this.x, this.y];
     }
     /**
      * Sets the Vector2 coordinates with the given Vector2 coordinates
@@ -119,6 +117,14 @@ export class Vector2 {
     set(x, y) {
         return this.copyFromFloats(x, y);
     }
+    /**
+     * Copies the given float to the current Vector2 coordinates
+     * @param v defines the x and y coordinates of the operand
+     * @returns the current updated Vector2
+     */
+    setAll(v) {
+        return this.copyFromFloats(v, v);
+    }
     /**
      * Add another vector with the current one
      * Example Playground https://playground.babylonjs.com/#QYBWV4#11
@@ -151,6 +157,17 @@ export class Vector2 {
         this.y += otherVector.y;
         return this;
     }
+    /**
+     * Adds the given coordinates to the current Vector2
+     * @param x defines the x coordinate of the operand
+     * @param y defines the y coordinate of the operand
+     * @returns the current updated Vector2
+     */
+    addInPlaceFromFloats(x, y) {
+        this.x += x;
+        this.y += y;
+        return this;
+    }
     /**
      * Gets a new Vector2 by adding the current Vector2 coordinates to the given Vector3 x, y coordinates
      * Example Playground https://playground.babylonjs.com/#QYBWV4#14
@@ -262,11 +279,69 @@ export class Vector2 {
      * @returns the current updated Vector2
      */
     divideInPlace(otherVector) {
-        return this.divideToRef(otherVector, this);
+        this.x = this.x / otherVector.x;
+        this.y = this.y / otherVector.y;
+        return this;
+    }
+    /**
+     * Updates the current Vector2 with the minimal coordinate values between its and the given vector ones
+     * @param other defines the second operand
+     * @returns the current updated Vector2
+     */
+    minimizeInPlace(other) {
+        return this.minimizeInPlaceFromFloats(other.x, other.y);
+    }
+    /**
+     * Updates the current Vector2 with the maximal coordinate values between its and the given vector ones.
+     * @param other defines the second operand
+     * @returns the current updated Vector2
+     */
+    maximizeInPlace(other) {
+        return this.maximizeInPlaceFromFloats(other.x, other.y);
+    }
+    /**
+     * Updates the current Vector2 with the minimal coordinate values between its and the given coordinates
+     * @param x defines the x coordinate of the operand
+     * @param y defines the y coordinate of the operand
+     * @returns the current updated Vector2
+     */
+    minimizeInPlaceFromFloats(x, y) {
+        this.x = Math.min(x, this.x);
+        this.y = Math.min(y, this.y);
+        return this;
+    }
+    /**
+     * Updates the current Vector2 with the maximal coordinate values between its and the given coordinates.
+     * @param x defines the x coordinate of the operand
+     * @param y defines the y coordinate of the operand
+     * @returns the current updated Vector2
+     */
+    maximizeInPlaceFromFloats(x, y) {
+        this.x = Math.max(x, this.x);
+        this.y = Math.max(y, this.y);
+        return this;
+    }
+    /**
+     * Returns a new Vector2 set with the subtraction of the given floats from the current Vector2 coordinates
+     * @param x defines the x coordinate of the operand
+     * @param y defines the y coordinate of the operand
+     * @returns the resulting Vector2
+     */
+    subtractFromFloats(x, y) {
+        return new this.constructor(this.x - x, this.y - y);
+    }
+    /**
+     * Subtracts the given floats from the current Vector2 coordinates and set the given vector "result" with this result
+     * @param x defines the x coordinate of the operand
+     * @param y defines the y coordinate of the operand
+     * @param result defines the Vector2 object where to store the result
+     * @returns the result
+     */
+    subtractFromFloatsToRef(x, y, result) {
+        return result.copyFromFloats(this.x - x, this.y - y);
     }
     /**
      * Gets a new Vector2 with current Vector2 negated coordinates
-     * Example Playground https://playground.babylonjs.com/#QYBWV4#22
      * @returns a new Vector2
      */
     negate() {
@@ -309,9 +384,7 @@ export class Vector2 {
      * @returns a new Vector2
      */
     scale(scale) {
-        const result = new this.constructor(0, 0);
-        this.scaleToRef(scale, result);
-        return result;
+        return new this.constructor(this.x * scale, this.y * scale);
     }
     /**
      * Scale the current Vector2 values by a factor to a given Vector2
@@ -354,7 +427,16 @@ export class Vector2 {
      * @returns true if the given vector coordinates are close to the current ones by a distance of epsilon.
      */
     equalsWithEpsilon(otherVector, epsilon = Epsilon) {
-        return otherVector && Scalar.WithinEpsilon(this.x, otherVector.x, epsilon) && Scalar.WithinEpsilon(this.y, otherVector.y, epsilon);
+        return otherVector && WithinEpsilon(this.x, otherVector.x, epsilon) && WithinEpsilon(this.y, otherVector.y, epsilon);
+    }
+    /**
+     * Returns true if the current Vector2 coordinates equals the given floats
+     * @param x defines the x coordinate of the operand
+     * @param y defines the y coordinate of the operand
+     * @returns true if both vectors are equal
+     */
+    equalsToFloats(x, y) {
+        return this.x === x && this.y === y;
     }
     /**
      * Gets a new Vector2 from current Vector2 floored values
@@ -365,6 +447,16 @@ export class Vector2 {
     floor() {
         return new this.constructor(Math.floor(this.x), Math.floor(this.y));
     }
+    /**
+     * Gets the current Vector2's floored values and stores them in result
+     * @param result the Vector2 to store the result in
+     * @returns the result Vector2
+     */
+    floorToRef(result) {
+        result.x = Math.floor(this.x);
+        result.y = Math.floor(this.y);
+        return result;
+    }
     /**
      * Gets a new Vector2 from current Vector2 fractional values
      * Example Playground https://playground.babylonjs.com/#QYBWV4#34
@@ -374,6 +466,16 @@ export class Vector2 {
     fract() {
         return new this.constructor(this.x - Math.floor(this.x), this.y - Math.floor(this.y));
     }
+    /**
+     * Gets the current Vector2's fractional values and stores them in result
+     * @param result the Vector2 to store the result in
+     * @returns the result Vector2
+     */
+    fractToRef(result) {
+        result.x = this.x - Math.floor(this.x);
+        result.y = this.y - Math.floor(this.y);
+        return result;
+    }
     /**
      * Rotate the current vector into a given result vector
      * Example Playground https://playground.babylonjs.com/#QYBWV4#49
@@ -431,19 +533,19 @@ export class Vector2 {
      * @returns the new Vector2
      */
     normalizeToNew() {
-        const normalized = new this.constructor(0, 0);
+        const normalized = new this.constructor();
         this.normalizeToRef(normalized);
         return normalized;
     }
     /**
      * Normalize the current Vector2 to the reference
-     * @param reference define the Vector2 to update
+     * @param reference define the Vector to update
      * @returns the updated Vector2
      */
     normalizeToRef(reference) {
         const len = this.length();
-        if (len === 0 || len === 1.0) {
-            return reference.copyFromFloats(this.x, this.y);
+        if (len === 0) {
+            return reference.copyFrom(this);
         }
         return this.scaleToRef(1.0 / len, reference);
     }
@@ -485,7 +587,17 @@ export class Vector2 {
      * @returns a Vector2 with random values between min and max
      */
     static Random(min = 0, max = 1) {
-        return new Vector2(Scalar.RandomRange(min, max), Scalar.RandomRange(min, max));
+        return new Vector2(RandomRange(min, max), RandomRange(min, max));
+    }
+    /**
+     * Sets a Vector2 with random values between min and max
+     * @param min the minimum random value
+     * @param max the maximum random value
+     * @param ref the ref to store the values in
+     * @returns the ref with random values between min and max
+     */
+    static RandomToRef(min = 0, max = 1, ref) {
+        return ref.copyFromFloats(RandomRange(min, max), RandomRange(min, max));
     }
     /**
      * Gets a zero Vector2 that must not be updated
@@ -516,6 +628,17 @@ export class Vector2 {
         result.y = array[offset + 1];
         return result;
     }
+    /**
+     * Sets the given vector "result" with the given floats.
+     * @param x defines the x coordinate of the source
+     * @param y defines the y coordinate of the source
+     * @param result defines the Vector2 where to store the result
+     * @returns the result vector
+     */
+    static FromFloatsToRef(x, y, result) {
+        result.copyFromFloats(x, y);
+        return result;
+    }
     /**
      * Gets a new Vector2 located for "amount" (float) on the CatmullRom spline defined by the given four Vector2
      * Example Playground https://playground.babylonjs.com/#QYBWV4#65
@@ -541,6 +664,21 @@ export class Vector2 {
                 (-value1.y + 3.0 * value2.y - 3.0 * value3.y + value4.y) * cubed);
         return new value1.constructor(x, y);
     }
+    /**
+     * Sets reference with same the coordinates than "value" ones if the vector "value" is in the square defined by "min" and "max".
+     * If a coordinate of "value" is lower than "min" coordinates, the returned Vector2 is given this "min" coordinate.
+     * If a coordinate of "value" is greater than "max" coordinates, the returned Vector2 is given this "max" coordinate
+     * @param value defines the value to clamp
+     * @param min defines the lower limit
+     * @param max defines the upper limit
+     * @param ref the reference
+     * @returns the reference
+     */
+    static ClampToRef(value, min, max, ref) {
+        ref.x = Clamp(value.x, min.x, max.x);
+        ref.y = Clamp(value.y, min.y, max.y);
+        return ref;
+    }
     /**
      * Returns a new Vector2 set with same the coordinates than "value" ones if the vector "value" is in the square defined by "min" and "max".
      * If a coordinate of "value" is lower than "min" coordinates, the returned Vector2 is given this "min" coordinate.
@@ -552,12 +690,8 @@ export class Vector2 {
      * @returns a new Vector2
      */
     static Clamp(value, min, max) {
-        let x = value.x;
-        x = x > max.x ? max.x : x;
-        x = x < min.x ? min.x : x;
-        let y = value.y;
-        y = y > max.y ? max.y : y;
-        y = y < min.y ? min.y : y;
+        const x = Clamp(value.x, min.x, max.x);
+        const y = Clamp(value.y, min.y, max.y);
         return new value.constructor(x, y);
     }
     /**
@@ -791,6 +925,11 @@ export class Vector2 {
     }
 }
 Vector2._ZeroReadOnly = Vector2.Zero();
+Vector2;
+Object.defineProperties(Vector2.prototype, {
+    dimension: { value: [2] },
+    rank: { value: 1 },
+});
 /**
  * Class used to store (x,y,z) vector representation
  * A Vector3 is the main object used in 3D geometry
@@ -871,9 +1010,7 @@ export class Vector3 {
      * @returns a new array of numbers
      */
     asArray() {
-        const result = [];
-        this.toArray(result, 0);
-        return result;
+        return [this._x, this._y, this._z];
     }
     /**
      * Populates the given array or Float32Array from the given index with the successive coordinates of the Vector3
@@ -892,11 +1029,11 @@ export class Vector3 {
      * Update the current vector from an array
      * Example Playground https://playground.babylonjs.com/#R1F8YU#24
      * @param array defines the destination array
-     * @param index defines the offset in the destination array
+     * @param offset defines the offset in the destination array
      * @returns the current Vector3
      */
-    fromArray(array, index = 0) {
-        Vector3.FromArrayToRef(array, index, this);
+    fromArray(array, offset = 0) {
+        Vector3.FromArrayToRef(array, offset, this);
         return this;
     }
     /**
@@ -914,7 +1051,11 @@ export class Vector3 {
      * @returns the current updated Vector3
      */
     addInPlace(otherVector) {
-        return this.addInPlaceFromFloats(otherVector._x, otherVector._y, otherVector._z);
+        this._x += otherVector._x;
+        this._y += otherVector._y;
+        this._z += otherVector._z;
+        this._isDirty = true;
+        return this;
     }
     /**
      * Adds the given coordinates to the current Vector3
@@ -1206,10 +1347,7 @@ export class Vector3 {
      * @returns true if both vectors are distant less than epsilon
      */
     equalsWithEpsilon(otherVector, epsilon = Epsilon) {
-        return (otherVector &&
-            Scalar.WithinEpsilon(this._x, otherVector._x, epsilon) &&
-            Scalar.WithinEpsilon(this._y, otherVector._y, epsilon) &&
-            Scalar.WithinEpsilon(this._z, otherVector._z, epsilon));
+        return otherVector && WithinEpsilon(this._x, otherVector._x, epsilon) && WithinEpsilon(this._y, otherVector._y, epsilon) && WithinEpsilon(this._z, otherVector._z, epsilon);
     }
     /**
      * Returns true if the current Vector3 coordinates equals the given floats
@@ -1291,7 +1429,11 @@ export class Vector3 {
      * @returns the current updated Vector3
      */
     divideInPlace(otherVector) {
-        return this.divideToRef(otherVector, this);
+        this._x = this._x / otherVector._x;
+        this._y = this._y / otherVector._y;
+        this._z = this._z / otherVector._z;
+        this._isDirty = true;
+        return this;
     }
     /**
      * Updates the current Vector3 with the minimal coordinate values between its and the given vector ones
@@ -1360,14 +1502,14 @@ export class Vector3 {
     isNonUniformWithinEpsilon(epsilon) {
         const absX = Math.abs(this._x);
         const absY = Math.abs(this._y);
-        if (!Scalar.WithinEpsilon(absX, absY, epsilon)) {
+        if (!WithinEpsilon(absX, absY, epsilon)) {
             return true;
         }
         const absZ = Math.abs(this._z);
-        if (!Scalar.WithinEpsilon(absX, absZ, epsilon)) {
+        if (!WithinEpsilon(absX, absZ, epsilon)) {
             return true;
         }
-        if (!Scalar.WithinEpsilon(absY, absZ, epsilon)) {
+        if (!WithinEpsilon(absY, absZ, epsilon)) {
             return true;
         }
         return false;
@@ -1387,13 +1529,37 @@ export class Vector3 {
         }
         return false;
     }
+    /**
+     * Gets the current Vector3's floored values and stores them in result
+     * @param result the vector to store the result in
+     * @returns the result vector
+     */
+    floorToRef(result) {
+        result._x = Math.floor(this._x);
+        result._y = Math.floor(this._y);
+        result._z = Math.floor(this._z);
+        result._isDirty = true;
+        return result;
+    }
     /**
      * Gets a new Vector3 from current Vector3 floored values
      * Example Playground https://playground.babylonjs.com/#R1F8YU#22
      * @returns a new Vector3
      */
     floor() {
-        return new this.constructor(Math.floor(this._x), Math.floor(this._y), Math.floor(this._z));
+        return new this.constructor(Math.floor(this.x), Math.floor(this.y), Math.floor(this.z));
+    }
+    /**
+     * Gets the current Vector3's fractional values and stores them in result
+     * @param result the vector to store the result in
+     * @returns the result vector
+     */
+    fractToRef(result) {
+        result._x = this.x - Math.floor(this._x);
+        result._y = this.y - Math.floor(this._y);
+        result._z = this.z - Math.floor(this._z);
+        result._isDirty = true;
+        return result;
     }
     /**
      * Gets a new Vector3 from current Vector3 fractional values
@@ -1401,7 +1567,7 @@ export class Vector3 {
      * @returns a new Vector3
      */
     fract() {
-        return new this.constructor(this._x - Math.floor(this._x), this._y - Math.floor(this._y), this._z - Math.floor(this._z));
+        return new this.constructor(this.x - Math.floor(this._x), this.y - Math.floor(this._y), this.z - Math.floor(this._z));
     }
     // Properties
     /**
@@ -1410,7 +1576,7 @@ export class Vector3 {
      * @returns the length of the Vector3
      */
     length() {
-        return Math.sqrt(this._x * this._x + this._y * this._y + this._z * this._z);
+        return Math.sqrt(this.lengthSquared());
     }
     /**
      * Gets the squared length of the Vector3
@@ -1522,7 +1688,7 @@ export class Vector3 {
     normalizeToRef(reference) {
         const len = this.length();
         if (len === 0 || len === 1.0) {
-            return reference.copyFromFloats(this._x, this._y, this._z);
+            return reference.copyFrom(this);
         }
         return this.scaleToRef(1.0 / len, reference);
     }
@@ -1608,7 +1774,7 @@ export class Vector3 {
         const v1 = vector1.normalizeToRef(MathTmp.Vector3[2]);
         let dot = Vector3.Dot(v0, v1);
         // Vectors are normalized so dot will be in [-1, 1] (aside precision issues enough to break the result which explains the below clamp)
-        dot = Scalar.Clamp(dot, -1, 1);
+        dot = Clamp(dot, -1, 1);
         const angle = Math.acos(dot);
         const n = MathTmp.Vector3[3];
         Vector3.CrossToRef(v0, v1, n);
@@ -1641,7 +1807,7 @@ export class Vector3 {
         Vector3.CrossToRef(vNormal, v0, right);
         Vector3.CrossToRef(right, vNormal, forward);
         const angle = Math.atan2(Vector3.Dot(v1, right), Vector3.Dot(v1, forward));
-        return Scalar.NormalizeRadians(angle);
+        return NormalizeRadians(angle);
     }
     /**
      * Gets the rotation that aligns the roll axis (Y) to the line joining the start point to the target point and stores it in the ref Vector3
@@ -1684,7 +1850,7 @@ export class Vector3 {
      * @returns The slerped vector
      */
     static SlerpToRef(vector0, vector1, slerp, result) {
-        slerp = Scalar.Clamp(slerp, 0, 1);
+        slerp = Clamp(slerp, 0, 1);
         const vector0Dir = MathTmp.Vector3[0];
         const vector1Dir = MathTmp.Vector3[1];
         vector0Dir.copyFrom(vector0);
@@ -1710,7 +1876,7 @@ export class Vector3 {
         vector0Dir.scaleInPlace(scale0);
         vector1Dir.scaleInPlace(scale1);
         result.copyFrom(vector0Dir).addInPlace(vector1Dir);
-        result.scaleInPlace(Scalar.Lerp(vector0Length, vector1Length, slerp));
+        result.scaleInPlace(Lerp(vector0Length, vector1Length, slerp));
         return result;
     }
     /**
@@ -1917,7 +2083,17 @@ export class Vector3 {
      * @returns a Vector3 with random values between min and max
      */
     static Random(min = 0, max = 1) {
-        return new Vector3(Scalar.RandomRange(min, max), Scalar.RandomRange(min, max), Scalar.RandomRange(min, max));
+        return new Vector3(RandomRange(min, max), RandomRange(min, max), RandomRange(min, max));
+    }
+    /**
+     * Sets a Vector3 with random values between min and max
+     * @param min the minimum random value
+     * @param max the maximum random value
+     * @param ref the ref to store the values in
+     * @returns the ref with random values between min and max
+     */
+    static RandomToRef(min = 0, max = 1, ref) {
+        return ref.copyFromFloats(RandomRange(min, max), RandomRange(min, max), RandomRange(min, max));
     }
     /**
      * Returns a new Vector3 set with the result of the transformation by the given matrix of the given vector.
@@ -2312,7 +2488,7 @@ export class Vector3 {
         Vector3.TransformCoordinatesToRef(source, matrix, result);
         const m = matrix.m;
         const num = source._x * m[3] + source._y * m[7] + source._z * m[11] + m[15];
-        if (Scalar.WithinEpsilon(num, 1.0)) {
+        if (WithinEpsilon(num, 1.0)) {
             result.scaleInPlace(1.0 / num);
         }
         return result;
@@ -2577,7 +2753,7 @@ export class Vector3 {
         l = edge.length();
         edge.normalizeFromLength(l);
         let t = Vector3.Dot(tmp, edge) / Math.max(l, Epsilon);
-        t = Scalar.Clamp(t, 0, 1);
+        t = Clamp(t, 0, 1);
         triProj.copyFrom(e0).addInPlace(edge.scaleInPlace(t * l));
         ref.copyFrom(triProj);
         return Vector3.Distance(vector, triProj);
@@ -2646,6 +2822,11 @@ Vector3._RightReadOnly = Vector3.Right();
 Vector3._LeftReadOnly = Vector3.Left();
 Vector3._ZeroReadOnly = Vector3.Zero();
 Vector3._OneReadOnly = Vector3.One();
+Vector3;
+Object.defineProperties(Vector3.prototype, {
+    dimension: { value: [3] },
+    rank: { value: 1 },
+});
 /**
  * Vector4 class created for EulerAngle class conversion to Quaternion
  */
@@ -2706,9 +2887,7 @@ export class Vector4 {
      * @returns the resulting array
      */
     asArray() {
-        const result = [];
-        this.toArray(result, 0);
-        return result;
+        return [this.x, this.y, this.z, this.w];
     }
     /**
      * Populates the given array from the given index with the Vector4 coordinates.
@@ -2729,11 +2908,11 @@ export class Vector4 {
     /**
      * Update the current vector from an array
      * @param array defines the destination array
-     * @param index defines the offset in the destination array
+     * @param offset defines the offset in the destination array
      * @returns the current Vector3
      */
-    fromArray(array, index = 0) {
-        Vector4.FromArrayToRef(array, index, this);
+    fromArray(array, offset = 0) {
+        Vector4.FromArrayToRef(array, offset, this);
         return this;
     }
     /**
@@ -2748,6 +2927,21 @@ export class Vector4 {
         this.w += otherVector.w;
         return this;
     }
+    /**
+     * Adds the given coordinates to the current Vector4
+     * @param x defines the x coordinate of the operand
+     * @param y defines the y coordinate of the operand
+     * @param z defines the z coordinate of the operand
+     * @param w defines the w coordinate of the operand
+     * @returns the current updated Vector4
+     */
+    addInPlaceFromFloats(x, y, z, w) {
+        this.x += x;
+        this.y += y;
+        this.z += z;
+        this.w += w;
+        return this;
+    }
     /**
      * Returns a new Vector4 as the result of the addition of the current Vector4 and the given one.
      * @param otherVector the vector to add
@@ -2802,9 +2996,6 @@ export class Vector4 {
         result.w = this.w - otherVector.w;
         return result;
     }
-    /**
-     * Returns a new Vector4 set with the result of the subtraction of the given floats from the current Vector4 coordinates.
-     */
     /**
      * Returns a new Vector4 set with the result of the subtraction of the given floats from the current Vector4 coordinates.
      * @param x value to subtract
@@ -2920,10 +3111,10 @@ export class Vector4 {
      */
     equalsWithEpsilon(otherVector, epsilon = Epsilon) {
         return (otherVector &&
-            Scalar.WithinEpsilon(this.x, otherVector.x, epsilon) &&
-            Scalar.WithinEpsilon(this.y, otherVector.y, epsilon) &&
-            Scalar.WithinEpsilon(this.z, otherVector.z, epsilon) &&
-            Scalar.WithinEpsilon(this.w, otherVector.w, epsilon));
+            WithinEpsilon(this.x, otherVector.x, epsilon) &&
+            WithinEpsilon(this.y, otherVector.y, epsilon) &&
+            WithinEpsilon(this.z, otherVector.z, epsilon) &&
+            WithinEpsilon(this.w, otherVector.w, epsilon));
     }
     /**
      * Boolean : True if the given floats are strictly equal to the current Vector4 coordinates.
@@ -3049,6 +3240,48 @@ export class Vector4 {
         }
         return this;
     }
+    /**
+     * Updates the current Vector4 with the minimal coordinate values between its and the given coordinates
+     * @param x defines the x coordinate of the operand
+     * @param y defines the y coordinate of the operand
+     * @param z defines the z coordinate of the operand
+     * @param w defines the w coordinate of the operand
+     * @returns the current updated Vector4
+     */
+    minimizeInPlaceFromFloats(x, y, z, w) {
+        this.x = Math.min(x, this.x);
+        this.y = Math.min(y, this.y);
+        this.z = Math.min(z, this.z);
+        this.w = Math.min(w, this.w);
+        return this;
+    }
+    /**
+     * Updates the current Vector4 with the maximal coordinate values between its and the given coordinates.
+     * @param x defines the x coordinate of the operand
+     * @param y defines the y coordinate of the operand
+     * @param z defines the z coordinate of the operand
+     * @param w defines the w coordinate of the operand
+     * @returns the current updated Vector4
+     */
+    maximizeInPlaceFromFloats(x, y, z, w) {
+        this.x = Math.max(x, this.x);
+        this.y = Math.max(y, this.y);
+        this.z = Math.max(z, this.z);
+        this.w = Math.max(w, this.w);
+        return this;
+    }
+    /**
+     * Gets the current Vector4's floored values and stores them in result
+     * @param result the vector to store the result in
+     * @returns the result vector
+     */
+    floorToRef(result) {
+        result.x = Math.floor(this.x);
+        result.y = Math.floor(this.y);
+        result.z = Math.floor(this.z);
+        result.w = Math.floor(this.w);
+        return result;
+    }
     /**
      * Gets a new Vector4 from current Vector4 floored values
      * @returns a new Vector4
@@ -3056,6 +3289,18 @@ export class Vector4 {
     floor() {
         return new this.constructor(Math.floor(this.x), Math.floor(this.y), Math.floor(this.z), Math.floor(this.w));
     }
+    /**
+     * Gets the current Vector4's fractional values and stores them in result
+     * @param result the vector to store the result in
+     * @returns the result vector
+     */
+    fractToRef(result) {
+        result.x = this.x - Math.floor(this.x);
+        result.y = this.y - Math.floor(this.y);
+        result.z = this.z - Math.floor(this.z);
+        result.w = this.w - Math.floor(this.w);
+        return result;
+    }
     /**
      * Gets a new Vector4 from current Vector4 fractional values
      * @returns a new Vector4
@@ -3103,7 +3348,7 @@ export class Vector4 {
      * @returns the new Vector4
      */
     normalizeToNew() {
-        const normalized = new this.constructor(0, 0, 0, 0);
+        const normalized = new this.constructor();
         this.normalizeToRef(normalized);
         return normalized;
     }
@@ -3115,7 +3360,7 @@ export class Vector4 {
     normalizeToRef(reference) {
         const len = this.length();
         if (len === 0 || len === 1.0) {
-            return reference.copyFromFloats(this.x, this.y, this.z, this.w);
+            return reference.copyFrom(this);
         }
         return this.scaleToRef(1.0 / len, reference);
     }
@@ -3172,9 +3417,9 @@ export class Vector4 {
         return this.copyFromFloats(x, y, z, w);
     }
     /**
-     * Copies the given float to the current Vector3 coordinates
+     * Copies the given float to the current Vector4 coordinates
      * @param v defines the x, y, z and w coordinates of the operand
-     * @returns the current updated Vector3
+     * @returns the current updated Vector4
      */
     setAll(v) {
         this.x = this.y = this.z = this.w = v;
@@ -3263,7 +3508,55 @@ export class Vector4 {
      * @returns a Vector4 with random values between min and max
      */
     static Random(min = 0, max = 1) {
-        return new Vector4(Scalar.RandomRange(min, max), Scalar.RandomRange(min, max), Scalar.RandomRange(min, max), Scalar.RandomRange(min, max));
+        return new Vector4(RandomRange(min, max), RandomRange(min, max), RandomRange(min, max), RandomRange(min, max));
+    }
+    /**
+     * Sets a Vector4 with random values between min and max
+     * @param min the minimum random value
+     * @param max the maximum random value
+     * @param ref the ref to store the values in
+     * @returns the ref with random values between min and max
+     */
+    static RandomToRef(min = 0, max = 1, ref) {
+        return ref.copyFromFloats(RandomRange(min, max), RandomRange(min, max), RandomRange(min, max), RandomRange(min, max));
+    }
+    /**
+     * Returns a new Vector4 set with the coordinates of "value", if the vector "value" is in the cube defined by the vectors "min" and "max"
+     * If a coordinate value of "value" is lower than one of the "min" coordinate, then this "value" coordinate is set with the "min" one
+     * If a coordinate value of "value" is greater than one of the "max" coordinate, then this "value" coordinate is set with the "max" one
+     * @param value defines the current value
+     * @param min defines the lower range value
+     * @param max defines the upper range value
+     * @returns the new Vector4
+     */
+    static Clamp(value, min, max) {
+        const result = new value.constructor();
+        Vector4.ClampToRef(value, min, max, result);
+        return result;
+    }
+    /**
+     * Sets the given vector "result" with the coordinates of "value", if the vector "value" is in the cube defined by the vectors "min" and "max"
+     * If a coordinate value of "value" is lower than one of the "min" coordinate, then this "value" coordinate is set with the "min" one
+     * If a coordinate value of "value" is greater than one of the "max" coordinate, then this "value" coordinate is set with the "max" one
+     * @param value defines the current value
+     * @param min defines the lower range value
+     * @param max defines the upper range value
+     * @param result defines the Vector4 where to store the result
+     * @returns result input
+     */
+    static ClampToRef(value, min, max, result) {
+        return result.copyFromFloats(Clamp(value.x, min.x, max.x), Clamp(value.y, min.y, max.y), Clamp(value.z, min.z, max.z), Clamp(value.w, min.w, max.w));
+    }
+    /**
+     * Checks if a given vector is inside a specific range
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#75
+     * @param v defines the vector to test
+     * @param min defines the minimum range
+     * @param max defines the maximum range
+     */
+    static CheckExtends(v, min, max) {
+        min.minimizeInPlace(v);
+        max.maximizeInPlace(v);
     }
     /**
      * Gets a zero Vector4 that must not be updated
@@ -3475,6 +3768,11 @@ export class Vector4 {
     }
 }
 Vector4._ZeroReadOnly = Vector4.Zero();
+Vector4;
+Object.defineProperties(Vector4.prototype, {
+    dimension: { value: [4] },
+    rank: { value: 1 },
+});
 /**
  * Class used to store quaternion data
  * Example Playground - Overview - https://playground.babylonjs.com/#L49EJ7#100
@@ -3580,6 +3878,9 @@ export class Quaternion {
         array[index + 3] = this._w;
         return this;
     }
+    fromArray(array, index = 0) {
+        return Quaternion.FromArrayToRef(array, index, this);
+    }
     /**
      * Check if two quaternions are equals
      * Example Playground https://playground.babylonjs.com/#L49EJ7#38
@@ -3598,10 +3899,10 @@ export class Quaternion {
      */
     equalsWithEpsilon(otherQuaternion, epsilon = Epsilon) {
         return (otherQuaternion &&
-            Scalar.WithinEpsilon(this._x, otherQuaternion._x, epsilon) &&
-            Scalar.WithinEpsilon(this._y, otherQuaternion._y, epsilon) &&
-            Scalar.WithinEpsilon(this._z, otherQuaternion._z, epsilon) &&
-            Scalar.WithinEpsilon(this._w, otherQuaternion._w, epsilon));
+            WithinEpsilon(this._x, otherQuaternion._x, epsilon) &&
+            WithinEpsilon(this._y, otherQuaternion._y, epsilon) &&
+            WithinEpsilon(this._z, otherQuaternion._z, epsilon) &&
+            WithinEpsilon(this._w, otherQuaternion._w, epsilon));
     }
     /**
      * Clone the current quaternion
@@ -3654,6 +3955,9 @@ export class Quaternion {
     set(x, y, z, w) {
         return this.copyFromFloats(x, y, z, w);
     }
+    setAll(value) {
+        return this.copyFromFloats(value, value, value, value);
+    }
     /**
      * Adds two quaternions
      * Example Playground https://playground.babylonjs.com/#L49EJ7#10
@@ -3677,6 +3981,41 @@ export class Quaternion {
         this._isDirty = true;
         return this;
     }
+    addToRef(other, result) {
+        result._x = this._x + other._x;
+        result._y = this._y + other._y;
+        result._z = this._z + other._z;
+        result._w = this._w + other._w;
+        result._isDirty = true;
+        return result;
+    }
+    addInPlaceFromFloats(x, y, z, w) {
+        this._x += x;
+        this._y += y;
+        this._z += z;
+        this._w += w;
+        this._isDirty = true;
+        return this;
+    }
+    subtractToRef(other, result) {
+        result._x = this._x - other._x;
+        result._y = this._y - other._y;
+        result._z = this._z - other._z;
+        result._w = this._w - other._w;
+        result._isDirty = true;
+        return result;
+    }
+    subtractFromFloats(x, y, z, w) {
+        return this.subtractFromFloatsToRef(x, y, z, w, new this.constructor());
+    }
+    subtractFromFloatsToRef(x, y, z, w, result) {
+        result._x = this._x - x;
+        result._y = this._y - y;
+        result._z = this._z - z;
+        result._w = this._w - w;
+        result._isDirty = true;
+        return result;
+    }
     /**
      * Subtract two quaternions
      * Example Playground https://playground.babylonjs.com/#L49EJ7#57
@@ -3782,39 +4121,145 @@ export class Quaternion {
     /**
      * 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
+     * @param other defines the second operand
      * @returns the currentupdated quaternion
      */
-    multiplyInPlace(q1) {
-        this.multiplyToRef(q1, this);
+    multiplyInPlace(other) {
+        return this.multiplyToRef(other, this);
+    }
+    multiplyByFloats(x, y, z, w) {
+        this._x *= x;
+        this._y *= y;
+        this._z *= z;
+        this._w *= w;
+        this._isDirty = true;
         return 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
+     * @internal
+     * Do not use
      */
-    conjugateToRef(ref) {
-        ref.copyFromFloats(-this._x, -this._y, -this._z, this._w);
-        return ref;
+    divide(_other) {
+        throw new ReferenceError("Can not divide a quaternion");
     }
     /**
-     * Conjugates in place the current quaternion
-     * Example Playground https://playground.babylonjs.com/#L49EJ7#82
-     * @returns the current updated quaternion
+     * @internal
+     * Do not use
      */
-    conjugateInPlace() {
-        this._x *= -1;
-        this._y *= -1;
-        this._z *= -1;
-        this._isDirty = true;
-        return this;
+    divideToRef(_other, _result) {
+        throw new ReferenceError("Can not divide a quaternion");
     }
     /**
-     * Conjugates (1-q) the current quaternion
-     * Example Playground https://playground.babylonjs.com/#L49EJ7#83
-     * @returns a new quaternion
+     * @internal
+     * Do not use
+     */
+    divideInPlace(_other) {
+        throw new ReferenceError("Can not divide a quaternion");
+    }
+    /**
+     * @internal
+     * Do not use
+     */
+    minimizeInPlace() {
+        throw new ReferenceError("Can not minimize a quaternion");
+    }
+    /**
+     * @internal
+     * Do not use
+     */
+    minimizeInPlaceFromFloats() {
+        throw new ReferenceError("Can not minimize a quaternion");
+    }
+    /**
+     * @internal
+     * Do not use
+     */
+    maximizeInPlace() {
+        throw new ReferenceError("Can not maximize a quaternion");
+    }
+    /**
+     * @internal
+     * Do not use
+     */
+    maximizeInPlaceFromFloats() {
+        throw new ReferenceError("Can not maximize a quaternion");
+    }
+    negate() {
+        return this.negateToRef(new this.constructor());
+    }
+    negateInPlace() {
+        this._x = -this._x;
+        this._y = -this._y;
+        this._z = -this._z;
+        this._w = -this._w;
+        this._isDirty = true;
+        return this;
+    }
+    negateToRef(result) {
+        result._x = -this._x;
+        result._y = -this._y;
+        result._z = -this._z;
+        result._w = -this._w;
+        result._isDirty = true;
+        return result;
+    }
+    equalsToFloats(x, y, z, w) {
+        return this._x === x && this._y === y && this._z === z && this._w === w;
+    }
+    /**
+     * @internal
+     * Do not use
+     */
+    floorToRef(_result) {
+        throw new ReferenceError("Can not floor a quaternion");
+    }
+    /**
+     * @internal
+     * Do not use
+     */
+    floor() {
+        throw new ReferenceError("Can not floor a quaternion");
+    }
+    /**
+     * @internal
+     * Do not use
+     */
+    fractToRef(_result) {
+        throw new ReferenceError("Can not fract a quaternion");
+    }
+    /**
+     * @internal
+     * Do not use
+     */
+    fract() {
+        throw new ReferenceError("Can not fract a quaternion");
+    }
+    /**
+     * 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(ref) {
+        ref.copyFromFloats(-this._x, -this._y, -this._z, this._w);
+        return ref;
+    }
+    /**
+     * Conjugates in place the current quaternion
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#82
+     * @returns the current updated quaternion
+     */
+    conjugateInPlace() {
+        this._x *= -1;
+        this._y *= -1;
+        this._z *= -1;
+        this._isDirty = true;
+        return this;
+    }
+    /**
+     * Conjugates (1-q) the current quaternion
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#83
+     * @returns a new quaternion
      */
     conjugate() {
         return new this.constructor(-this._x, -this._y, -this._z, this._w);
@@ -4076,7 +4521,7 @@ export class Quaternion {
      */
     static SmoothToRef(source, goal, deltaTime, lerpTime, result) {
         let slerp = lerpTime === 0 ? 1 : deltaTime / lerpTime;
-        slerp = Scalar.Clamp(slerp, 0, 1);
+        slerp = Clamp(slerp, 0, 1);
         Quaternion.SlerpToRef(source, goal, slerp, result);
         return result;
     }
@@ -4179,6 +4624,19 @@ export class Quaternion {
         result._isDirty = true;
         return result;
     }
+    /**
+     * Sets the given quaternion "result" with the given floats.
+     * @param x defines the x coordinate of the source
+     * @param y defines the y coordinate of the source
+     * @param z defines the z coordinate of the source
+     * @param w defines the w coordinate of the source
+     * @param result defines the quaternion where to store the result
+     * @returns the result quaternion
+     */
+    static FromFloatsToRef(x, y, z, w, result) {
+        result.copyFromFloats(x, y, z, w);
+        return result;
+    }
     /**
      * Create a quaternion from Euler rotation angles
      * Example Playground https://playground.babylonjs.com/#L49EJ7#33
@@ -4536,7 +4994,113 @@ export class Quaternion {
         quat.normalizeToRef(result);
         return result;
     }
+    /**
+     * Returns a new Quaternion set with the coordinates of "value", if the quaternion "value" is in the cube defined by the quaternions "min" and "max"
+     * If a coordinate value of "value" is lower than one of the "min" coordinate, then this "value" coordinate is set with the "min" one
+     * If a coordinate value of "value" is greater than one of the "max" coordinate, then this "value" coordinate is set with the "max" one
+     * @param value defines the current value
+     * @param min defines the lower range value
+     * @param max defines the upper range value
+     * @returns the new Quaternion
+     */
+    static Clamp(value, min, max) {
+        const result = new value.constructor();
+        Quaternion.ClampToRef(value, min, max, result);
+        return result;
+    }
+    /**
+     * Sets the given quaternion "result" with the coordinates of "value", if the quaternion "value" is in the cube defined by the quaternions "min" and "max"
+     * If a coordinate value of "value" is lower than one of the "min" coordinate, then this "value" coordinate is set with the "min" one
+     * If a coordinate value of "value" is greater than one of the "max" coordinate, then this "value" coordinate is set with the "max" one
+     * @param value defines the current value
+     * @param min defines the lower range value
+     * @param max defines the upper range value
+     * @param result defines the Quaternion where to store the result
+     * @returns result input
+     */
+    static ClampToRef(value, min, max, result) {
+        return result.copyFromFloats(Clamp(value.x, min.x, max.x), Clamp(value.y, min.y, max.y), Clamp(value.z, min.z, max.z), Clamp(value.w, min.w, max.w));
+    }
+    /**
+     * Returns a new Quaternion with random values between min and max
+     * @param min the minimum random value
+     * @param max the maximum random value
+     * @returns a Quaternion with random values between min and max
+     */
+    static Random(min = 0, max = 1) {
+        return new Quaternion(RandomRange(min, max), RandomRange(min, max), RandomRange(min, max), RandomRange(min, max));
+    }
+    /**
+     * Sets a Quaternion with random values between min and max
+     * @param min the minimum random value
+     * @param max the maximum random value
+     * @param ref the ref to store the values in
+     * @returns the ref with random values between min and max
+     */
+    static RandomToRef(min = 0, max = 1, ref) {
+        return ref.copyFromFloats(RandomRange(min, max), RandomRange(min, max), RandomRange(min, max), RandomRange(min, max));
+    }
+    /**
+     * Do not use
+     * @internal
+     */
+    static Minimize() {
+        throw new ReferenceError("Quaternion.Minimize does not make sense");
+    }
+    /**
+     * Do not use
+     * @internal
+     */
+    static Maximize() {
+        throw new ReferenceError("Quaternion.Maximize does not make sense");
+    }
+    /**
+     * Returns the distance (float) between the quaternions "value1" and "value2".
+     * @param value1 value to calulate the distance between
+     * @param value2 value to calulate the distance between
+     * @returns the distance between the two quaternions
+     */
+    static Distance(value1, value2) {
+        return Math.sqrt(Quaternion.DistanceSquared(value1, value2));
+    }
+    /**
+     * Returns the squared distance (float) between the quaternions "value1" and "value2".
+     * @param value1 value to calulate the distance between
+     * @param value2 value to calulate the distance between
+     * @returns the distance between the two quaternions squared
+     */
+    static DistanceSquared(value1, value2) {
+        const x = value1.x - value2.x;
+        const y = value1.y - value2.y;
+        const z = value1.z - value2.z;
+        const w = value1.w - value2.w;
+        return x * x + y * y + z * z + w * w;
+    }
+    /**
+     * Returns a new Quaternion located at the center between the quaternions "value1" and "value2".
+     * @param value1 value to calulate the center between
+     * @param value2 value to calulate the center between
+     * @returns the center between the two quaternions
+     */
+    static Center(value1, value2) {
+        return Quaternion.CenterToRef(value1, value2, Quaternion.Zero());
+    }
+    /**
+     * Gets the center of the quaternions "value1" and "value2" and stores the result in the quaternion "ref"
+     * @param value1 defines first quaternion
+     * @param value2 defines second quaternion
+     * @param ref defines third quaternion
+     * @returns ref
+     */
+    static CenterToRef(value1, value2, ref) {
+        return ref.copyFromFloats((value1.x + value2.x) / 2, (value1.y + value2.y) / 2, (value1.z + value2.z) / 2, (value1.w + value2.w) / 2);
+    }
 }
+Quaternion;
+Object.defineProperties(Quaternion.prototype, {
+    dimension: { value: [4] },
+    rank: { value: 1 },
+});
 /**
  * Class used to store matrix data (4x4)
  * Note on matrix definitions in Babylon.js for setting values directly
@@ -4711,13 +5275,15 @@ export class Matrix {
     toString() {
         return `{${this.m[0]}, ${this.m[1]}, ${this.m[2]}, ${this.m[3]}\n${this.m[4]}, ${this.m[5]}, ${this.m[6]}, ${this.m[7]}\n${this.m[8]}, ${this.m[9]}, ${this.m[10]}, ${this.m[11]}\n${this.m[12]}, ${this.m[13]}, ${this.m[14]}, ${this.m[15]}}`;
     }
-    /**
-     * Returns the matrix as a Float32Array or Array<number>
-     * Example Playground - https://playground.babylonjs.com/#AV9X17#49
-     * @returns the matrix underlying array
-     */
-    toArray() {
-        return this._m;
+    toArray(array = null, index = 0) {
+        if (!array) {
+            return this._m;
+        }
+        const m = this._m;
+        for (let i = 0; i < 16; i++) {
+            array[index + i] = m[i];
+        }
+        return this;
     }
     /**
      * Returns the matrix as a Float32Array or Array<number>
@@ -4727,6 +5293,28 @@ export class Matrix {
     asArray() {
         return this._m;
     }
+    fromArray(array, index = 0) {
+        return Matrix.FromArrayToRef(array, index, this);
+    }
+    copyFromFloats(...floats) {
+        return Matrix.FromArrayToRef(floats, 0, this);
+    }
+    set(...values) {
+        const m = this._m;
+        for (let i = 0; i < 16; i++) {
+            m[i] = values[i];
+        }
+        this.markAsUpdated();
+        return this;
+    }
+    setAll(value) {
+        const m = this._m;
+        for (let i = 0; i < 16; i++) {
+            m[i] = value;
+        }
+        this.markAsUpdated();
+        return this;
+    }
     /**
      * Inverts the current matrix in place
      * Example Playground - https://playground.babylonjs.com/#AV9X17#118
@@ -4788,6 +5376,57 @@ export class Matrix {
         this.markAsUpdated();
         return this;
     }
+    addInPlace(other) {
+        const m = this._m, otherM = other.m;
+        for (let i = 0; i < 16; i++) {
+            m[i] += otherM[i];
+        }
+        this.markAsUpdated();
+        return this;
+    }
+    addInPlaceFromFloats(...floats) {
+        const m = this._m;
+        for (let i = 0; i < 16; i++) {
+            m[i] += floats[i];
+        }
+        this.markAsUpdated();
+        return this;
+    }
+    subtract(other) {
+        const m = this._m, otherM = other.m;
+        for (let i = 0; i < 16; i++) {
+            m[i] -= otherM[i];
+        }
+        this.markAsUpdated();
+        return this;
+    }
+    subtractToRef(other, result) {
+        const m = this._m, otherM = other.m, resultM = result._m;
+        for (let i = 0; i < 16; i++) {
+            resultM[i] = m[i] - otherM[i];
+        }
+        result.markAsUpdated();
+        return result;
+    }
+    subtractInPlace(other) {
+        const m = this._m, otherM = other.m;
+        for (let i = 0; i < 16; i++) {
+            m[i] -= otherM[i];
+        }
+        this.markAsUpdated();
+        return this;
+    }
+    subtractFromFloats(...floats) {
+        return this.subtractFromFloatsToRef(...floats, new this.constructor());
+    }
+    subtractFromFloatsToRef(...args) {
+        const result = args.pop(), m = this._m, resultM = result._m, values = args;
+        for (let i = 0; i < 16; i++) {
+            resultM[i] = m[i] - values[i];
+        }
+        result.markAsUpdated();
+        return result;
+    }
     /**
      * Sets the given matrix to the current inverted Matrix
      * Example Playground - https://playground.babylonjs.com/#AV9X17#119
@@ -4942,18 +5581,6 @@ export class Matrix {
         this._updateIdentityStatus(m[12] === 0 && m[13] === 0 && m[14] === 0 && m[15] === 1);
         return this;
     }
-    /**
-     * Multiply two matrices
-     * Example Playground - https://playground.babylonjs.com/#AV9X17#15
-     * 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
-     */
-    multiply(other) {
-        const result = new this.constructor();
-        this.multiplyToRef(other, result);
-        return result;
-    }
     /**
      * Copy the current matrix from the given one
      * Example Playground - https://playground.babylonjs.com/#AV9X17#21
@@ -4993,6 +5620,47 @@ export class Matrix {
         array[offset + 15] = source[15];
         return this;
     }
+    /**
+     * Multiply two matrices
+     * Example Playground - https://playground.babylonjs.com/#AV9X17#15
+     * 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
+     */
+    multiply(other) {
+        const result = new this.constructor();
+        this.multiplyToRef(other, result);
+        return result;
+    }
+    multiplyInPlace(other) {
+        const m = this._m, otherM = other.m;
+        for (let i = 0; i < 16; i++) {
+            m[i] *= otherM[i];
+        }
+        this.markAsUpdated();
+        return this;
+    }
+    multiplyByFloats(...floats) {
+        const m = this._m;
+        for (let i = 0; i < 16; i++) {
+            m[i] = floats[i];
+        }
+        this.markAsUpdated();
+        return this;
+    }
+    /**
+     * Multiples the current matrix by the given floats and stores them in the given ref
+     * @param args The floats and ref
+     * @returns The updated ref
+     */
+    multiplyByFloatsToRef(...args) {
+        const result = args.pop(), m = this._m, resultM = result._m, values = args;
+        for (let i = 0; i < 16; i++) {
+            resultM[i] = m[i] * values[i];
+        }
+        result.markAsUpdated();
+        return result;
+    }
     /**
      * 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
@@ -5050,6 +5718,76 @@ export class Matrix {
         result[offset + 15] = tm12 * om3 + tm13 * om7 + tm14 * om11 + tm15 * om15;
         return this;
     }
+    divide(other) {
+        return this.divideToRef(other, new this.constructor());
+    }
+    divideToRef(other, result) {
+        const m = this._m, otherM = other.m, resultM = result._m;
+        for (let i = 0; i < 16; i++) {
+            resultM[i] = m[i] / otherM[i];
+        }
+        result.markAsUpdated();
+        return result;
+    }
+    divideInPlace(other) {
+        const m = this._m, otherM = other.m;
+        for (let i = 0; i < 16; i++) {
+            m[i] /= otherM[i];
+        }
+        this.markAsUpdated();
+        return this;
+    }
+    minimizeInPlace(other) {
+        const m = this._m, otherM = other.m;
+        for (let i = 0; i < 16; i++) {
+            m[i] = Math.min(m[i], otherM[i]);
+        }
+        this.markAsUpdated();
+        return this;
+    }
+    minimizeInPlaceFromFloats(...floats) {
+        const m = this._m;
+        for (let i = 0; i < 16; i++) {
+            m[i] = Math.min(m[i], floats[i]);
+        }
+        this.markAsUpdated();
+        return this;
+    }
+    maximizeInPlace(other) {
+        const m = this._m, otherM = other.m;
+        for (let i = 0; i < 16; i++) {
+            m[i] = Math.min(m[i], otherM[i]);
+        }
+        this.markAsUpdated();
+        return this;
+    }
+    maximizeInPlaceFromFloats(...floats) {
+        const m = this._m;
+        for (let i = 0; i < 16; i++) {
+            m[i] = Math.min(m[i], floats[i]);
+        }
+        this.markAsUpdated();
+        return this;
+    }
+    negate() {
+        return this.negateToRef(new this.constructor());
+    }
+    negateInPlace() {
+        const m = this._m;
+        for (let i = 0; i < 16; i++) {
+            m[i] = -m[i];
+        }
+        this.markAsUpdated();
+        return this;
+    }
+    negateToRef(result) {
+        const m = this._m, resultM = result._m;
+        for (let i = 0; i < 16; i++) {
+            resultM[i] = -m[i];
+        }
+        result.markAsUpdated();
+        return result;
+    }
     /**
      * Check equality between this matrix and a second one
      * @param value defines the second matrix to compare
@@ -5084,6 +5822,46 @@ export class Matrix {
             m[14] === om[14] &&
             m[15] === om[15]);
     }
+    equalsWithEpsilon(other, epsilon = 0) {
+        const m = this._m, otherM = other.m;
+        for (let i = 0; i < 16; i++) {
+            if (!WithinEpsilon(m[i], otherM[i], epsilon)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    equalsToFloats(...floats) {
+        const m = this._m;
+        for (let i = 0; i < 16; i++) {
+            if (m[i] != floats[i]) {
+                return false;
+            }
+        }
+        return true;
+    }
+    floor() {
+        return this.floorToRef(new this.constructor());
+    }
+    floorToRef(result) {
+        const m = this._m, resultM = result._m;
+        for (let i = 0; i < 16; i++) {
+            resultM[i] = Math.floor(m[i]);
+        }
+        result.markAsUpdated();
+        return result;
+    }
+    fract() {
+        return this.fractToRef(new this.constructor());
+    }
+    fractToRef(result) {
+        const m = this._m, resultM = result._m;
+        for (let i = 0; i < 16; i++) {
+            resultM[i] = m[i] - Math.floor(m[i]);
+        }
+        result.markAsUpdated();
+        return result;
+    }
     /**
      * Clone the current matrix
      * Example Playground - https://playground.babylonjs.com/#AV9X17#18
@@ -5297,6 +6075,14 @@ export class Matrix {
         result.markAsUpdated();
         return result;
     }
+    scaleInPlace(scale) {
+        const m = this._m;
+        for (let i = 0; i < 16; i++) {
+            m[i] *= scale;
+        }
+        this.markAsUpdated();
+        return this;
+    }
     /**
      * Writes to the given matrix a normal matrix, computed from this one (using values from identity matrix for fourth row and column).
      * Example Playground - https://playground.babylonjs.com/#AV9X17#17
@@ -6611,25 +7397,37 @@ export class Matrix {
 }
 Matrix._UpdateFlagSeed = 0;
 Matrix._IdentityReadOnly = Matrix.Identity();
+Object.defineProperties(Matrix.prototype, {
+    dimension: { value: [4, 4] },
+    rank: { value: 2 },
+});
 /**
  * @internal
  * Same as Tmp but not exported to keep it only for math functions to avoid conflicts
  */
 class MathTmp {
 }
+// Temporary Vector3s
 MathTmp.Vector3 = ArrayTools.BuildTuple(11, Vector3.Zero);
+// Temporary Matricies
 MathTmp.Matrix = ArrayTools.BuildTuple(2, Matrix.Identity);
+// Temporary Quaternions
 MathTmp.Quaternion = ArrayTools.BuildTuple(3, Quaternion.Zero);
 /**
  * @internal
  */
 export class TmpVectors {
 }
-TmpVectors.Vector2 = ArrayTools.BuildTuple(3, Vector2.Zero); // 3 temp Vector2 at once should be enough
-TmpVectors.Vector3 = ArrayTools.BuildTuple(13, Vector3.Zero); // 13 temp Vector3 at once should be enough
-TmpVectors.Vector4 = ArrayTools.BuildTuple(3, Vector4.Zero); // 3 temp Vector4 at once should be enough
-TmpVectors.Quaternion = ArrayTools.BuildTuple(2, Quaternion.Zero); // 2 temp Quaternion at once should be enough
-TmpVectors.Matrix = ArrayTools.BuildTuple(8, Matrix.Identity); // 8 temp Matrices at once should be enough
+/** 3 temp Vector2 at once should be enough */
+TmpVectors.Vector2 = ArrayTools.BuildTuple(3, Vector2.Zero);
+/** 13 temp Vector3 at once should be enough */
+TmpVectors.Vector3 = ArrayTools.BuildTuple(13, Vector3.Zero);
+/** 3 temp Vector4 at once should be enough */
+TmpVectors.Vector4 = ArrayTools.BuildTuple(3, Vector4.Zero);
+/** 2 temp Quaternion at once should be enough */
+TmpVectors.Quaternion = ArrayTools.BuildTuple(2, Quaternion.Zero);
+/** 8 temp Matrices at once should be enough */
+TmpVectors.Matrix = ArrayTools.BuildTuple(8, Matrix.Identity);
 RegisterClass("BABYLON.Vector2", Vector2);
 RegisterClass("BABYLON.Vector3", Vector3);
 RegisterClass("BABYLON.Vector4", Vector4);