@babylonjs/core 6.45.0 → 6.46.0

package/Maths/math.vector.d.ts

@@ -1,23 +1,98 @@
 import type { Viewport } from "./math.viewport";
-import type { DeepImmutable, Nullable, FloatArray, float } from "../types";
-import type { IPlaneLike } from "./math.like";
+import type { DeepImmutable, Nullable, FloatArray, float, Tuple } from "../types";
 import type { Plane } from "./math.plane";
 import type { TransformNode } from "../Meshes/transformNode";
-export type Vector2Constructor<T extends Vector2> = new (...args: ConstructorParameters<typeof Vector2>) => T;
-export type Vector3Constructor<T extends Vector3> = new (...args: ConstructorParameters<typeof Vector3>) => T;
-export type Vector4Constructor<T extends Vector4> = new (...args: ConstructorParameters<typeof Vector4>) => T;
-export type QuaternionConstructor<T extends Quaternion> = new (...args: ConstructorParameters<typeof Quaternion>) => T;
-export type MatrixConstructor<T extends Matrix> = new () => T;
+import type { Dimension, Tensor, TensorStatic } from "./tensor";
+import type { IVector2Like, IVector3Like, IVector4Like, IQuaternionLike, IMatrixLike, IPlaneLike } from "./math.like";
+/**
+ * Represents a vector of any dimension
+ */
+export interface Vector<N extends number[] = number[]> extends Tensor<N> {
+    /**
+     * @see Tensor.dimension
+     */
+    readonly dimension: Readonly<Dimension<N>>;
+    /**
+     * @see Tensor.rank
+     */
+    readonly rank: 1;
+    /**
+     * Gets the length of the vector
+     * @returns the vector length (float)
+     */
+    length(): number;
+    /**
+     * Gets the vector squared length
+     * @returns the vector squared length (float)
+     */
+    lengthSquared(): number;
+    /**
+     * Normalize the vector
+     * @returns the current updated Vector
+     */
+    normalize(): this;
+    /**
+     * Normalize the current Vector 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 Vector
+     */
+    normalizeFromLength(len: number): this;
+    /**
+     * Normalize the current Vector to a new vector
+     * @returns the new Vector
+     */
+    normalizeToNew(): this;
+    /**
+     * Normalize the current Vector to the reference
+     * @param reference define the Vector to update
+     * @returns the updated Vector
+     */
+    normalizeToRef(reference: this): this;
+}
+/**
+ * Static side of Vector
+ */
+export interface VectorStatic<T extends Vector> extends TensorStatic<T> {
+    /**
+     * Checks if a given vector is inside a specific range
+     * @param v defines the vector to test
+     * @param min defines the minimum range
+     * @param max defines the maximum range
+     */
+    CheckExtends(v: T, min: T, max: T): void;
+    /**
+     * Returns a new Vector equal to the normalized given vector
+     * @param vector defines the vector to normalize
+     * @returns a new Vector
+     */
+    Normalize(vector: DeepImmutable<T>): T;
+    /**
+     * Normalize a given vector into a second one
+     * @param vector defines the vector to normalize
+     * @param result defines the vector where to store the result
+     * @returns result input
+     */
+    NormalizeToRef(vector: DeepImmutable<T>, result: T): T;
+}
 /**
  * Class representing a vector containing 2 coordinates
  * Example Playground - Overview -  https://playground.babylonjs.com/#QYBWV4#9
  */
