@babylonjs/core 7.19.1 → 7.20.1

package/Maths/math.like.js.map

@@ -1 +1 @@
-{"version":3,"file":"math.like.js","sourceRoot":"","sources":["../../../../dev/core/src/Maths/math.like.ts"],"names":[],"mappings":"","sourcesContent":["import type { float, int, DeepImmutable, Tuple } from \"../types\";\r\n\r\n/**\r\n * @internal\r\n */\r\nexport interface IColor3Like {\r\n    r: float;\r\n    g: float;\r\n    b: float;\r\n}\r\n\r\n/**\r\n * @internal\r\n */\r\nexport interface IColor4Like extends IColor3Like {\r\n    a: float;\r\n}\r\n\r\n/**\r\n * @internal\r\n */\r\nexport interface IVector2Like {\r\n    x: float;\r\n    y: float;\r\n}\r\n\r\n/**\r\n * @internal\r\n */\r\nexport interface IVector3Like extends IVector2Like {\r\n    z: float;\r\n}\r\n\r\n/**\r\n * @internal\r\n */\r\nexport interface IVector4Like extends IVector3Like {\r\n    w: float;\r\n}\r\n\r\n/**\r\n * @internal\r\n */\r\nexport interface IQuaternionLike extends IVector3Like {\r\n    w: float;\r\n}\r\n\r\n/**\r\n * @internal\r\n */\r\nexport interface IPlaneLike {\r\n    normal: IVector3Like;\r\n    d: float;\r\n    normalize(): void;\r\n}\r\n\r\n/**\r\n * @internal\r\n */\r\nexport interface IMatrixLike {\r\n    asArray(): DeepImmutable<Tuple<number, 16>>;\r\n    updateFlag: int;\r\n}\r\n\r\n/**\r\n * @internal\r\n */\r\nexport interface IViewportLike {\r\n    x: float;\r\n    y: float;\r\n    width: float;\r\n    height: float;\r\n}\r\n"]}
+{"version":3,"file":"math.like.js","sourceRoot":"","sources":["../../../../dev/core/src/Maths/math.like.ts"],"names":[],"mappings":"","sourcesContent":["import type { float, int, DeepImmutable, Tuple } from \"../types\";\r\n\r\n/**\r\n * @internal\r\n */\r\nexport interface IColor3Like {\r\n    r: float;\r\n    g: float;\r\n    b: float;\r\n}\r\n\r\n/**\r\n * @internal\r\n */\r\nexport interface IColor4Like extends IColor3Like {\r\n    a: float;\r\n}\r\n\r\n/**\r\n * @internal\r\n */\r\nexport interface IVector2Like {\r\n    x: float;\r\n    y: float;\r\n}\r\n\r\n/**\r\n * @internal\r\n */\r\nexport interface IVector3Like extends IVector2Like {\r\n    z: float;\r\n}\r\n\r\n/**\r\n * @internal\r\n */\r\nexport interface Vector3LikeInternal {\r\n    _x: number;\r\n    _y: number;\r\n    _z: number;\r\n    _isDirty?: boolean;\r\n}\r\n\r\n/**\r\n * @internal\r\n */\r\nexport interface IVector4Like extends IVector3Like {\r\n    w: float;\r\n}\r\n\r\n/**\r\n * @internal\r\n */\r\nexport interface IQuaternionLike extends IVector3Like {\r\n    w: float;\r\n}\r\n\r\n/**\r\n * @internal\r\n */\r\nexport interface IPlaneLike {\r\n    normal: IVector3Like;\r\n    d: float;\r\n    normalize(): void;\r\n}\r\n\r\n/**\r\n * @internal\r\n */\r\nexport interface IMatrixLike {\r\n    asArray(): DeepImmutable<Tuple<number, 16>>;\r\n    updateFlag: int;\r\n}\r\n\r\n/**\r\n * @internal\r\n */\r\nexport interface IViewportLike {\r\n    x: float;\r\n    y: float;\r\n    width: float;\r\n    height: float;\r\n}\r\n"]}

