@babylonjs/core 9.8.0 → 9.9.1

package/Maths/math.vector.pure.js

@@ -22,11 +22,10 @@ export class Vector2 {
      * @param y defines the second coordinate
      */
     constructor(
-        /** [0] defines the first coordinate */
-        x = 0,
-        /** [0] defines the second coordinate */
-        y = 0
-    ) {
+    /** [0] defines the first coordinate */
+    x = 0, 
+    /** [0] defines the second coordinate */
+    y = 0) {
         this.x = x;
         this.y = y;
     }
@@ -666,14 +665,12 @@ export class Vector2 {
     static CatmullRom(value1, value2, value3, value4, amount) {
         const squared = amount * amount;
         const cubed = amount * squared;
-        const x =
-            0.5 *
+        const x = 0.5 *
             (2.0 * value2.x +
                 (-value1.x + value3.x) * amount +
                 (2.0 * value1.x - 5.0 * value2.x + 4.0 * value3.x - value4.x) * squared +
                 (-value1.x + 3.0 * value2.x - 3.0 * value3.x + value4.x) * cubed);
-        const y =
-            0.5 *
+        const y = 0.5 *
             (2.0 * value2.y +
                 (-value1.y + value3.y) * amount +
                 (2.0 * value1.y - 5.0 * value2.y + 4.0 * value3.y - value4.y) * squared +
@@ -1269,7 +1266,8 @@ export class Vector3 {
         //makes angle 90 degs to current vector
         if (theta > Math.PI / 2) {
             theta -= Math.PI / 2;
-        } else {
+        }
+        else {
             theta += Math.PI / 2;
         }
         //Calculates resutant normal vector from spherical coordinate of perpendicular vector
@@ -1288,13 +1286,8 @@ export class Vector3 {
      */
     applyRotationQuaternionToRef(q, result) {
         // Derived from https://raw.org/proof/vector-rotation-using-quaternions/
-        const vx = this._x,
-            vy = this._y,
-            vz = this._z;
-        const qx = q._x,
-            qy = q._y,
-            qz = q._z,
-            qw = q._w;
+        const vx = this._x, vy = this._y, vz = this._z;
+        const qx = q._x, qy = q._y, qz = q._z, qw = q._w;
         // t = 2q x v
         const tx = 2 * (qy * vz - qz * vy);
         const ty = 2 * (qz * vx - qx * vz);
@@ -1367,7 +1360,8 @@ export class Vector3 {
         //When the ray is close to parallel to the plane return infinity vector
         if (Math.abs(denom) < 0.0000000001) {
             result.setAll(Infinity);
-        } else {
+        }
+        else {
             const t = -(Vector3.Dot(origin, n) + d) / denom;
             // P = P0 + t*V
             const scaledV = V.scaleInPlace(t);
@@ -1921,7 +1915,8 @@ export class Vector3 {
             const invSin = 1 / Math.sin(omega);
             scale0 = Math.sin((1 - slerp) * omega) * invSin;
             scale1 = Math.sin(slerp * omega) * invSin;
-        } else {
+        }
+        else {
             // Use linear interpolation
             scale0 = 1 - slerp;
             scale1 = slerp;
@@ -2255,20 +2250,17 @@ export class Vector3 {
     static CatmullRom(value1, value2, value3, value4, amount) {
         const squared = amount * amount;
         const cubed = amount * squared;
-        const x =
-            0.5 *
+        const x = 0.5 *
             (2.0 * value2._x +
                 (-value1._x + value3._x) * amount +
                 (2.0 * value1._x - 5.0 * value2._x + 4.0 * value3._x - value4._x) * squared +
                 (-value1._x + 3.0 * value2._x - 3.0 * value3._x + value4._x) * cubed);
-        const y =
-            0.5 *
+        const y = 0.5 *
             (2.0 * value2._y +
                 (-value1._y + value3._y) * amount +
                 (2.0 * value1._y - 5.0 * value2._y + 4.0 * value3._y - value4._y) * squared +
                 (-value1._y + 3.0 * value2._y - 3.0 * value3._y + value4._y) * cubed);
-        const z =
-            0.5 *
+        const z = 0.5 *
             (2.0 * value2._z +
                 (-value1._z + value3._z) * amount +
                 (2.0 * value1._z - 5.0 * value2._z + 4.0 * value3._z - value4._z) * squared +
@@ -2609,7 +2601,8 @@ export class Vector3 {
         screenSource.y = -((sourceY / viewportHeight) * 2 - 1);
         if (EngineStore.LastCreatedEngine?.isNDCHalfZRange) {
             screenSource.z = sourceZ;
-        } else {
+        }
+        else {
             screenSource.z = 2 * sourceZ - 1.0;
         }
         Vector3.TransformCoordinatesToRef(screenSource, matrix, result);
@@ -2755,11 +2748,13 @@ export class Vector3 {
             edge.copyFrom(p1p0);
             e0 = p0;
             e1 = p1;
-        } else if (s1 > 0 && s2 < 0) {
+        }
+        else if (s1 > 0 && s2 < 0) {
             edge.copyFrom(p2p1);
             e0 = p1;
             e1 = p2;
-        } else {
+        }
+        else {
             edge.copyFrom(p2p0).scaleInPlace(-1);
             e0 = p2;
             e1 = p0;
@@ -3191,13 +3186,11 @@ export class Vector4 {
      * @returns true if they are equal
      */
     equalsWithEpsilon(otherVector, epsilon = Epsilon) {
-        return (
-            otherVector &&
+        return (otherVector &&
             WithinEpsilon(this._x, otherVector.x, epsilon) &&
             WithinEpsilon(this._y, otherVector.y, epsilon) &&
             WithinEpsilon(this._z, otherVector.z, epsilon) &&
-            WithinEpsilon(this._w, otherVector.w, epsilon)
-        );
+            WithinEpsilon(this._w, otherVector.w, epsilon));
     }
     /**
      * Boolean : True if the given floats are strictly equal to the current Vector4 coordinates.
@@ -3991,13 +3984,11 @@ export class Quaternion {
      * @returns true if the given quaternion coordinates are close to the current ones by a distance of epsilon.
      */
     equalsWithEpsilon(otherQuaternion, epsilon = Epsilon) {
-        return (
-            otherQuaternion &&
+        return (otherQuaternion &&
             WithinEpsilon(this._x, otherQuaternion._x, epsilon) &&
             WithinEpsilon(this._y, otherQuaternion._y, epsilon) &&
             WithinEpsilon(this._z, otherQuaternion._z, epsilon) &&
-            WithinEpsilon(this._w, otherQuaternion._w, epsilon)
-        );
+            WithinEpsilon(this._w, otherQuaternion._w, epsilon));
     }
     /**
      * Gets a boolean if two quaternions are equals (using an epsilon value), taking care of double cover : https://www.reedbeta.com/blog/why-quaternions-double-cover/
@@ -4006,8 +3997,7 @@ export class Quaternion {
      * @returns true if the given quaternion coordinates are close to the current ones by a distance of epsilon.
      */
     isApprox(otherQuaternion, epsilon = Epsilon) {
-        return (
-            otherQuaternion &&
+        return (otherQuaternion &&
             ((WithinEpsilon(this._x, otherQuaternion._x, epsilon) &&
                 WithinEpsilon(this._y, otherQuaternion._y, epsilon) &&
                 WithinEpsilon(this._z, otherQuaternion._z, epsilon) &&
@@ -4015,8 +4005,7 @@ export class Quaternion {
                 (WithinEpsilon(this._x, -otherQuaternion._x, epsilon) &&
                     WithinEpsilon(this._y, -otherQuaternion._y, epsilon) &&
                     WithinEpsilon(this._z, -otherQuaternion._z, epsilon) &&
-                    WithinEpsilon(this._w, -otherQuaternion._w, epsilon)))
-        );
+                    WithinEpsilon(this._w, -otherQuaternion._w, epsilon))));
     }
     /**
      * Clone the current quaternion
@@ -4540,12 +4529,14 @@ export class Quaternion {
             result._x = Math.PI / 2;
             result._z = 0;
             result._isDirty = true;
-        } else if (zAxisY > limit) {
+        }
+        else if (zAxisY > limit) {
             result._y = 2 * Math.atan2(qy, qw);
             result._x = -Math.PI / 2;
             result._z = 0;
             result._isDirty = true;
-        } else {
+        }
+        else {
             const sqw = qw * qw;
             const sqz = qz * qz;
             const sqx = qx * qx;
@@ -4632,7 +4623,8 @@ export class Quaternion {
         if (sinHalfAngle > 0) {
             angle = 2 * Math.atan2(sinHalfAngle, cosHalfAngle);
             axis.set(this._x / sinHalfAngle, this._y / sinHalfAngle, this._z / sinHalfAngle);
-        } else {
+        }
+        else {
             angle = 0;
             axis.set(1, 0, 0);
         }
@@ -4659,15 +4651,9 @@ export class Quaternion {
      */
     static FromRotationMatrixToRef(matrix, result) {
         const data = matrix.m;
-        const m11 = data[0],
-            m12 = data[4],
-            m13 = data[8];
-        const m21 = data[1],
-            m22 = data[5],
-            m23 = data[9];
-        const m31 = data[2],
-            m32 = data[6],
-            m33 = data[10];
+        const m11 = data[0], m12 = data[4], m13 = data[8];
+        const m21 = data[1], m22 = data[5], m23 = data[9];
+        const m31 = data[2], m32 = data[6], m33 = data[10];
         const trace = m11 + m22 + m33;
         let s;
         if (trace > 0) {
@@ -4677,21 +4663,24 @@ export class Quaternion {
             result._y = (m13 - m31) * s;
             result._z = (m21 - m12) * s;
             result._isDirty = true;
-        } else if (m11 > m22 && m11 > m33) {
+        }
+        else if (m11 > m22 && m11 > m33) {
             s = 2.0 * Math.sqrt(1.0 + m11 - m22 - m33);
             result._w = (m32 - m23) / s;
             result._x = 0.25 * s;
             result._y = (m12 + m21) / s;
             result._z = (m13 + m31) / s;
             result._isDirty = true;
-        } else if (m22 > m33) {
+        }
+        else if (m22 > m33) {
             s = 2.0 * Math.sqrt(1.0 + m22 - m11 - m33);
             result._w = (m13 - m31) / s;
             result._x = (m12 + m21) / s;
             result._y = 0.25 * s;
             result._z = (m23 + m32) / s;
             result._isDirty = true;
-        } else {
+        }
+        else {
             s = 2.0 * Math.sqrt(1.0 + m33 - m11 - m22);
             result._w = (m21 - m12) / s;
             result._x = (m13 + m31) / s;
@@ -4912,10 +4901,12 @@ export class Quaternion {
         if (r < epsilon) {
             if (Math.abs(vecFrom.x) > Math.abs(vecFrom.z)) {
                 result.set(-vecFrom.y, vecFrom.x, 0, 0);
-            } else {
+            }
+            else {
                 result.set(0, -vecFrom.z, vecFrom.y, 0);
             }
-        } else {
+        }
+        else {
             Vector3.CrossToRef(vecFrom, vecTo, TmpVectors.Vector3[0]);
             result.set(TmpVectors.Vector3[0].x, TmpVectors.Vector3[0].y, TmpVectors.Vector3[0].z, r);
         }
@@ -5115,7 +5106,8 @@ export class Quaternion {
         if (num4 > 0.999999) {
             num3 = 1 - amount;
             num2 = flag ? -amount : amount;
-        } else {
+        }
+        else {
             const num5 = Math.acos(num4);
             const num6 = 1.0 / Math.sin(num5);
             num3 = Math.sin((1.0 - amount) * num5) * num6;
@@ -5400,21 +5392,21 @@ export class Matrix {
             const m = this._m;
             this._isIdentity =
                 m[0] === 1.0 &&
-                m[1] === 0.0 &&
-                m[2] === 0.0 &&
-                m[3] === 0.0 &&
-                m[4] === 0.0 &&
-                m[5] === 1.0 &&
-                m[6] === 0.0 &&
-                m[7] === 0.0 &&
-                m[8] === 0.0 &&
-                m[9] === 0.0 &&
-                m[10] === 1.0 &&
-                m[11] === 0.0 &&
-                m[12] === 0.0 &&
-                m[13] === 0.0 &&
-                m[14] === 0.0 &&
-                m[15] === 1.0;
+                    m[1] === 0.0 &&
+                    m[2] === 0.0 &&
+                    m[3] === 0.0 &&
+                    m[4] === 0.0 &&
+                    m[5] === 1.0 &&
+                    m[6] === 0.0 &&
+                    m[7] === 0.0 &&
+                    m[8] === 0.0 &&
+                    m[9] === 0.0 &&
+                    m[10] === 1.0 &&
+                    m[11] === 0.0 &&
+                    m[12] === 0.0 &&
+                    m[13] === 0.0 &&
+                    m[14] === 0.0 &&
+                    m[15] === 1.0;
         }
         return this._isIdentity;
     }
@@ -5427,8 +5419,8 @@ export class Matrix {
             this._isIdentity3x2Dirty = false;
             if (this._m[0] !== 1.0 || this._m[5] !== 1.0 || this._m[15] !== 1.0) {
                 this._isIdentity3x2 = false;
-            } else if (
-                this._m[1] !== 0.0 ||
+            }
+            else if (this._m[1] !== 0.0 ||
                 this._m[2] !== 0.0 ||
                 this._m[3] !== 0.0 ||
                 this._m[4] !== 0.0 ||
@@ -5440,10 +5432,10 @@ export class Matrix {
                 this._m[11] !== 0.0 ||
                 this._m[12] !== 0.0 ||
                 this._m[13] !== 0.0 ||
-                this._m[14] !== 0.0
-            ) {
+                this._m[14] !== 0.0) {
                 this._isIdentity3x2 = false;
-            } else {
+            }
+            else {
                 this._isIdentity3x2 = true;
             }
         }
@@ -5459,22 +5451,10 @@ export class Matrix {
             return 1;
         }
         const m = this._m;
-        const m00 = m[0],
-            m01 = m[1],
-            m02 = m[2],
-            m03 = m[3];
-        const m10 = m[4],
-            m11 = m[5],
-            m12 = m[6],
-            m13 = m[7];
-        const m20 = m[8],
-            m21 = m[9],
-            m22 = m[10],
-            m23 = m[11];
-        const m30 = m[12],
-            m31 = m[13],
-            m32 = m[14],
-            m33 = m[15];
+        const m00 = m[0], m01 = m[1], m02 = m[2], m03 = m[3];
+        const m10 = m[4], m11 = m[5], m12 = m[6], m13 = m[7];
+        const m20 = m[8], m21 = m[9], m22 = m[10], m23 = m[11];
+        const m30 = m[12], m31 = m[13], m32 = m[14], m33 = m[15];
         // https://en.wikipedia.org/wiki/Laplace_expansion
         // to compute the deterrminant of a 4x4 Matrix we compute the cofactors of any row or column,
         // then we multiply each Cofactor by its corresponding matrix value and sum them all to get the determinant
@@ -5634,8 +5614,7 @@ export class Matrix {
         return this;
     }
     addInPlace(other) {
-        const m = this._m,
-            otherM = other.m;
+        const m = this._m, otherM = other.m;
         for (let i = 0; i < 16; i++) {
             m[i] += otherM[i];
         }
@@ -5651,8 +5630,7 @@ export class Matrix {
         return this;
     }
     subtract(other) {
-        const m = this._m,
-            otherM = other.m;
+        const m = this._m, otherM = other.m;
         for (let i = 0; i < 16; i++) {
             m[i] -= otherM[i];
         }
@@ -5660,9 +5638,7 @@ export class Matrix {
         return this;
     }
     subtractToRef(other, result) {
-        const m = this._m,
-            otherM = other.m,
-            resultM = result._m;
+        const m = this._m, otherM = other.m, resultM = result._m;
         for (let i = 0; i < 16; i++) {
             resultM[i] = m[i] - otherM[i];
         }
@@ -5670,8 +5646,7 @@ export class Matrix {
         return result;
     }
     subtractInPlace(other) {
-        const m = this._m,
-            otherM = other.m;
+        const m = this._m, otherM = other.m;
         for (let i = 0; i < 16; i++) {
             m[i] -= otherM[i];
         }
@@ -5682,10 +5657,7 @@ export class Matrix {
         return this.subtractFromFloatsToRef(...floats, new Matrix());
     }
     subtractFromFloatsToRef(...args) {
-        const result = args.pop(),
-            m = this._m,
-            resultM = result._m,
-            values = 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];
         }
@@ -5705,7 +5677,8 @@ export class Matrix {
         }
         if (InvertMatrixToArray(this, other.asArray())) {
             other.markAsUpdated();
-        } else {
+        }
+        else {
             other.copyFrom(this);
         }
         return other;
@@ -5845,8 +5818,7 @@ export class Matrix {
      * @returns the current updated matrix
      */
     multiplyInPlace(other) {
-        const m = this._m,
-            otherM = other.m;
+        const m = this._m, otherM = other.m;
         for (let i = 0; i < 16; i++) {
             m[i] *= otherM[i];
         }
@@ -5873,10 +5845,7 @@ export class Matrix {
      * @returns The updated ref
      */
     multiplyByFloatsToRef(...args) {
-        const result = args.pop(),
-            m = this._m,
-            resultM = result._m,
-            values = 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];
         }
@@ -5919,9 +5888,7 @@ export class Matrix {
         return this.divideToRef(other, new Matrix());
     }
     divideToRef(other, result) {
-        const m = this._m,
-            otherM = other.m,
-            resultM = result._m;
+        const m = this._m, otherM = other.m, resultM = result._m;
         for (let i = 0; i < 16; i++) {
             resultM[i] = m[i] / otherM[i];
         }
@@ -5929,8 +5896,7 @@ export class Matrix {
         return result;
     }
     divideInPlace(other) {
-        const m = this._m,
-            otherM = other.m;
+        const m = this._m, otherM = other.m;
         for (let i = 0; i < 16; i++) {
             m[i] /= otherM[i];
         }
@@ -5938,8 +5904,7 @@ export class Matrix {
         return this;
     }
     minimizeInPlace(other) {
-        const m = this._m,
-            otherM = other.m;
+        const m = this._m, otherM = other.m;
         for (let i = 0; i < 16; i++) {
             m[i] = Math.min(m[i], otherM[i]);
         }
@@ -5955,8 +5920,7 @@ export class Matrix {
         return this;
     }
     maximizeInPlace(other) {
-        const m = this._m,
-            otherM = other.m;
+        const m = this._m, otherM = other.m;
         for (let i = 0; i < 16; i++) {
             m[i] = Math.min(m[i], otherM[i]);
         }
@@ -5983,8 +5947,7 @@ export class Matrix {
         return this;
     }
     negateToRef(result) {
-        const m = this._m,
-            resultM = result._m;
+        const m = this._m, resultM = result._m;
         for (let i = 0; i < 16; i++) {
             resultM[i] = -m[i];
         }
@@ -6008,8 +5971,7 @@ export class Matrix {
         }
         const m = this.m;
         const om = other.m;
-        return (
-            m[0] === om[0] &&
+        return (m[0] === om[0] &&
             m[1] === om[1] &&
             m[2] === om[2] &&
             m[3] === om[3] &&
@@ -6024,12 +5986,10 @@ export class Matrix {
             m[12] === om[12] &&
             m[13] === om[13] &&
             m[14] === om[14] &&
-            m[15] === om[15]
-        );
+            m[15] === om[15]);
     }
     equalsWithEpsilon(other, epsilon = 0) {
-        const m = this._m,
-            otherM = other.m;
+        const m = this._m, otherM = other.m;
         for (let i = 0; i < 16; i++) {
             if (!WithinEpsilon(m[i], otherM[i], epsilon)) {
                 return false;
@@ -6050,8 +6010,7 @@ export class Matrix {
         return this.floorToRef(new Matrix());
     }
     floorToRef(result) {
-        const m = this._m,
-            resultM = result._m;
+        const m = this._m, resultM = result._m;
         for (let i = 0; i < 16; i++) {
             resultM[i] = Math.floor(m[i]);
         }
@@ -6062,8 +6021,7 @@ export class Matrix {
         return this.fractToRef(new Matrix());
     }
     fractToRef(result) {
-        const m = this._m,
-            resultM = result._m;
+        const m = this._m, resultM = result._m;
         for (let i = 0; i < 16; i++) {
             resultM[i] = m[i] - Math.floor(m[i]);
         }
@@ -6146,7 +6104,8 @@ export class Matrix {
             scale.x *= signX;
             scale.y *= signY;
             scale.z *= signZ;
-        } else {
+        }
+        else {
             if (this.determinant() <= 0) {
                 scale.y *= -1;
             }
@@ -6158,28 +6117,8 @@ export class Matrix {
             return false;
         }
         if (rotation) {
-            const sx = 1 / scale._x,
-                sy = 1 / scale._y,
-                sz = 1 / scale._z;
-            Matrix.FromValuesToRef(
-                m[0] * sx,
-                m[1] * sx,
-                m[2] * sx,
-                0.0,
-                m[4] * sy,
-                m[5] * sy,
-                m[6] * sy,
-                0.0,
-                m[8] * sz,
-                m[9] * sz,
-                m[10] * sz,
-                0.0,
-                0.0,
-                0.0,
-                0.0,
-                1.0,
-                MathTmp.Matrix[0]
-            );
+            const sx = 1 / scale._x, sy = 1 / scale._y, sz = 1 / scale._z;
+            Matrix.FromValuesToRef(m[0] * sx, m[1] * sx, m[2] * sx, 0.0, m[4] * sy, m[5] * sy, m[6] * sy, 0.0, m[8] * sz, m[9] * sz, m[10] * sz, 0.0, 0.0, 0.0, 0.0, 1.0, MathTmp.Matrix[0]);
             Quaternion.FromRotationMatrixToRef(MathTmp.Matrix[0], rotation);
         }
         return true;
@@ -6345,9 +6284,7 @@ export class Matrix {
             return result;
         }
         const m = this._m;
-        const sx = 1 / scale._x,
-            sy = 1 / scale._y,
-            sz = 1 / scale._z;
+        const sx = 1 / scale._x, sy = 1 / scale._y, sz = 1 / scale._z;
         Matrix.FromValuesToRef(m[0] * sx, m[1] * sx, m[2] * sx, 0.0, m[4] * sy, m[5] * sy, m[6] * sy, 0.0, m[8] * sz, m[9] * sz, m[10] * sz, 0.0, 0.0, 0.0, 0.0, 1.0, result);
         return result;
     }
@@ -6461,25 +6398,7 @@ export class Matrix {
      * @param initialM44 defines 4th value of 4th row
      * @param result defines the target matrix
      */
-    static FromValuesToRef(
-        initialM11,
-        initialM12,
-        initialM13,
-        initialM14,
-        initialM21,
-        initialM22,
-        initialM23,
-        initialM24,
-        initialM31,
-        initialM32,
-        initialM33,
-        initialM34,
-        initialM41,
-        initialM42,
-        initialM43,
-        initialM44,
-        result
-    ) {
+    static FromValuesToRef(initialM11, initialM12, initialM13, initialM14, initialM21, initialM22, initialM23, initialM24, initialM31, initialM32, initialM33, initialM34, initialM41, initialM42, initialM43, initialM44, result) {
         const m = result._m;
         m[0] = initialM11;
         m[1] = initialM12;
@@ -6519,24 +6438,7 @@ export class Matrix {
      * @param initialM44 defines 4th value of 4th row
      * @returns the new matrix
      */
-    static FromValues(
-        initialM11,
-        initialM12,
-        initialM13,
-        initialM14,
-        initialM21,
-        initialM22,
-        initialM23,
-        initialM24,
-        initialM31,
-        initialM32,
-        initialM33,
-        initialM34,
-        initialM41,
-        initialM42,
-        initialM43,
-        initialM44
-    ) {
+    static FromValues(initialM11, initialM12, initialM13, initialM14, initialM21, initialM22, initialM23, initialM24, initialM31, initialM32, initialM33, initialM34, initialM41, initialM42, initialM43, initialM44) {
         const result = new Matrix();
         const m = result._m;
         m[0] = initialM11;
@@ -6582,25 +6484,12 @@ export class Matrix {
      */
     static ComposeToRef(scale, rotation, translation, result) {
         const m = result._m;
-        const x = rotation._x,
-            y = rotation._y,
-            z = rotation._z,
-            w = rotation._w;
-        const x2 = x + x,
-            y2 = y + y,
-            z2 = z + z;
-        const xx = x * x2,
-            xy = x * y2,
-            xz = x * z2;
-        const yy = y * y2,
-            yz = y * z2,
-            zz = z * z2;
-        const wx = w * x2,
-            wy = w * y2,
-            wz = w * z2;
-        const sx = scale._x,
-            sy = scale._y,
-            sz = scale._z;
+        const x = rotation._x, y = rotation._y, z = rotation._z, w = rotation._w;
+        const x2 = x + x, y2 = y + y, z2 = z + z;
+        const xx = x * x2, xy = x * y2, xz = x * z2;
+        const yy = y * y2, yz = y * z2, zz = z * z2;
+        const wx = w * x2, wy = w * y2, wz = w * z2;
+        const sx = scale._x, sy = scale._y, sz = scale._z;
         m[0] = (1 - (yy + zz)) * sx;
         m[1] = (xy + wz) * sx;
         m[2] = (xz - wy) * sx;
@@ -6807,7 +6696,8 @@ export class Matrix {
             m[9] = 0;
             m[10] = useYAxisForCoplanar ? -1 : 1;
             m[11] = 0;
-        } else {
+        }
+        else {
             const v = Vector3.Cross(to, from);
             const k = 1 / (1 + c);
             m[0] = v._x * v._x * k + c;
@@ -7030,7 +6920,8 @@ export class Matrix {
         const xSquareLength = xAxis.lengthSquared();
         if (xSquareLength === 0) {
             xAxis.x = 1.0;
-        } else {
+        }
+        else {
             xAxis.normalizeFromLength(Math.sqrt(xSquareLength));
         }
         // Y axis
@@ -7081,7 +6972,8 @@ export class Matrix {
         const xSquareLength = xAxis.lengthSquared();
         if (xSquareLength === 0) {
             xAxis.x = 1.0;
-        } else {
+        }
+        else {
             xAxis.normalizeFromLength(Math.sqrt(xSquareLength));
         }
         // Y axis
@@ -7631,25 +7523,7 @@ export class Matrix {
         const temp = -2 * x;
         const temp2 = -2 * y;
         const temp3 = -2 * z;
-        Matrix.FromValuesToRef(
-            temp * x + 1,
-            temp2 * x,
-            temp3 * x,
-            0.0,
-            temp * y,
-            temp2 * y + 1,
-            temp3 * y,
-            0.0,
-            temp * z,
-            temp2 * z,
-            temp3 * z + 1,
-            0.0,
-            temp * plane.d,
-            temp2 * plane.d,
-            temp3 * plane.d,
-            1.0,
-            result
-        );
+        Matrix.FromValuesToRef(temp * x + 1, temp2 * x, temp3 * x, 0.0, temp * y, temp2 * y + 1, temp3 * y, 0.0, temp * z, temp2 * z, temp3 * z + 1, 0.0, temp * plane.d, temp2 * plane.d, temp3 * plane.d, 1.0, result);
         return result;
     }
     /**
@@ -7705,7 +7579,8 @@ Matrix._IdentityReadOnly = /*#__PURE__*/ Matrix.Identity();
  * @internal
  * Same as Tmp but not exported to keep it only for math functions to avoid conflicts
  */
-class MathTmp {}
+class MathTmp {
+}
 // Temporary Vector3s
 MathTmp.Vector3 = /*#__PURE__*/ BuildTuple(11, Vector3.Zero);
 // Temporary Matricies
@@ -7715,7 +7590,8 @@ MathTmp.Quaternion = /*#__PURE__*/ BuildTuple(3, Quaternion.Zero);
 /**
  * @internal
  */
-export class TmpVectors {}
+export class TmpVectors {
+}
 /** 3 temp Vector2 at once should be enough */
 TmpVectors.Vector2 = /*#__PURE__*/ BuildTuple(3, Vector2.Zero);
 /** 13 temp Vector3 at once should be enough */
@@ -7762,4 +7638,4 @@ export function RegisterMathVector() {
     RegisterClass("BABYLON.Vector4", Vector4);
     RegisterClass("BABYLON.Matrix", Matrix);
 }
-//# sourceMappingURL=math.vector.pure.js.map
+//# sourceMappingURL=math.vector.pure.js.map