-export declare class Vector2 {
+export declare class Vector2 implements Vector<Tuple<number, 2>>, IVector2Like {
     /** defines the first coordinate */
     x: number;
     /** defines the second coordinate */
     y: number;
     private static _ZeroReadOnly;
+    /**
+     * @see Tensor.dimension
+     */
+    readonly dimension: Readonly<[2]>;
+    /**
+     * @see Tensor.rank
+     */
+    readonly rank: 1;
     /**
      * Creates a new Vector2 from the given x and y coordinates
      * @param x defines the first coordinate
@@ -55,23 +130,23 @@ export declare 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: FloatArray, index?: number): this;
+    fromArray(array: FloatArray, offset?: number): this;
     /**
      * Copy the current vector to an array
      * Example Playground https://playground.babylonjs.com/#QYBWV4#40
      * @returns a new array with 2 elements: the Vector2 coordinates.
      */
-    asArray(): number[];
+    asArray(): [number, number];
     /**
      * Sets the Vector2 coordinates with the given Vector2 coordinates
      * Example Playground https://playground.babylonjs.com/#QYBWV4#24
      * @param source defines the source Vector2
      * @returns the current updated Vector2
      */
-    copyFrom(source: DeepImmutable<Vector2>): this;
+    copyFrom(source: DeepImmutable<this>): this;
     /**
      * Sets the Vector2 coordinates with the given floats
      * Example Playground https://playground.babylonjs.com/#QYBWV4#25
@@ -88,13 +163,19 @@ export declare class Vector2 {
      * @returns the current updated Vector2
      */
     set(x: number, y: number): this;
+    /**
+     * 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: number): this;
     /**
      * Add another vector with the current one
      * Example Playground https://playground.babylonjs.com/#QYBWV4#11
      * @param otherVector defines the other vector
      * @returns a new Vector2 set with the addition of the current Vector2 and the given one coordinates
      */
-    add(otherVector: DeepImmutable<Vector2>): this;
+    add(otherVector: DeepImmutable<this>): this;
     /**
      * Sets the "result" coordinates with the addition of the current Vector2 and the given one coordinates
      * Example Playground https://playground.babylonjs.com/#QYBWV4#12
@@ -102,14 +183,21 @@ export declare class Vector2 {
      * @param result defines the target vector
      * @returns result input
      */
-    addToRef<T extends Vector2>(otherVector: DeepImmutable<Vector2>, result: T): T;
+    addToRef<T extends this>(otherVector: DeepImmutable<this>, result: T): T;
     /**
      * Set the Vector2 coordinates by adding the given Vector2 coordinates
      * Example Playground https://playground.babylonjs.com/#QYBWV4#13
      * @param otherVector defines the other vector
      * @returns the current updated Vector2
      */
-    addInPlace(otherVector: DeepImmutable<Vector2>): this;
+    addInPlace(otherVector: DeepImmutable<this>): 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: number, y: number): 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
@@ -123,7 +211,7 @@ export declare class Vector2 {
      * @param otherVector defines the other vector
      * @returns a new Vector2
      */
-    subtract(otherVector: Vector2): this;
+    subtract(otherVector: DeepImmutable<this>): this;
     /**
      * Sets the "result" coordinates with the subtraction of the given one from the current Vector2 coordinates.
      * Example Playground https://playground.babylonjs.com/#QYBWV4#63
@@ -131,28 +219,28 @@ export declare class Vector2 {
      * @param result defines the target vector
      * @returns result input
      */
-    subtractToRef<T extends Vector2>(otherVector: DeepImmutable<Vector2>, result: T): T;
+    subtractToRef<T extends this>(otherVector: DeepImmutable<this>, result: T): T;
     /**
      * Sets the current Vector2 coordinates by subtracting from it the given one coordinates
      * Example Playground https://playground.babylonjs.com/#QYBWV4#88
      * @param otherVector defines the other vector
      * @returns the current updated Vector2
      */
-    subtractInPlace(otherVector: DeepImmutable<Vector2>): this;
+    subtractInPlace(otherVector: DeepImmutable<this>): this;
     /**
      * Multiplies in place the current Vector2 coordinates by the given ones
      * Example Playground https://playground.babylonjs.com/#QYBWV4#43
      * @param otherVector defines the other vector
      * @returns the current updated Vector2
      */
-    multiplyInPlace(otherVector: DeepImmutable<Vector2>): this;
+    multiplyInPlace(otherVector: DeepImmutable<this>): this;
     /**
      * Returns a new Vector2 set with the multiplication of the current Vector2 and the given one coordinates
      * Example Playground https://playground.babylonjs.com/#QYBWV4#42
      * @param otherVector defines the other vector
      * @returns a new Vector2
      */
-    multiply(otherVector: DeepImmutable<Vector2>): this;
+    multiply(otherVector: DeepImmutable<this>): this;
     /**
      * Sets "result" coordinates with the multiplication of the current Vector2 and the given one coordinates
      * Example Playground https://playground.babylonjs.com/#QYBWV4#44
@@ -160,7 +248,7 @@ export declare class Vector2 {
      * @param result defines the target vector
      * @returns result input
      */
-    multiplyToRef<T extends Vector2>(otherVector: DeepImmutable<Vector2>, result: T): T;
+    multiplyToRef<T extends this>(otherVector: DeepImmutable<this>, result: T): T;
     /**
      * Gets a new Vector2 set with the Vector2 coordinates multiplied by the given floats
      * Example Playground https://playground.babylonjs.com/#QYBWV4#89
@@ -175,7 +263,7 @@ export declare class Vector2 {
      * @param otherVector defines the other vector
      * @returns a new Vector2
      */
-    divide(otherVector: Vector2): this;
+    divide(otherVector: DeepImmutable<this>): this;
     /**
      * Sets the "result" coordinates with the Vector2 divided by the given one coordinates
      * Example Playground https://playground.babylonjs.com/#QYBWV4#30
@@ -183,17 +271,57 @@ export declare class Vector2 {
      * @param result defines the target vector
      * @returns result input
      */
-    divideToRef<T extends Vector2>(otherVector: DeepImmutable<Vector2>, result: T): T;
+    divideToRef<T extends this>(otherVector: DeepImmutable<this>, result: T): T;
     /**
      * Divides the current Vector2 coordinates by the given ones
      * Example Playground https://playground.babylonjs.com/#QYBWV4#28
      * @param otherVector defines the other vector
      * @returns the current updated Vector2
      */
-    divideInPlace(otherVector: DeepImmutable<Vector2>): this;
+    divideInPlace(otherVector: DeepImmutable<this>): 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: DeepImmutable<this>): this;
+    /**
+     * 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: DeepImmutable<this>): this;
+    /**
+     * 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: number, y: number): 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: number, y: number): 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: number, y: number): this;
+    /**
+     * 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<T extends this>(x: number, y: number, result: T): T;
     /**
      * Gets a new Vector2 with current Vector2 negated coordinates
-     * Example Playground https://playground.babylonjs.com/#QYBWV4#22
      * @returns a new Vector2
      */
     negate(): this;
@@ -209,7 +337,7 @@ export declare class Vector2 {
      * @param result defines the Vector3 object where to store the result
      * @returns the result
      */
-    negateToRef<T extends Vector2>(result: T): T;
+    negateToRef<T extends this>(result: T): T;
     /**
      * Multiply the Vector2 coordinates by
      * Example Playground https://playground.babylonjs.com/#QYBWV4#59
@@ -231,7 +359,7 @@ export declare class Vector2 {
      * @param result defines the Vector2 object where to store the result
      * @returns result input
      */
-    scaleToRef<T extends Vector2>(scale: number, result: T): T;
+    scaleToRef<T extends this>(scale: number, result: T): T;
     /**
      * Scale the current Vector2 values by a factor and add the result to a given Vector2
      * Example Playground https://playground.babylonjs.com/#QYBWV4#58
@@ -239,14 +367,14 @@ export declare class Vector2 {
      * @param result defines the Vector2 object where to store the result
      * @returns result input
      */
-    scaleAndAddToRef<T extends Vector2>(scale: number, result: T): T;
+    scaleAndAddToRef<T extends this>(scale: number, result: T): T;
     /**
      * Gets a boolean if two vectors are equals
      * Example Playground https://playground.babylonjs.com/#QYBWV4#31
      * @param otherVector defines the other vector
      * @returns true if the given vector coordinates strictly equal the current Vector2 ones
      */
-    equals(otherVector: DeepImmutable<Vector2>): boolean;
+    equals(otherVector: DeepImmutable<this>): boolean;
     /**
      * Gets a boolean if two vectors are equals (using an epsilon value)
      * Example Playground https://playground.babylonjs.com/#QYBWV4#32
@@ -254,7 +382,14 @@ export declare class Vector2 {
      * @param epsilon defines the minimal distance to consider equality
      * @returns true if the given vector coordinates are close to the current ones by a distance of epsilon.
      */
-    equalsWithEpsilon(otherVector: DeepImmutable<Vector2>, epsilon?: number): boolean;
+    equalsWithEpsilon(otherVector: DeepImmutable<this>, epsilon?: number): boolean;
+    /**
+     * 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: number, y: number): boolean;
     /**
      * Gets a new Vector2 from current Vector2 floored values
      * Example Playground https://playground.babylonjs.com/#QYBWV4#35
@@ -262,6 +397,12 @@ export declare class Vector2 {
      * @returns a new Vector2
      */
     floor(): this;
+    /**
+     * 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<T extends this>(result: T): T;
     /**
      * Gets a new Vector2 from current Vector2 fractional values
      * Example Playground https://playground.babylonjs.com/#QYBWV4#34
@@ -269,6 +410,12 @@ export declare class Vector2 {
      * @returns a new Vector2
      */
     fract(): this;
+    /**
+     * 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<T extends this>(result: T): T;
     /**
      * Rotate the current vector into a given result vector
      * Example Playground https://playground.babylonjs.com/#QYBWV4#49
@@ -276,7 +423,7 @@ export declare class Vector2 {
      * @param result defines the result vector where to store the rotated vector
      * @returns result input
      */
-    rotateToRef<T extends Vector2>(angle: number, result: T): T;
+    rotateToRef<T extends this>(angle: number, result: T): T;
     /**
      * Gets the length of the vector
      * @returns the vector length (float)
@@ -307,10 +454,10 @@ export declare class Vector2 {
     normalizeToNew(): this;
     /**
      * 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<T extends Vector2>(reference: T): T;
+    normalizeToRef<T extends this>(reference: T): T;
     /**
      * Gets a new Vector2 copied from the Vector2
      * Example Playground https://playground.babylonjs.com/#QYBWV4#20
@@ -340,6 +487,14 @@ export declare class Vector2 {
      * @returns a Vector2 with random values between min and max
      */
     static Random(min?: number, max?: number): Vector2;
+    /**
+     * 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<T extends Vector2>(min: number | undefined, max: number | undefined, ref: T): T;
     /**
      * Gets a zero Vector2 that must not be updated
      */
@@ -361,6 +516,14 @@ export declare class Vector2 {
      * @returns result input
      */
     static FromArrayToRef<T extends Vector2>(array: DeepImmutable<ArrayLike<number>>, offset: number, result: T): T;
+    /**
+     * 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<T extends Vector2>(x: number, y: number, result: T): T;
     /**
      * 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
@@ -372,6 +535,17 @@ export declare class Vector2 {
      * @returns a new Vector2
      */
     static CatmullRom<T extends Vector2>(value1: DeepImmutable<T>, value2: DeepImmutable<Vector2>, value3: DeepImmutable<Vector2>, value4: DeepImmutable<Vector2>, amount: number): T;
+    /**
+     * 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<T extends Vector2>(value: DeepImmutable<T>, min: DeepImmutable<Vector2>, max: DeepImmutable<Vector2>, ref: T): T;
     /**
      * 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.
@@ -543,7 +717,7 @@ export declare class Vector2 {
  * Reminder: js uses a left handed forward facing system
  * Example Playground - Overview - https://playground.babylonjs.com/#R1F8YU
  */
-export declare class Vector3 {
+export declare class Vector3 implements Vector<Tuple<number, 3>>, IVector3Like {
     private static _UpReadOnly;
     private static _DownReadOnly;
     private static _LeftHandedForwardReadOnly;
@@ -554,6 +728,14 @@ export declare class Vector3 {
     private static _LeftReadOnly;
     private static _ZeroReadOnly;
     private static _OneReadOnly;
+    /**
+     * @see Tensor.dimension
+     */
+    readonly dimension: Readonly<[3]>;
+    /**
+     * @see Tensor.rank
+     */
+    readonly rank: 1;
     /** @internal */
     _x: number;
     /** @internal */
@@ -599,7 +781,7 @@ export declare class Vector3 {
      * Example Playground https://playground.babylonjs.com/#R1F8YU#10
      * @returns a new array of numbers
      */
-    asArray(): number[];
+    asArray(): Tuple<number, 3>;
     /**
      * Populates the given array or Float32Array from the given index with the successive coordinates of the Vector3
      * Example Playground https://playground.babylonjs.com/#R1F8YU#65
@@ -612,10 +794,10 @@ export declare 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: FloatArray, index?: number): this;
+    fromArray(array: FloatArray, offset?: number): this;
     /**
      * Converts the current Vector3 into a quaternion (considering that the Vector3 contains Euler angles representation of a rotation)
      * Example Playground https://playground.babylonjs.com/#R1F8YU#66
@@ -746,7 +928,7 @@ export declare class Vector3 {
      * @param result defines the Vector3 object where to store the resultant normal
      * @returns the result
      */
-    getNormalToRef(result: DeepImmutable<Vector3>): Vector3;
+    getNormalToRef(result: Vector3): Vector3;
     /**
      * Rotates the vector using the given unit quaternion and stores the new vector in result
      * Example Playground https://playground.babylonjs.com/#R1F8YU#9
@@ -870,7 +1052,7 @@ export declare class Vector3 {
      * @param otherVector defines the second operand
      * @returns the current updated Vector3
      */
-    divideInPlace(otherVector: Vector3): this;
+    divideInPlace(otherVector: DeepImmutable<Vector3>): 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
@@ -914,12 +1096,24 @@ export declare class Vector3 {
      * Gets a boolean indicating that the vector is non uniform meaning x, y or z are not all the same
      */
     get isNonUniform(): boolean;
+    /**
+     * 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<T extends this>(result: T): T;
     /**
      * Gets a new Vector3 from current Vector3 floored values
      * Example Playground https://playground.babylonjs.com/#R1F8YU#22
      * @returns a new Vector3
      */
     floor(): this;
+    /**
+     * 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<T extends this>(result: T): T;
     /**
      * Gets a new Vector3 from current Vector3 fractional values
      * Example Playground https://playground.babylonjs.com/#R1F8YU#23
@@ -1069,7 +1263,7 @@ export declare class Vector3 {
      * @param normal Normal of the projection plane
      * @returns the angle in radians (float) between vector0 and vector1 projected on the plane with the specified normal
      */
-    static GetAngleBetweenVectorsOnPlane(vector0: Vector3, vector1: Vector3, normal: Vector3): number;
+    static GetAngleBetweenVectorsOnPlane(vector0: DeepImmutable<Vector3>, vector1: DeepImmutable<Vector3>, normal: DeepImmutable<Vector3>): number;
     /**
      * 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
      * Example PG https://playground.babylonjs.com/#R1F8YU#189
@@ -1250,6 +1444,14 @@ export declare class Vector3 {
      * @returns a Vector3 with random values between min and max
      */
     static Random(min?: number, max?: number): Vector3;
+    /**
+     * 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<T extends Vector3>(min: number | undefined, max: number | undefined, ref: T): T;
     /**
      * Returns a new Vector3 set with the result of the transformation by the given matrix of the given vector.
      * This method computes transformed coordinates only, not transformed direction vectors (ie. it takes translation in account)
@@ -1258,7 +1460,7 @@ export declare class Vector3 {
      * @param transformation defines the transformation matrix
      * @returns the transformed Vector3
      */
-    static TransformCoordinates<T extends Vector3>(vector: DeepImmutable<Vector3>, transformation: DeepImmutable<Matrix>): Vector3;
+    static TransformCoordinates(vector: DeepImmutable<Vector3>, transformation: DeepImmutable<Matrix>): Vector3;
     /**
      * Sets the given vector "result" coordinates with the result of the transformation by the given matrix of the given vector
      * This method computes transformed coordinates only, not transformed direction vectors (ie. it takes translation in account)
@@ -1482,7 +1684,7 @@ export declare class Vector3 {
      * @param normal defines the normal - Must be normalized
      * @returns the resulting vector
      */
-    static Reflect<T extends Vector3>(inDirection: DeepImmutable<Vector3>, normal: DeepImmutable<Vector3>): Vector3;
+    static Reflect(inDirection: DeepImmutable<Vector3>, normal: DeepImmutable<Vector3>): Vector3;
     /**
      * Reflects a vector off the plane defined by a normalized normal to reference
      * @param inDirection defines the vector direction
@@ -1636,7 +1838,7 @@ export declare class Vector3 {
 /**
  * Vector4 class created for EulerAngle class conversion to Quaternion
  */
-export declare class Vector4 {
+export declare class Vector4 implements Vector<Tuple<number, 4>>, IVector4Like {
     /** x value of the vector */
     x: number;
     /** y value of the vector */
@@ -1646,6 +1848,14 @@ export declare class Vector4 {
     /** w value of the vector */
     w: number;
     private static _ZeroReadOnly;
+    /**
+     * @see Tensor.dimension
+     */
+    readonly dimension: Readonly<[4]>;
+    /**
+     * @see Tensor.rank
+     */
+    readonly rank: 1;
     /**
      * Creates a Vector4 object from the given floats.
      * @param x x value of the vector
@@ -1681,7 +1891,7 @@ export declare class Vector4 {
      * Returns a new array populated with 4 elements : the Vector4 coordinates.
      * @returns the resulting array
      */
-    asArray(): number[];
+    asArray(): Tuple<number, 4>;
     /**
      * Populates the given array from the given index with the Vector4 coordinates.
      * @param array array to populate
@@ -1692,16 +1902,25 @@ export declare 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: FloatArray, index?: number): this;
+    fromArray(array: FloatArray, offset?: number): this;
     /**
      * Adds the given vector to the current Vector4.
      * @param otherVector the vector to add
      * @returns the updated Vector4.
      */
     addInPlace(otherVector: DeepImmutable<Vector4>): 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: number, y: number, z: number, w: number): 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
@@ -1734,9 +1953,6 @@ export declare class Vector4 {
      * @returns result input
      */
     subtractToRef<T extends Vector4>(otherVector: DeepImmutable<Vector4>, result: T): T;
-    /**
-     * 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
@@ -1825,7 +2041,7 @@ export declare class Vector4 {
      * @param otherVector vector to multiple with
      * @returns the updated Vector4.
      */
-    multiplyInPlace(otherVector: Vector4): this;
+    multiplyInPlace(otherVector: DeepImmutable<Vector4>): this;
     /**
      * Returns a new Vector4 set with the multiplication result of the current Vector4 and the given one.
      * @param otherVector vector to multiple with
@@ -1879,11 +2095,41 @@ export declare class Vector4 {
      * @returns the current updated Vector4
      */
     maximizeInPlace(other: DeepImmutable<Vector4>): 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: number, y: number, z: number, w: number): 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: number, y: number, z: number, w: number): 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<T extends this>(result: T): T;
     /**
      * Gets a new Vector4 from current Vector4 floored values
      * @returns a new Vector4
      */
     floor(): this;
+    /**
+     * 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<T extends this>(result: T): T;
     /**
      * Gets a new Vector4 from current Vector4 fractional values
      * @returns a new Vector4
@@ -1921,7 +2167,7 @@ export declare class Vector4 {
      * @param reference define the Vector4 to update
      * @returns the updated Vector4
      */
-    normalizeToRef<T extends Vector4>(reference: T): T;
+    normalizeToRef<T extends this>(reference: T): T;
     /**
      * Returns a new Vector3 from the Vector4 (x, y, z) coordinates.
      * @returns this converted to a new vector3
@@ -1957,9 +2203,9 @@ export declare class Vector4 {
      */
     set(x: number, y: number, z: number, w: number): this;
     /**
-     * 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: number): this;
     /**
@@ -2018,6 +2264,43 @@ export declare class Vector4 {
      * @returns a Vector4 with random values between min and max
      */
     static Random(min?: number, max?: number): Vector4;
+    /**
+     * 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<T extends Vector4>(min: number | undefined, max: number | undefined, ref: T): T;
+    /**
+     * 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<T extends Vector4>(value: DeepImmutable<T>, min: DeepImmutable<Vector4>, max: DeepImmutable<Vector4>): T;
+    /**
+     * 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<T extends Vector4>(value: DeepImmutable<Vector4>, min: DeepImmutable<Vector4>, max: DeepImmutable<Vector4>, result: T): T;
+    /**
+     * 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: Vector4, min: Vector4, max: Vector4): void;
     /**
      * Gets a zero Vector4 that must not be updated
      */
@@ -2159,7 +2442,7 @@ export declare class Vector4 {
  * @see https://en.wikipedia.org/wiki/Quaternion
  * @see https://doc.babylonjs.com/features/featuresDeepDive/mesh/transforms
  */
-export declare class Quaternion {
+export declare class Quaternion implements Tensor<Tuple<number, 4>>, IQuaternionLike {
     /** @internal */
     _x: number;
     /** @internal */
@@ -2182,6 +2465,14 @@ export declare class Quaternion {
     /** Gets or sets the w coordinate */
     get w(): number;
     set w(value: number);
+    /**
+     * @see Tensor.dimension
+     */
+    readonly dimension: Readonly<[4]>;
+    /**
+     * @see Tensor.rank
+     */
+    readonly rank: 1;
     /**
      * Creates a new Quaternion from the given floats
      * @param x defines the first component (0 by default)
@@ -2210,7 +2501,7 @@ export declare class Quaternion {
      * Example Playground https://playground.babylonjs.com/#L49EJ7#13
      * @returns a new array populated with 4 elements from the quaternion coordinates
      */
-    asArray(): number[];
+    asArray(): Tuple<number, 4>;
     /**
      * Stores from the starting index in the given array the Quaternion successive values
      * Example Playground https://playground.babylonjs.com/#L49EJ7#59
@@ -2218,7 +2509,8 @@ export declare class Quaternion {
      * @param index defines an optional index in the target array to define where to start storing values
      * @returns the current Quaternion object
      */
-    toArray(array: FloatArray, index?: number): Quaternion;
+    toArray(array: FloatArray, index?: number): this;
+    fromArray(array: FloatArray, index?: number): this;
     /**
      * Check if two quaternions are equals
      * Example Playground https://playground.babylonjs.com/#L49EJ7#38
@@ -2267,6 +2559,7 @@ export declare class Quaternion {
      * @returns the updated current quaternion
      */
     set(x: number, y: number, z: number, w: number): this;
+    setAll(value: number): this;
     /**
      * Adds two quaternions
      * Example Playground https://playground.babylonjs.com/#L49EJ7#10
@@ -2281,13 +2574,18 @@ export declare class Quaternion {
      * @returns the current quaternion
      */
     addInPlace(other: DeepImmutable<Quaternion>): this;
+    addToRef<T extends this>(other: DeepImmutable<this>, result: T): T;
+    addInPlaceFromFloats(x: number, y: number, z: number, w: number): this;
+    subtractToRef<T extends this>(other: DeepImmutable<this>, result: T): T;
+    subtractFromFloats(x: number, y: number, z: number, w: number): this;
+    subtractFromFloatsToRef<T extends this>(x: number, y: number, z: number, w: number, result: T): T;
     /**
      * Subtract two quaternions
      * Example Playground https://playground.babylonjs.com/#L49EJ7#57
      * @param other defines the second operand
      * @returns a new quaternion as the subtraction result of the given one from the current one
      */
-    subtract(other: Quaternion): this;
+    subtract(other: DeepImmutable<this>): this;
     /**
      * Subtract a quaternion to the current one
      * Example Playground https://playground.babylonjs.com/#L49EJ7#58
@@ -2343,10 +2641,70 @@ export declare 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: DeepImmutable<Quaternion>): this;
+    multiplyInPlace(other: DeepImmutable<Quaternion>): this;
+    multiplyByFloats(x: number, y: number, z: number, w: number): this;
+    /**
+     * @internal
+     * Do not use
+     */
+    divide(_other: DeepImmutable<this>): this;
+    /**
+     * @internal
+     * Do not use
+     */
+    divideToRef<T extends this>(_other: DeepImmutable<this>, _result: T): T;
+    /**
+     * @internal
+     * Do not use
+     */
+    divideInPlace(_other: DeepImmutable<this>): this;
+    /**
+     * @internal
+     * Do not use
+     */
+    minimizeInPlace(): this;
+    /**
+     * @internal
+     * Do not use
+     */
+    minimizeInPlaceFromFloats(): this;
+    /**
+     * @internal
+     * Do not use
+     */
+    maximizeInPlace(): this;
+    /**
+     * @internal
+     * Do not use
+     */
+    maximizeInPlaceFromFloats(): this;
+    negate(): this;
+    negateInPlace(): this;
+    negateToRef<T extends this>(result: T): T;
+    equalsToFloats(x: number, y: number, z: number, w: number): boolean;
+    /**
+     * @internal
+     * Do not use
+     */
+    floorToRef<T extends this>(_result: T): T;
+    /**
+     * @internal
+     * Do not use
+     */
+    floor(): this;
+    /**
+     * @internal
+     * Do not use
+     */
+    fractToRef<T extends this>(_result: T): T;
+    /**
+     * @internal
+     * Do not use
+     */
+    fract(): this;
     /**
      * Conjugates the current quaternion and stores the result in the given quaternion
      * Example Playground https://playground.babylonjs.com/#L49EJ7#81
@@ -2558,6 +2916,16 @@ export declare class Quaternion {
      * @returns result input
      */
     static FromArrayToRef<T extends Quaternion>(array: DeepImmutable<ArrayLike<number>>, offset: number, result: T): T;
+    /**
+     * 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<T extends Quaternion = Quaternion>(x: number, y: number, z: number, w: number, result: T): T;
     /**
      * Create a quaternion from Euler rotation angles
      * Example Playground https://playground.babylonjs.com/#L49EJ7#33
@@ -2764,6 +3132,81 @@ export declare class Quaternion {
      * @returns result input
      */
     static NormalizeToRef<T extends Quaternion>(quat: DeepImmutable<Quaternion>, result: T): T;
+    /**
+     * 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<T extends Quaternion>(value: DeepImmutable<T>, min: DeepImmutable<Quaternion>, max: DeepImmutable<Quaternion>): T;
+    /**
+     * 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<T extends Quaternion>(value: DeepImmutable<Quaternion>, min: DeepImmutable<Quaternion>, max: DeepImmutable<Quaternion>, result: T): T;
+    /**
+     * 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?: number, max?: number): Quaternion;
+    /**
+     * 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<T extends Quaternion>(min: number | undefined, max: number | undefined, ref: T): T;
+    /**
+     * Do not use
+     * @internal
+     */
+    static Minimize(): Quaternion;
+    /**
+     * Do not use
+     * @internal
+     */
+    static Maximize(): Quaternion;
+    /**
+     * 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: DeepImmutable<Quaternion>, value2: DeepImmutable<Quaternion>): number;
+    /**
+     * 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: DeepImmutable<Quaternion>, value2: DeepImmutable<Quaternion>): number;
+    /**
+     * 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: DeepImmutable<Quaternion>, value2: DeepImmutable<Quaternion>): Quaternion;
+    /**
+     * 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<T extends Quaternion>(value1: DeepImmutable<Quaternion>, value2: DeepImmutable<Quaternion>, ref: T): T;
 }
 /**
  * Class used to store matrix data (4x4)
@@ -2787,7 +3230,15 @@ export declare class Quaternion {
  * Example Playground - Overview Transformation - https://playground.babylonjs.com/#AV9X17#1
  * Example Playground - Overview Projection - https://playground.babylonjs.com/#AV9X17#2
  */
-export declare class Matrix {
+export declare class Matrix implements Tensor<Tuple<Tuple<number, 4>, 4>>, IMatrixLike {
+    /**
+     * @see Tensor.dimension
+     */
+    readonly dimension: Readonly<[4, 4]>;
+    /**
+     * @see Tensor.rank
+     */
+    readonly rank: 2;
     /**
      * Gets the precision of matrix computations
      */
@@ -2808,7 +3259,7 @@ export declare class Matrix {
     /**
      * Gets the internal data of the matrix
      */
-    get m(): DeepImmutable<Float32Array | Array<number>>;
+    get m(): DeepImmutable<Tuple<number, 16>>;
     /**
      * Update the updateFlag to indicate that the matrix has been updated
      */
@@ -2841,16 +3292,27 @@ export declare class Matrix {
     toString(): string;
     /**
      * Returns the matrix as a Float32Array or Array<number>
+     * @deprecated Use asArray
+     */
+    toArray(): FloatArray;
+    /**
+     * Stores the matrix in a Float32Array or Array<number>
      * Example Playground - https://playground.babylonjs.com/#AV9X17#49
-     * @returns the matrix underlying array
+     * @param array The destination array
+     * @param index The destination index to start ay
+     * @returns the matrix
      */
-    toArray(): DeepImmutable<Float32Array | Array<number>>;
+    toArray(array: FloatArray, index: number): this;
     /**
      * Returns the matrix as a Float32Array or Array<number>
      * Example Playground - https://playground.babylonjs.com/#AV9X17#114
      * @returns the matrix underlying array.
      */
-    asArray(): DeepImmutable<Float32Array | Array<number>>;
+    asArray(): Tuple<number, 16>;
+    fromArray(array: FloatArray, index?: number): this;
+    copyFromFloats(...floats: Tuple<number, 16>): this;
+    set(...values: Tuple<number, 16>): this;
+    setAll(value: number): this;
     /**
      * Inverts the current matrix in place
      * Example Playground - https://playground.babylonjs.com/#AV9X17#118
@@ -2884,6 +3346,13 @@ export declare class Matrix {
      * @returns the current updated matrix
      */
     addToSelf(other: DeepImmutable<Matrix>): this;
+    addInPlace(other: DeepImmutable<this>): this;
+    addInPlaceFromFloats(...floats: Tuple<number, 16>): this;
+    subtract(other: DeepImmutable<this>): this;
+    subtractToRef<T extends this>(other: DeepImmutable<this>, result: T): T;
+    subtractInPlace(other: DeepImmutable<this>): this;
+    subtractFromFloats(...floats: Tuple<number, 16>): this;
+    subtractFromFloatsToRef<T extends this>(...args: [...Tuple<number, 16>, T]): T;
     /**
      * Sets the given matrix to the current inverted Matrix
      * Example Playground - https://playground.babylonjs.com/#AV9X17#119
@@ -2950,14 +3419,6 @@ export declare class Matrix {
      * @returns the updated matrix
      */
     removeRotationAndScaling(): 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: DeepImmutable<Matrix>): this;
     /**
      * Copy the current matrix from the given one
      * Example Playground - https://playground.babylonjs.com/#AV9X17#21
@@ -2972,6 +3433,22 @@ export declare class Matrix {
      * @returns the current matrix
      */
     copyToArray(array: Float32Array | Array<number>, offset?: number): 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: DeepImmutable<Matrix>): this;
+    multiplyInPlace(other: DeepImmutable<this>): this;
+    multiplyByFloats(...floats: Tuple<number, 16>): 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<T extends this>(...args: [...Tuple<number, 16>, T]): T;
     /**
      * 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
@@ -2989,12 +3466,28 @@ export declare class Matrix {
      * @returns the current matrix
      */
     multiplyToArray(other: DeepImmutable<Matrix>, result: Float32Array | Array<number>, offset: number): this;
+    divide(other: DeepImmutable<this>): this;
+    divideToRef<T extends this>(other: DeepImmutable<this>, result: T): T;
+    divideInPlace(other: DeepImmutable<this>): this;
+    minimizeInPlace(other: DeepImmutable<this>): this;
+    minimizeInPlaceFromFloats(...floats: Tuple<number, 16>): this;
+    maximizeInPlace(other: DeepImmutable<this>): this;
+    maximizeInPlaceFromFloats(...floats: Tuple<number, 16>): this;
+    negate(): this;
+    negateInPlace(): this;
+    negateToRef<T extends this>(result: T): T;
     /**
      * Check equality between this matrix and a second one
      * @param value defines the second matrix to compare
      * @returns true is the current matrix and the given one values are strictly equal
      */
     equals(value: DeepImmutable<Matrix>): boolean;
+    equalsWithEpsilon(other: DeepImmutable<this>, epsilon?: number): boolean;
+    equalsToFloats(...floats: Tuple<number, 16>): boolean;
+    floor(): this;
+    floorToRef<T extends this>(result: T): T;
+    fract(): this;
+    fractToRef<T extends this>(result: T): T;
     /**
      * Clone the current matrix
      * Example Playground - https://playground.babylonjs.com/#AV9X17#18
@@ -3096,6 +3589,7 @@ export declare class Matrix {
      * @returns result input
      */
     scaleAndAddToRef<T extends Matrix>(scale: number, result: T): T;
+    scaleInPlace(scale: number): 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
@@ -3780,9 +4274,14 @@ export declare class Matrix {
  * @internal
  */
 export declare class TmpVectors {
+    /** 3 temp Vector2 at once should be enough */
     static Vector2: [Vector2, Vector2, Vector2];
+    /** 13 temp Vector3 at once should be enough */
     static Vector3: [Vector3, Vector3, Vector3, Vector3, Vector3, Vector3, Vector3, Vector3, Vector3, Vector3, Vector3, Vector3, Vector3];
+    /** 3 temp Vector4 at once should be enough */
     static Vector4: [Vector4, Vector4, Vector4];
+    /** 2 temp Quaternion at once should be enough */
     static Quaternion: [Quaternion, Quaternion];
+    /** 8 temp Matrices at once should be enough */
     static Matrix: [Matrix, Matrix, Matrix, Matrix, Matrix, Matrix, Matrix, Matrix];
 }