package/Maths/math.vector.d.ts

@@ -3,7 +3,7 @@ import type { DeepImmutable, Nullable, FloatArray, float, Tuple } from "../types
 import type { Plane } from "./math.plane";
 import type { TransformNode } from "../Meshes/transformNode";
 import type { Dimension, Tensor, TensorLike, TensorStatic } from "./tensor";
-import type { IVector2Like, IVector3Like, IVector4Like, IQuaternionLike, IMatrixLike, IPlaneLike } from "./math.like";
+import type { IVector2Like, IVector3Like, IVector4Like, IQuaternionLike, IMatrixLike, IPlaneLike, Vector3LikeInternal } from "./math.like";
 /**
  * Represents a vector of any dimension
  */
@@ -726,7 +726,7 @@ export declare class Vector2 implements Vector<Tuple<number, 2>, IVector2Like>,
  * Reminder: js uses a left handed forward facing system
  * Example Playground - Overview - https://playground.babylonjs.com/#R1F8YU
  */
-export declare class Vector3 implements Vector<Tuple<number, 3>, Vector3>, IVector3Like {
+export declare class Vector3 implements Vector<Tuple<number, 3>, Vector3LikeInternal>, IVector3Like {
     private static _UpReadOnly;
     private static _DownReadOnly;
     private static _LeftHandedForwardReadOnly;
@@ -835,7 +835,7 @@ export declare class Vector3 implements Vector<Tuple<number, 3>, Vector3>, IVect
      * @param otherVector defines the second operand
      * @returns the resulting Vector3
      */
-    add(otherVector: DeepImmutable<Vector3>): Vector3;
+    add(otherVector: DeepImmutable<Vector3LikeInternal>): Vector3;
     /**
      * Adds the current Vector3 to the given one and stores the result in the vector "result"
      * Example Playground https://playground.babylonjs.com/#R1F8YU#6
@@ -843,21 +843,21 @@ export declare class Vector3 implements Vector<Tuple<number, 3>, Vector3>, IVect
      * @param result defines the Vector3 object where to store the result
      * @returns the result
      */
-    addToRef<T extends Vector3>(otherVector: DeepImmutable<Vector3>, result: T): T;
+    addToRef<T extends Vector3LikeInternal>(otherVector: DeepImmutable<Vector3LikeInternal>, result: T): T;
     /**
      * Subtract the given vector from the current Vector3
      * Example Playground https://playground.babylonjs.com/#R1F8YU#61
      * @param otherVector defines the second operand
      * @returns the current updated Vector3
      */
-    subtractInPlace(otherVector: DeepImmutable<Vector3>): this;
+    subtractInPlace(otherVector: DeepImmutable<Vector3LikeInternal>): this;
     /**
      * Returns a new Vector3, result of the subtraction of the given vector from the current Vector3
      * Example Playground https://playground.babylonjs.com/#R1F8YU#60
      * @param otherVector defines the second operand
      * @returns the resulting Vector3
      */
-    subtract(otherVector: DeepImmutable<Vector3>): Vector3;
+    subtract(otherVector: DeepImmutable<Vector3LikeInternal>): Vector3;
     /**
      * Subtracts the given vector from the current Vector3 and stores the result in the vector "result".
      * Example Playground https://playground.babylonjs.com/#R1F8YU#63
@@ -865,7 +865,7 @@ export declare class Vector3 implements Vector<Tuple<number, 3>, Vector3>, IVect
      * @param result defines the Vector3 object where to store the result
      * @returns the result
      */
-    subtractToRef<T extends Vector3>(otherVector: DeepImmutable<Vector3>, result: T): T;
+    subtractToRef<T extends Vector3LikeInternal>(otherVector: DeepImmutable<Vector3LikeInternal>, result: T): T;
     /**
      * Returns a new Vector3 set with the subtraction of the given floats from the current Vector3 coordinates
      * Example Playground https://playground.babylonjs.com/#R1F8YU#62
@@ -884,7 +884,7 @@ export declare class Vector3 implements Vector<Tuple<number, 3>, Vector3>, IVect
      * @param result defines the Vector3 object where to store the result
      * @returns the result
      */
-    subtractFromFloatsToRef<T extends Vector3>(x: number, y: number, z: number, result: T): T;
+    subtractFromFloatsToRef<T extends Vector3LikeInternal>(x: number, y: number, z: number, result: T): T;
     /**
      * Gets a new Vector3 set with the current Vector3 negated coordinates
      * Example Playground https://playground.babylonjs.com/#R1F8YU#35
@@ -903,7 +903,7 @@ export declare class Vector3 implements Vector<Tuple<number, 3>, Vector3>, IVect
      * @param result defines the Vector3 object where to store the result
      * @returns the result
      */
-    negateToRef<T extends Vector3 = Vector3>(result: T): T;
+    negateToRef<T extends Vector3LikeInternal>(result: T): T;
     /**
      * Multiplies the Vector3 coordinates by the float "scale"
      * Example Playground https://playground.babylonjs.com/#R1F8YU#56
@@ -925,7 +925,7 @@ export declare class Vector3 implements Vector<Tuple<number, 3>, Vector3>, IVect
      * @param result defines the Vector3 object where to store the result
      * @returns the result
      */
-    scaleToRef<T extends Vector3>(scale: number, result: T): T;
+    scaleToRef<T extends Vector3LikeInternal>(scale: number, result: T): T;
     /**
      * Creates a vector normal (perpendicular) to the current Vector3 and stores the result in the given vector
      * Out of the infinite possibilities the normal chosen is the one formed by rotating the current vector
@@ -967,7 +967,7 @@ export declare class Vector3 implements Vector<Tuple<number, 3>, Vector3>, IVect
      * @param result defines the Vector3 object where to store the result
      * @returns result input
      */
-    scaleAndAddToRef<T extends Vector3>(scale: number, result: T): T;
+    scaleAndAddToRef<T extends Vector3LikeInternal>(scale: number, result: T): T;
     /**
      * Projects the current point Vector3 to a plane along a ray starting from a specified origin and passing through the current point Vector3.
      * Example Playground https://playground.babylonjs.com/#R1F8YU#48
@@ -1015,14 +1015,14 @@ export declare class Vector3 implements Vector<Tuple<number, 3>, Vector3>, IVect
      * @param otherVector defines the second operand
      * @returns the current updated Vector3
      */
-    multiplyInPlace(otherVector: DeepImmutable<Vector3>): this;
+    multiplyInPlace(otherVector: DeepImmutable<Vector3LikeInternal>): this;
     /**
      * Returns a new Vector3, result of the multiplication of the current Vector3 by the given vector
      * Example Playground https://playground.babylonjs.com/#R1F8YU#31
      * @param otherVector defines the second operand
      * @returns the new Vector3
      */
-    multiply(otherVector: DeepImmutable<Vector3>): Vector3;
+    multiply(otherVector: DeepImmutable<Vector3LikeInternal>): Vector3;
     /**
      * Multiplies the current Vector3 by the given one and stores the result in the given vector "result"
      * Example Playground https://playground.babylonjs.com/#R1F8YU#33
@@ -1030,7 +1030,7 @@ export declare class Vector3 implements Vector<Tuple<number, 3>, Vector3>, IVect
      * @param result defines the Vector3 object where to store the result
      * @returns the result
      */
-    multiplyToRef<T extends Vector3>(otherVector: DeepImmutable<Vector3>, result: T): T;
+    multiplyToRef<T extends Vector3LikeInternal>(otherVector: DeepImmutable<Vector3LikeInternal>, result: T): T;
     /**
      * Returns a new Vector3 set with the result of the multiplication of the current Vector3 coordinates by the given floats
      * Example Playground https://playground.babylonjs.com/#R1F8YU#34
@@ -1046,7 +1046,7 @@ export declare class Vector3 implements Vector<Tuple<number, 3>, Vector3>, IVect
      * @param otherVector defines the second operand
      * @returns the new Vector3
      */
-    divide(otherVector: DeepImmutable<Vector3>): Vector3;
+    divide(otherVector: DeepImmutable<Vector3LikeInternal>): Vector3;
     /**
      * Divides the current Vector3 coordinates by the given ones and stores the result in the given vector "result"
      * Example Playground https://playground.babylonjs.com/#R1F8YU#18
@@ -1054,28 +1054,28 @@ export declare class Vector3 implements Vector<Tuple<number, 3>, Vector3>, IVect
      * @param result defines the Vector3 object where to store the result
      * @returns the result
      */
-    divideToRef<T extends Vector3>(otherVector: DeepImmutable<Vector3>, result: T): T;
+    divideToRef<T extends Vector3LikeInternal>(otherVector: DeepImmutable<Vector3LikeInternal>, result: T): T;
     /**
      * Divides the current Vector3 coordinates by the given ones.
      * Example Playground https://playground.babylonjs.com/#R1F8YU#17
      * @param otherVector defines the second operand
      * @returns the current updated Vector3
      */
-    divideInPlace(otherVector: DeepImmutable<Vector3>): this;
+    divideInPlace(otherVector: DeepImmutable<Vector3LikeInternal>): this;
     /**
      * Updates the current Vector3 with the minimal coordinate values between its and the given vector ones
      * Example Playground https://playground.babylonjs.com/#R1F8YU#29
      * @param other defines the second operand
      * @returns the current updated Vector3
      */
-    minimizeInPlace(other: DeepImmutable<Vector3>): this;
+    minimizeInPlace(other: DeepImmutable<Vector3LikeInternal>): this;
     /**
      * Updates the current Vector3 with the maximal coordinate values between its and the given vector ones.
      * Example Playground https://playground.babylonjs.com/#R1F8YU#27
      * @param other defines the second operand
      * @returns the current updated Vector3
      */
-    maximizeInPlace(other: DeepImmutable<Vector3>): this;
+    maximizeInPlace(other: DeepImmutable<Vector3LikeInternal>): this;
     /**
      * Updates the current Vector3 with the minimal coordinate values between its and the given coordinates
      * Example Playground https://playground.babylonjs.com/#R1F8YU#30
@@ -1110,7 +1110,7 @@ export declare class Vector3 implements Vector<Tuple<number, 3>, Vector3>, IVect
      * @param result the vector to store the result in
      * @returns the result vector
      */
-    floorToRef<T extends Vector3>(result: T): T;
+    floorToRef<T extends Vector3LikeInternal>(result: T): T;
     /**
      * Gets a new Vector3 from current Vector3 floored values
      * Example Playground https://playground.babylonjs.com/#R1F8YU#22
@@ -1122,7 +1122,7 @@ export declare class Vector3 implements Vector<Tuple<number, 3>, Vector3>, IVect
      * @param result the vector to store the result in
      * @returns the result vector
      */
-    fractToRef<T extends Vector3>(result: T): T;
+    fractToRef<T extends Vector3LikeInternal>(result: T): T;
     /**
      * Gets a new Vector3 from current Vector3 fractional values
      * Example Playground https://playground.babylonjs.com/#R1F8YU#23
@@ -1202,10 +1202,10 @@ export declare class Vector3 implements Vector<Tuple<number, 3>, Vector3>, IVect
     /**
      * Normalize the current Vector3 to the reference
      * Example Playground https://playground.babylonjs.com/#R1F8YU#125
-     * @param reference define the Vector3 to update
+     * @param result define the Vector3 to update
      * @returns the updated Vector3
      */
-    normalizeToRef<T extends Vector3>(reference: T): T;
+    normalizeToRef<T extends Vector3LikeInternal>(result: T): T;
     /**
      * Creates a new Vector3 copied from the current Vector3
      * Example Playground https://playground.babylonjs.com/#R1F8YU#11

package/Maths/math.vector.js

@@ -1,6 +1,6 @@
 /* eslint-disable @typescript-eslint/naming-convention */
 import { Epsilon } from "./math.constants.js";
-import { ArrayTools } from "../Misc/arrayTools.js";
+import { BuildTuple } from "../Misc/arrayTools.js";
 import { RegisterClass } from "../Misc/typeStore.js";
 import { PerformanceConfigurator } from "../Engines/performanceConfigurator.js";
 import { EngineStore } from "../Engines/engineStore.js";
@@ -1098,7 +1098,11 @@ export class Vector3 {
      * @returns the result
      */
     addToRef(otherVector, result) {
-        return result.copyFromFloats(this._x + otherVector._x, this._y + otherVector._y, this._z + otherVector._z);
+        result._x = this._x + otherVector._x;
+        result._y = this._y + otherVector._y;
+        result._z = this._z + otherVector._z;
+        result._isDirty = true;
+        return result;
     }
     /**
      * Subtract the given vector from the current Vector3
@@ -1153,7 +1157,11 @@ export class Vector3 {
      * @returns the result
      */
     subtractFromFloatsToRef(x, y, z, result) {
-        return result.copyFromFloats(this._x - x, this._y - y, this._z - z);
+        result._x = this._x - x;
+        result._y = this._y - y;
+        result._z = this._z - z;
+        result._isDirty = true;
+        return result;
     }
     /**
      * Gets a new Vector3 set with the current Vector3 negated coordinates
@@ -1182,7 +1190,11 @@ export class Vector3 {
      * @returns the result
      */
     negateToRef(result) {
-        return result.copyFromFloats(this._x * -1, this._y * -1, this._z * -1);
+        result._x = this._x * -1;
+        result._y = this._y * -1;
+        result._z = this._z * -1;
+        result._isDirty = true;
+        return result;
     }
     /**
      * Multiplies the Vector3 coordinates by the float "scale"
@@ -1214,7 +1226,11 @@ export class Vector3 {
      * @returns the result
      */
     scaleToRef(scale, result) {
-        return result.copyFromFloats(this._x * scale, this._y * scale, this._z * scale);
+        result._x = this._x * scale;
+        result._y = this._y * scale;
+        result._z = this._z * scale;
+        result._isDirty = true;
+        return result;
     }
     /**
      * Creates a vector normal (perpendicular) to the current Vector3 and stores the result in the given vector
@@ -1297,7 +1313,11 @@ export class Vector3 {
      * @returns result input
      */
     scaleAndAddToRef(scale, result) {
-        return result.addInPlaceFromFloats(this._x * scale, this._y * scale, this._z * scale);
+        result._x += this._x * scale;
+        result._y += this._y * scale;
+        result._z += this._z * scale;
+        result._isDirty = true;
+        return result;
     }
     /**
      * Projects the current point Vector3 to a plane along a ray starting from a specified origin and passing through the current point Vector3.
@@ -1397,7 +1417,11 @@ export class Vector3 {
      * @returns the result
      */
     multiplyToRef(otherVector, result) {
-        return result.copyFromFloats(this._x * otherVector._x, this._y * otherVector._y, this._z * otherVector._z);
+        result._x = this._x * otherVector._x;
+        result._y = this._y * otherVector._y;
+        result._z = this._z * otherVector._z;
+        result._isDirty = true;
+        return result;
     }
     /**
      * Returns a new Vector3 set with the result of the multiplication of the current Vector3 coordinates by the given floats
@@ -1427,7 +1451,11 @@ export class Vector3 {
      * @returns the result
      */
     divideToRef(otherVector, result) {
-        return result.copyFromFloats(this._x / otherVector._x, this._y / otherVector._y, this._z / otherVector._z);
+        result._x = this._x / otherVector._x;
+        result._y = this._y / otherVector._y;
+        result._z = this._z / otherVector._z;
+        result._isDirty = true;
+        return result;
     }
     /**
      * Divides the current Vector3 coordinates by the given ones.
@@ -1686,15 +1714,19 @@ export class Vector3 {
     /**
      * Normalize the current Vector3 to the reference
      * Example Playground https://playground.babylonjs.com/#R1F8YU#125
-     * @param reference define the Vector3 to update
+     * @param result define the Vector3 to update
      * @returns the updated Vector3
      */
-    normalizeToRef(reference) {
+    normalizeToRef(result) {
         const len = this.length();
         if (len === 0 || len === 1.0) {
-            return reference.copyFrom(this);
+            result._x = this._x;
+            result._y = this._y;
+            result._z = this._z;
+            result._isDirty = true;
+            return result;
         }
-        return this.scaleToRef(1.0 / len, reference);
+        return this.scaleToRef(1.0 / len, result);
     }
     /**
      * Creates a new Vector3 copied from the current Vector3
@@ -4629,12 +4661,11 @@ export class Quaternion {
      * @returns the target quaternion
      */
     static RotationAxisToRef(axis, angle, result) {
-        const sin = Math.sin(angle / 2);
-        axis.normalize();
         result._w = Math.cos(angle / 2);
-        result._x = axis._x * sin;
-        result._y = axis._y * sin;
-        result._z = axis._z * sin;
+        const sinByLength = Math.sin(angle / 2) / axis.length();
+        result._x = axis._x * sinByLength;
+        result._y = axis._y * sinByLength;
+        result._z = axis._z * sinByLength;
         result._isDirty = true;
         return result;
     }
@@ -7489,26 +7520,26 @@ Object.defineProperties(Matrix.prototype, {
 class MathTmp {
 }
 // Temporary Vector3s
-MathTmp.Vector3 = ArrayTools.BuildTuple(11, Vector3.Zero);
+MathTmp.Vector3 = BuildTuple(11, Vector3.Zero);
 // Temporary Matricies
-MathTmp.Matrix = ArrayTools.BuildTuple(2, Matrix.Identity);
+MathTmp.Matrix = BuildTuple(2, Matrix.Identity);
 // Temporary Quaternions
-MathTmp.Quaternion = ArrayTools.BuildTuple(3, Quaternion.Zero);
+MathTmp.Quaternion = BuildTuple(3, Quaternion.Zero);
 /**
  * @internal
  */
 export class TmpVectors {
 }
 /** 3 temp Vector2 at once should be enough */
-TmpVectors.Vector2 = ArrayTools.BuildTuple(3, Vector2.Zero);
+TmpVectors.Vector2 = BuildTuple(3, Vector2.Zero);
 /** 13 temp Vector3 at once should be enough */
-TmpVectors.Vector3 = ArrayTools.BuildTuple(13, Vector3.Zero);
+TmpVectors.Vector3 = BuildTuple(13, Vector3.Zero);
 /** 3 temp Vector4 at once should be enough */
-TmpVectors.Vector4 = ArrayTools.BuildTuple(3, Vector4.Zero);
+TmpVectors.Vector4 = BuildTuple(3, Vector4.Zero);
 /** 3 temp Quaternion at once should be enough */
-TmpVectors.Quaternion = ArrayTools.BuildTuple(3, Quaternion.Zero);
+TmpVectors.Quaternion = BuildTuple(3, Quaternion.Zero);
 /** 8 temp Matrices at once should be enough */
-TmpVectors.Matrix = ArrayTools.BuildTuple(8, Matrix.Identity);
+TmpVectors.Matrix = BuildTuple(8, Matrix.Identity);
 RegisterClass("BABYLON.Vector2", Vector2);
 RegisterClass("BABYLON.Vector3", Vector3);
 RegisterClass("BABYLON.Vector4", Vector4);