@babylonjs/core 6.29.1 → 6.29.2

package/Maths/math.vector.js

@@ -412,8 +412,40 @@ export class Vector2 {
      * @returns the current updated Vector2
      */
     normalize() {
-        Vector2.NormalizeToRef(this, this);
-        return this;
+        return this.normalizeFromLength(this.length());
+    }
+    /**
+     * Normalize the current Vector2 with the given input length.
+     * Please note that this is an in place operation.
+     * @param len the length of the vector
+     * @returns the current updated Vector2
+     */
+    normalizeFromLength(len) {
+        if (len === 0 || len === 1.0) {
+            return this;
+        }
+        return this.scaleInPlace(1.0 / len);
+    }
+    /**
+     * Normalize the current Vector2 to a new vector
+     * @returns the new Vector2
+     */
+    normalizeToNew() {
+        const normalized = new this.constructor(0, 0);
+        this.normalizeToRef(normalized);
+        return normalized;
+    }
+    /**
+     * Normalize the current Vector2 to the reference
+     * @param reference define the Vector2 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);
+        }
+        return this.scaleToRef(1.0 / len, reference);
     }
     /**
      * Gets a new Vector2 copied from the Vector2
@@ -423,6 +455,14 @@ export class Vector2 {
     clone() {
         return new this.constructor(this.x, this.y);
     }
+    /**
+     * Gets the dot product of the current vector and the vector "otherVector"
+     * @param otherVector defines second vector
+     * @returns the dot product (float)
+     */
+    dot(otherVector) {
+        return this.x * otherVector.x + this.y * otherVector.y;
+    }
     // Statics
     /**
      * Gets a new Vector2(0, 0)
@@ -603,9 +643,9 @@ export class Vector2 {
      * @returns a new Vector2
      */
     static Normalize(vector) {
-        const newVector = new vector.constructor();
-        this.NormalizeToRef(vector, newVector);
-        return newVector;
+        const result = new vector.constructor();
+        Vector2.NormalizeToRef(vector, result);
+        return result;
     }
     /**
      * Normalize a given vector into a second one
@@ -615,12 +655,7 @@ export class Vector2 {
      * @returns result input
      */
     static NormalizeToRef(vector, result) {
-        const len = vector.length();
-        if (len === 0) {
-            return result;
-        }
-        result.x = vector.x / len;
-        result.y = vector.y / len;
+        vector.normalizeToRef(result);
         return result;
     }
     /**
@@ -2149,6 +2184,14 @@ export class Vector3 {
     static Dot(left, right) {
         return left._x * right._x + left._y * right._y + left._z * right._z;
     }
+    /**
+     * Returns the dot product (float) between the current vectors and "otherVector"
+     * @param otherVector defines the right operand
+     * @returns the dot product
+     */
+    dot(otherVector) {
+        return this._x * otherVector._x + this._y * otherVector._y + this._z * otherVector._z;
+    }
     /**
      * Returns a new Vector3 as the cross product of the vectors "left" and "right"
      * The cross product is then orthogonal to both "left" and "right"
@@ -3038,12 +3081,41 @@ export class Vector4 {
      * @returns the updated Vector4.
      */
     normalize() {
-        const len = this.length();
-        if (len === 0) {
+        return this.normalizeFromLength(this.length());
+    }
+    /**
+     * Normalize the current Vector4 with the given input length.
+     * Please note that this is an in place operation.
+     * @param len the length of the vector
+     * @returns the current updated Vector4
+     */
+    normalizeFromLength(len) {
+        if (len === 0 || len === 1.0) {
             return this;
         }
         return this.scaleInPlace(1.0 / len);
     }
+    /**
+     * Normalize the current Vector4 to a new vector
+     * @returns the new Vector4
+     */
+    normalizeToNew() {
+        const normalized = new this.constructor(0, 0, 0, 0);
+        this.normalizeToRef(normalized);
+        return normalized;
+    }
+    /**
+     * Normalize the current Vector4 to the reference
+     * @param reference define the Vector4 to update
+     * @returns the updated 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 this.scaleToRef(1.0 / len, reference);
+    }
     /**
      * Returns a new Vector3 from the Vector4 (x, y, z) coordinates.
      * @returns this converted to a new vector3
@@ -3105,6 +3177,14 @@ export class Vector4 {
         this.x = this.y = this.z = this.w = v;
         return this;
     }
+    /**
+     * Returns the dot product (float) between the current vectors and "otherVector"
+     * @param otherVector defines the right operand
+     * @returns the dot product
+     */
+    dot(otherVector) {
+        return this.x * otherVector.x + this.y * otherVector.y + this.z * otherVector.z + this.w * otherVector.w;
+    }
     // Statics
     /**
      * Returns a new Vector4 set from the starting index of the given array.
@@ -3205,8 +3285,7 @@ export class Vector4 {
      * @returns result input
      */
     static NormalizeToRef(vector, result) {
-        result.copyFrom(vector);
-        result.normalize();
+        vector.normalizeToRef(result);
         return result;
     }
     /**
@@ -3382,6 +3461,15 @@ export class Vector4 {
     static FromVector3(source, w = 0) {
         return new Vector4(source._x, source._y, source._z, w);
     }
+    /**
+     * Returns the dot product (float) between the vectors "left" and "right"
+     * @param left defines the left operand
+     * @param right defines the right operand
+     * @returns the dot product
+     */
+    static Dot(left, right) {
+        return left.dot(right);
+    }
 }
 Vector4._ZeroReadOnly = Vector4.Zero();
 /**
@@ -3778,13 +3866,19 @@ export class Quaternion {
      * @returns the current updated quaternion
      */
     normalize() {
-        const len = this.length();
-        if (len === 0) {
+        return this.normalizeFromLength(this.length());
+    }
+    /**
+     * Normalize the current quaternion with the given input length.
+     * Please note that this is an in place operation.
+     * @param len the length of the quaternion
+     * @returns the current updated Quaternion
+     */
+    normalizeFromLength(len) {
+        if (len === 0 || len === 1.0) {
             return this;
         }
-        const inv = 1.0 / len;
-        this.scaleInPlace(inv);
-        return this;
+        return this.scaleInPlace(1.0 / len);
     }
     /**
      * Normalize a copy of the current quaternion
@@ -3792,12 +3886,21 @@ export class Quaternion {
      * @returns the normalized quaternion
      */
     normalizeToNew() {
+        const normalized = new this.constructor(0, 0, 0, 1);
+        this.normalizeToRef(normalized);
+        return normalized;
+    }
+    /**
+     * Normalize the current Quaternion to the reference
+     * @param reference define the Quaternion to update
+     * @returns the updated Quaternion
+     */
+    normalizeToRef(reference) {
         const len = this.length();
-        if (len === 0) {
-            return this.clone();
+        if (len === 0 || len === 1.0) {
+            return reference.copyFromFloats(this._x, this._y, this._z, this._w);
         }
-        const inv = 1.0 / len;
-        return this.scale(inv);
+        return this.scaleToRef(1.0 / len, reference);
     }
     /**
      * Returns a new Vector3 set with the Euler angles translated from the current quaternion
@@ -3868,6 +3971,14 @@ export class Quaternion {
         Quaternion.FromRotationMatrixToRef(matrix, this);
         return this;
     }
+    /**
+     * Returns the dot product (float) between the current quaternions and "other"
+     * @param other defines the right operand
+     * @returns the dot product
+     */
+    dot(other) {
+        return this._x * other._x + this._y * other._y + this._z * other._z + this._w * other._w;
+    }
     // Statics
     /**
      * Creates a new quaternion from a rotation matrix
@@ -4401,6 +4512,26 @@ export class Quaternion {
         result._isDirty = true;
         return result;
     }
+    /**
+     * Returns a new Quaternion as the normalization of the given Quaternion
+     * @param quat defines the Quaternion to normalize
+     * @returns the new Quaternion
+     */
+    static Normalize(quat) {
+        const result = Quaternion.Zero();
+        Quaternion.NormalizeToRef(quat, result);
+        return result;
+    }
+    /**
+     * Sets the given Quaternion "result" with the normalization of the given first Quaternion
+     * @param quat defines the Quaternion to normalize
+     * @param result defines the Quaternion where to store the result
+     * @returns result input
+     */
+    static NormalizeToRef(quat, result) {
+        quat.normalizeToRef(result);
+        return result;
+    }
 }
 /**
  * Class used to store matrix data (4x4)