@babylonjs/core 5.28.0 → 5.30.0

package/Maths/math.vector.d.ts

@@ -3,6 +3,11 @@ import type { DeepImmutable, Nullable, FloatArray, float } from "../types";
 import type { IPlaneLike } from "./math.like";
 import type { Plane } from "./math.plane";
 declare type TransformNode = import("../Meshes/transformNode").TransformNode;
+export declare type Vector2Constructor<T extends Vector2> = new (...args: ConstructorParameters<typeof Vector2>) => T;
+export declare type Vector3Constructor<T extends Vector3> = new (...args: ConstructorParameters<typeof Vector3>) => T;
+export declare type Vector4Constructor<T extends Vector4> = new (...args: ConstructorParameters<typeof Vector4>) => T;
+export declare type QuaternionConstructor<T extends Quaternion> = new (...args: ConstructorParameters<typeof Quaternion>) => T;
+export declare type MatrixConstructor<T extends Matrix> = new () => T;
 /**
  * Class representing a vector containing 2 coordinates
  * Example Playground - Overview -  https://playground.babylonjs.com/#QYBWV4#9
@@ -45,15 +50,15 @@ export declare class Vector2 {
      * @param index defines the offset in source array
      * @returns the current Vector2
      */
-    toArray(array: FloatArray, index?: number): Vector2;
+    toArray(array: FloatArray, index?: number): this;
     /**
      * 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
-     * @returns the current Vector3
+     * @returns the current Vector2
      */
-    fromArray(array: FloatArray, index?: number): Vector2;
+    fromArray(array: FloatArray, index?: number): this;
     /**
      * Copy the current vector to an array
      * Example Playground https://playground.babylonjs.com/#QYBWV4#40
@@ -66,7 +71,7 @@ export declare class Vector2 {
      * @param source defines the source Vector2
      * @returns the current updated Vector2
      */
-    copyFrom(source: DeepImmutable<Vector2>): Vector2;
+    copyFrom(source: DeepImmutable<Vector2>): this;
     /**
      * Sets the Vector2 coordinates with the given floats
      * Example Playground https://playground.babylonjs.com/#QYBWV4#25
@@ -74,7 +79,7 @@ export declare class Vector2 {
      * @param y defines the second coordinate
      * @returns the current updated Vector2
      */
-    copyFromFloats(x: number, y: number): Vector2;
+    copyFromFloats(x: number, y: number): this;
     /**
      * Sets the Vector2 coordinates with the given floats
      * Example Playground https://playground.babylonjs.com/#QYBWV4#62
@@ -82,80 +87,80 @@ export declare class Vector2 {
      * @param y defines the second coordinate
      * @returns the current updated Vector2
      */
-    set(x: number, y: number): Vector2;
+    set(x: number, y: 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>): Vector2;
+    add(otherVector: DeepImmutable<Vector2>): 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
      * @param otherVector defines the other vector
      * @param result defines the target vector
-     * @returns the unmodified current Vector2
+     * @returns result input
      */
-    addToRef(otherVector: DeepImmutable<Vector2>, result: Vector2): Vector2;
+    addToRef<T extends Vector2>(otherVector: DeepImmutable<Vector2>, 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>): Vector2;
+    addInPlace(otherVector: DeepImmutable<Vector2>): 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
      * @param otherVector defines the other vector
      * @returns a new Vector2
      */
-    addVector3(otherVector: Vector3): Vector2;
+    addVector3(otherVector: Vector3): this;
     /**
      * Gets a new Vector2 set with the subtracted coordinates of the given one from the current Vector2
      * Example Playground https://playground.babylonjs.com/#QYBWV4#61
      * @param otherVector defines the other vector
      * @returns a new Vector2
      */
-    subtract(otherVector: Vector2): Vector2;
+    subtract(otherVector: Vector2): 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
      * @param otherVector defines the other vector
      * @param result defines the target vector
-     * @returns the unmodified current Vector2
+     * @returns result input
      */
-    subtractToRef(otherVector: DeepImmutable<Vector2>, result: Vector2): Vector2;
+    subtractToRef<T extends Vector2>(otherVector: DeepImmutable<Vector2>, 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>): Vector2;
+    subtractInPlace(otherVector: DeepImmutable<Vector2>): 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>): Vector2;
+    multiplyInPlace(otherVector: DeepImmutable<Vector2>): 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>): Vector2;
+    multiply(otherVector: DeepImmutable<Vector2>): this;
     /**
      * Sets "result" coordinates with the multiplication of the current Vector2 and the given one coordinates
      * Example Playground https://playground.babylonjs.com/#QYBWV4#44
      * @param otherVector defines the other vector
      * @param result defines the target vector
-     * @returns the unmodified current Vector2
+     * @returns result input
      */
-    multiplyToRef(otherVector: DeepImmutable<Vector2>, result: Vector2): Vector2;
+    multiplyToRef<T extends Vector2>(otherVector: DeepImmutable<Vector2>, 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
@@ -163,78 +168,78 @@ export declare class Vector2 {
      * @param y defines the second coordinate
      * @returns a new Vector2
      */
-    multiplyByFloats(x: number, y: number): Vector2;
+    multiplyByFloats(x: number, y: number): this;
     /**
      * Returns a new Vector2 set with the Vector2 coordinates divided by the given one coordinates
      * Example Playground https://playground.babylonjs.com/#QYBWV4#27
      * @param otherVector defines the other vector
      * @returns a new Vector2
      */
-    divide(otherVector: Vector2): Vector2;
+    divide(otherVector: Vector2): this;
     /**
      * Sets the "result" coordinates with the Vector2 divided by the given one coordinates
      * Example Playground https://playground.babylonjs.com/#QYBWV4#30
      * @param otherVector defines the other vector
      * @param result defines the target vector
-     * @returns the unmodified current Vector2
+     * @returns result input
      */
-    divideToRef(otherVector: DeepImmutable<Vector2>, result: Vector2): Vector2;
+    divideToRef<T extends Vector2>(otherVector: DeepImmutable<Vector2>, 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>): Vector2;
+    divideInPlace(otherVector: DeepImmutable<Vector2>): this;
     /**
      * Gets a new Vector2 with current Vector2 negated coordinates
      * Example Playground https://playground.babylonjs.com/#QYBWV4#22
      * @returns a new Vector2
      */
-    negate(): Vector2;
+    negate(): this;
     /**
      * Negate this vector in place
      * Example Playground https://playground.babylonjs.com/#QYBWV4#23
      * @returns this
      */
-    negateInPlace(): Vector2;
+    negateInPlace(): this;
     /**
      * Negate the current Vector2 and stores the result in the given vector "result" coordinates
      * Example Playground https://playground.babylonjs.com/#QYBWV4#41
      * @param result defines the Vector3 object where to store the result
      * @returns the result
      */
-    negateToRef(result: Vector2): Vector2;
+    negateToRef<T extends Vector2>(result: T): T;
     /**
      * Multiply the Vector2 coordinates by
      * Example Playground https://playground.babylonjs.com/#QYBWV4#59
      * @param scale defines the scaling factor
      * @returns the current updated Vector2
      */
-    scaleInPlace(scale: number): Vector2;
+    scaleInPlace(scale: number): this;
     /**
      * Returns a new Vector2 scaled by "scale" from the current Vector2
      * Example Playground https://playground.babylonjs.com/#QYBWV4#52
      * @param scale defines the scaling factor
      * @returns a new Vector2
      */
-    scale(scale: number): Vector2;
+    scale(scale: number): this;
     /**
      * Scale the current Vector2 values by a factor to a given Vector2
      * Example Playground https://playground.babylonjs.com/#QYBWV4#57
      * @param scale defines the scale factor
      * @param result defines the Vector2 object where to store the result
-     * @returns the unmodified current Vector2
+     * @returns result input
      */
-    scaleToRef(scale: number, result: Vector2): Vector2;
+    scaleToRef<T extends Vector2>(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
      * @param scale defines the scale factor
      * @param result defines the Vector2 object where to store the result
-     * @returns the unmodified current Vector2
+     * @returns result input
      */
-    scaleAndAddToRef(scale: number, result: Vector2): Vector2;
+    scaleAndAddToRef<T extends Vector2>(scale: number, result: T): T;
     /**
      * Gets a boolean if two vectors are equals
      * Example Playground https://playground.babylonjs.com/#QYBWV4#31
@@ -256,22 +261,22 @@ export declare class Vector2 {
      * eg (1.2, 2.31) returns (1, 2)
      * @returns a new Vector2
      */
-    floor(): Vector2;
+    floor(): this;
     /**
      * Gets a new Vector2 from current Vector2 fractional values
      * Example Playground https://playground.babylonjs.com/#QYBWV4#34
      * eg (1.2, 2.31) returns (0.2, 0.31)
      * @returns a new Vector2
      */
-    fract(): Vector2;
+    fract(): this;
     /**
      * Rotate the current vector into a given result vector
      * Example Playground https://playground.babylonjs.com/#QYBWV4#49
      * @param angle defines the rotation angle
      * @param result defines the result vector where to store the rotated vector
-     * @returns the current vector
+     * @returns result input
      */
-    rotateToRef(angle: number, result: Vector2): this;
+    rotateToRef<T extends Vector2>(angle: number, result: T): T;
     /**
      * Gets the length of the vector
      * @returns the vector length (float)
@@ -287,13 +292,13 @@ export declare class Vector2 {
      * Example Playground https://playground.babylonjs.com/#QYBWV4#48
      * @returns the current updated Vector2
      */
-    normalize(): Vector2;
+    normalize(): this;
     /**
      * Gets a new Vector2 copied from the Vector2
      * Example Playground https://playground.babylonjs.com/#QYBWV4#20
      * @returns a new Vector2
      */
-    clone(): Vector2;
+    clone(): this;
     /**
      * Gets a new Vector2(0, 0)
      * @returns a new Vector2
@@ -322,8 +327,9 @@ export declare class Vector2 {
      * @param array defines the data source
      * @param offset defines the offset in the data source
      * @param result defines the target vector
+     * @returns result input
      */
-    static FromArrayToRef(array: DeepImmutable<ArrayLike<number>>, offset: number, result: Vector2): void;
+    static FromArrayToRef<T extends Vector2>(array: DeepImmutable<ArrayLike<number>>, offset: 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
@@ -334,7 +340,7 @@ export declare class Vector2 {
      * @param amount defines the interpolation factor
      * @returns a new Vector2
      */
-    static CatmullRom(value1: DeepImmutable<Vector2>, value2: DeepImmutable<Vector2>, value3: DeepImmutable<Vector2>, value4: DeepImmutable<Vector2>, amount: number): Vector2;
+    static CatmullRom<T extends Vector2>(value1: DeepImmutable<T>, value2: DeepImmutable<Vector2>, value3: DeepImmutable<Vector2>, value4: DeepImmutable<Vector2>, amount: number): 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.
@@ -345,7 +351,7 @@ export declare class Vector2 {
      * @param max defines the upper limit
      * @returns a new Vector2
      */
-    static Clamp(value: DeepImmutable<Vector2>, min: DeepImmutable<Vector2>, max: DeepImmutable<Vector2>): Vector2;
+    static Clamp<T extends Vector2>(value: DeepImmutable<T>, min: DeepImmutable<Vector2>, max: DeepImmutable<Vector2>): T;
     /**
      * Returns a new Vector2 located for "amount" (float) on the Hermite spline defined by the vectors "value1", "value2", "tangent1", "tangent2"
      * Example Playground https://playground.babylonjs.com/#QYBWV4#81
@@ -356,7 +362,7 @@ export declare class Vector2 {
      * @param amount defines the interpolation factor
      * @returns a new Vector2
      */
-    static Hermite(value1: DeepImmutable<Vector2>, tangent1: DeepImmutable<Vector2>, value2: DeepImmutable<Vector2>, tangent2: DeepImmutable<Vector2>, amount: number): Vector2;
+    static Hermite<T extends Vector2>(value1: DeepImmutable<T>, tangent1: DeepImmutable<Vector2>, value2: DeepImmutable<Vector2>, tangent2: DeepImmutable<Vector2>, amount: number): T;
     /**
      * Returns a new Vector2 which is the 1st derivative of the Hermite spline defined by the vectors "value1", "value2", "tangent1", "tangent2".
      * Example Playground https://playground.babylonjs.com/#QYBWV4#82
@@ -367,7 +373,7 @@ export declare class Vector2 {
      * @param time define where the derivative must be done
      * @returns 1st derivative
      */
-    static Hermite1stDerivative(value1: DeepImmutable<Vector2>, tangent1: DeepImmutable<Vector2>, value2: DeepImmutable<Vector2>, tangent2: DeepImmutable<Vector2>, time: number): Vector2;
+    static Hermite1stDerivative<T extends Vector2>(value1: DeepImmutable<T>, tangent1: DeepImmutable<Vector2>, value2: DeepImmutable<Vector2>, tangent2: DeepImmutable<Vector2>, time: number): T;
     /**
      * Returns a new Vector2 which is the 1st derivative of the Hermite spline defined by the vectors "value1", "value2", "tangent1", "tangent2".
      * Example Playground https://playground.babylonjs.com/#QYBWV4#83
@@ -377,8 +383,9 @@ export declare class Vector2 {
      * @param tangent2 defines the second tangent
      * @param time define where the derivative must be done
      * @param result define where the derivative will be stored
+     * @returns result input
      */
-    static Hermite1stDerivativeToRef(value1: DeepImmutable<Vector2>, tangent1: DeepImmutable<Vector2>, value2: DeepImmutable<Vector2>, tangent2: DeepImmutable<Vector2>, time: number, result: Vector2): void;
+    static Hermite1stDerivativeToRef<T extends Vector2>(value1: DeepImmutable<Vector2>, tangent1: DeepImmutable<Vector2>, value2: DeepImmutable<Vector2>, tangent2: DeepImmutable<Vector2>, time: number, result: T): T;
     /**
      * Returns a new Vector2 located for "amount" (float) on the linear interpolation between the vector "start" adn the vector "end".
      * Example Playground https://playground.babylonjs.com/#QYBWV4#84
@@ -387,7 +394,7 @@ export declare class Vector2 {
      * @param amount defines the interpolation factor
      * @returns a new Vector2
      */
-    static Lerp(start: DeepImmutable<Vector2>, end: DeepImmutable<Vector2>, amount: number): Vector2;
+    static Lerp<T extends Vector2>(start: DeepImmutable<T>, end: DeepImmutable<Vector2>, amount: number): Vector2;
     /**
      * Gets the dot product of the vector "left" and the vector "right"
      * Example Playground https://playground.babylonjs.com/#QYBWV4#90
@@ -402,14 +409,15 @@ export declare class Vector2 {
      * @param vector defines the vector to normalize
      * @returns a new Vector2
      */
-    static Normalize(vector: DeepImmutable<Vector2>): Vector2;
+    static Normalize<T extends Vector2>(vector: DeepImmutable<T>): T;
     /**
      * Normalize a given vector into a second one
      * Example Playground https://playground.babylonjs.com/#QYBWV4#50
      * @param vector defines the vector to normalize
      * @param result defines the vector where to store the result
+     * @returns result input
      */
-    static NormalizeToRef(vector: DeepImmutable<Vector2>, result: Vector2): void;
+    static NormalizeToRef<T extends Vector2>(vector: DeepImmutable<Vector2>, result: T): T;
     /**
      * Gets a new Vector2 set with the minimal coordinate values from the "left" and "right" vectors
      * Example Playground https://playground.babylonjs.com/#QYBWV4#86
@@ -417,7 +425,7 @@ export declare class Vector2 {
      * @param right defines 2nd vector
      * @returns a new Vector2
      */
-    static Minimize(left: DeepImmutable<Vector2>, right: DeepImmutable<Vector2>): Vector2;
+    static Minimize<T extends Vector2>(left: DeepImmutable<T>, right: DeepImmutable<Vector2>): T;
     /**
      * Gets a new Vector2 set with the maximal coordinate values from the "left" and "right" vectors
      * Example Playground https://playground.babylonjs.com/#QYBWV4#86
@@ -425,7 +433,7 @@ export declare class Vector2 {
      * @param right defines 2nd vector
      * @returns a new Vector2
      */
-    static Maximize(left: DeepImmutable<Vector2>, right: DeepImmutable<Vector2>): Vector2;
+    static Maximize<T extends Vector2>(left: DeepImmutable<T>, right: DeepImmutable<Vector2>): T;
     /**
      * Gets a new Vector2 set with the transformed coordinates of the given vector by the given transformation matrix
      * Example Playground https://playground.babylonjs.com/#QYBWV4#17
@@ -433,15 +441,16 @@ export declare class Vector2 {
      * @param transformation defines the matrix to apply
      * @returns a new Vector2
      */
-    static Transform(vector: DeepImmutable<Vector2>, transformation: DeepImmutable<Matrix>): Vector2;
+    static Transform<T extends Vector2>(vector: DeepImmutable<T>, transformation: DeepImmutable<Matrix>): T;
     /**
      * Transforms the given vector coordinates by the given transformation matrix and stores the result in the vector "result" coordinates
      * Example Playground https://playground.babylonjs.com/#QYBWV4#19
      * @param vector defines the vector to transform
      * @param transformation defines the matrix to apply
      * @param result defines the target vector
+     * @returns result input
      */
-    static TransformToRef(vector: DeepImmutable<Vector2>, transformation: DeepImmutable<Matrix>, result: Vector2): void;
+    static TransformToRef<T extends Vector2>(vector: DeepImmutable<Vector2>, transformation: DeepImmutable<Matrix>, result: T): T;
     /**
      * Determines if a given vector is included in a triangle
      * Example Playground https://playground.babylonjs.com/#QYBWV4#87
@@ -476,7 +485,7 @@ export declare class Vector2 {
      * @param value2 defines second vector
      * @returns a new Vector2
      */
-    static Center(value1: DeepImmutable<Vector2>, value2: DeepImmutable<Vector2>): Vector2;
+    static Center<T extends Vector2>(value1: DeepImmutable<T>, value2: DeepImmutable<Vector2>): T;
     /**
      * Gets the center of the vectors "value1" and "value2" and stores the result in the vector "ref"
      * Example Playground https://playground.babylonjs.com/#QYBWV4#66
@@ -485,7 +494,7 @@ export declare class Vector2 {
      * @param ref defines third vector
      * @returns ref
      */
-    static CenterToRef(value1: DeepImmutable<Vector2>, value2: DeepImmutable<Vector2>, ref: DeepImmutable<Vector2>): Vector2;
+    static CenterToRef<T extends Vector2>(value1: DeepImmutable<Vector2>, value2: DeepImmutable<Vector2>, ref: T): T;
     /**
      * Gets the shortest distance (float) between the point "p" and the segment defined by the two points "segA" and "segB".
      * Example Playground https://playground.babylonjs.com/#QYBWV4#77
@@ -564,7 +573,7 @@ export declare class Vector3 {
      * @param index defines the offset in the destination array
      * @returns the current Vector3
      */
-    toArray(array: FloatArray, index?: number): Vector3;
+    toArray(array: FloatArray, index?: number): this;
     /**
      * Update the current vector from an array
      * Example Playground https://playground.babylonjs.com/#R1F8YU#24
@@ -572,7 +581,7 @@ export declare class Vector3 {
      * @param index defines the offset in the destination array
      * @returns the current Vector3
      */
-    fromArray(array: FloatArray, index?: number): Vector3;
+    fromArray(array: FloatArray, index?: 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
@@ -585,7 +594,7 @@ export declare class Vector3 {
      * @param otherVector defines the second operand
      * @returns the current updated Vector3
      */
-    addInPlace(otherVector: DeepImmutable<Vector3>): Vector3;
+    addInPlace(otherVector: DeepImmutable<Vector3>): this;
     /**
      * Adds the given coordinates to the current Vector3
      * Example Playground https://playground.babylonjs.com/#R1F8YU#5
@@ -594,14 +603,14 @@ export declare class Vector3 {
      * @param z defines the z coordinate of the operand
      * @returns the current updated Vector3
      */
-    addInPlaceFromFloats(x: number, y: number, z: number): Vector3;
+    addInPlaceFromFloats(x: number, y: number, z: number): this;
     /**
      * Gets a new Vector3, result of the addition the current Vector3 and the given vector
      * Example Playground https://playground.babylonjs.com/#R1F8YU#3
      * @param otherVector defines the second operand
      * @returns the resulting Vector3
      */
-    add(otherVector: DeepImmutable<Vector3>): Vector3;
+    add(otherVector: DeepImmutable<Vector3>): this;
     /**
      * Adds the current Vector3 to the given one and stores the result in the vector "result"
      * Example Playground https://playground.babylonjs.com/#R1F8YU#6
@@ -609,21 +618,21 @@ export declare class Vector3 {
      * @param result defines the Vector3 object where to store the result
      * @returns the result
      */
-    addToRef(otherVector: DeepImmutable<Vector3>, result: Vector3): Vector3;
+    addToRef<T extends Vector3>(otherVector: DeepImmutable<Vector3>, 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>): Vector3;
+    subtractInPlace(otherVector: DeepImmutable<Vector3>): 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<Vector3>): this;
     /**
      * Subtracts the given vector from the current Vector3 and stores the result in the vector "result".
      * Example Playground https://playground.babylonjs.com/#R1F8YU#63
@@ -631,7 +640,7 @@ export declare class Vector3 {
      * @param result defines the Vector3 object where to store the result
      * @returns the result
      */
-    subtractToRef(otherVector: DeepImmutable<Vector3>, result: Vector3): Vector3;
+    subtractToRef<T extends Vector3>(otherVector: DeepImmutable<Vector3>, 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
@@ -640,7 +649,7 @@ export declare class Vector3 {
      * @param z defines the z coordinate of the operand
      * @returns the resulting Vector3
      */
-    subtractFromFloats(x: number, y: number, z: number): Vector3;
+    subtractFromFloats(x: number, y: number, z: number): this;
     /**
      * Subtracts the given floats from the current Vector3 coordinates and set the given vector "result" with this result
      * Example Playground https://playground.babylonjs.com/#R1F8YU#64
@@ -650,40 +659,40 @@ export declare class Vector3 {
      * @param result defines the Vector3 object where to store the result
      * @returns the result
      */
-    subtractFromFloatsToRef(x: number, y: number, z: number, result: Vector3): Vector3;
+    subtractFromFloatsToRef<T extends Vector3>(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
      * @returns a new Vector3
      */
-    negate(): Vector3;
+    negate(): this;
     /**
      * Negate this vector in place
      * Example Playground https://playground.babylonjs.com/#R1F8YU#36
      * @returns this
      */
-    negateInPlace(): Vector3;
+    negateInPlace(): this;
     /**
      * Negate the current Vector3 and stores the result in the given vector "result" coordinates
      * Example Playground https://playground.babylonjs.com/#R1F8YU#37
      * @param result defines the Vector3 object where to store the result
      * @returns the result
      */
-    negateToRef(result: Vector3): Vector3;
+    negateToRef<T extends Vector3 = Vector3>(result: T): T;
     /**
      * Multiplies the Vector3 coordinates by the float "scale"
      * Example Playground https://playground.babylonjs.com/#R1F8YU#56
      * @param scale defines the multiplier factor
      * @returns the current updated Vector3
      */
-    scaleInPlace(scale: number): Vector3;
+    scaleInPlace(scale: number): this;
     /**
      * Returns a new Vector3 set with the current Vector3 coordinates multiplied by the float "scale"
      * Example Playground https://playground.babylonjs.com/#R1F8YU#53
      * @param scale defines the multiplier factor
      * @returns a new Vector3
      */
-    scale(scale: number): Vector3;
+    scale(scale: number): this;
     /**
      * Multiplies the current Vector3 coordinates by the float "scale" and stores the result in the given vector "result" coordinates
      * Example Playground https://playground.babylonjs.com/#R1F8YU#57
@@ -691,14 +700,19 @@ export declare class Vector3 {
      * @param result defines the Vector3 object where to store the result
      * @returns the result
      */
-    scaleToRef(scale: number, result: Vector3): Vector3;
+    scaleToRef<T extends Vector3>(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
+     * 90 degrees about an axis which lies perpendicular to the current vector
+     * and its projection on the xz plane. In the case of a current vector in the xz plane
+     * the normal is calculated to be along the y axis.
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#230
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#231
      * @param result defines the Vector3 object where to store the resultant normal
      * returns the result
-     * @hidden
      */
-    _getNormalToRef(result: DeepImmutable<Vector3>): Vector3;
+    getNormalToRef(result: DeepImmutable<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
@@ -706,29 +720,29 @@ export declare class Vector3 {
      * @param result the output vector
      * @returns the result
      */
-    applyRotationQuaternionToRef(q: Quaternion, result: Vector3): Vector3;
+    applyRotationQuaternionToRef<T extends Vector3>(q: Quaternion, result: T): T;
     /**
      * Rotates the vector in place using the given unit quaternion
      * Example Playground https://playground.babylonjs.com/#R1F8YU#8
      * @param q the unit quaternion representing the rotation
      * @returns the current updated Vector3
      */
-    applyRotationQuaternionInPlace(q: Quaternion): Vector3;
+    applyRotationQuaternionInPlace(q: Quaternion): this;
     /**
      * Rotates the vector using the given unit quaternion and returns the new vector
      * Example Playground https://playground.babylonjs.com/#R1F8YU#7
      * @param q the unit quaternion representing the rotation
      * @returns a new Vector3
      */
-    applyRotationQuaternion(q: Quaternion): Vector3;
+    applyRotationQuaternion(q: Quaternion): this;
     /**
      * Scale the current Vector3 values by a factor and add the result to a given Vector3
      * Example Playground https://playground.babylonjs.com/#R1F8YU#55
      * @param scale defines the scale factor
      * @param result defines the Vector3 object where to store the result
-     * @returns the unmodified current Vector3
+     * @returns result input
      */
-    scaleAndAddToRef(scale: number, result: Vector3): Vector3;
+    scaleAndAddToRef<T extends Vector3>(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
@@ -736,15 +750,16 @@ export declare class Vector3 {
      * @param origin defines the origin of the projection ray
      * @returns the projected vector3
      */
-    projectOnPlane(plane: Plane, origin: Vector3): Vector3;
+    projectOnPlane<T extends Vector3>(plane: Plane, origin: Vector3): 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#49
      * @param plane defines the plane to project to
      * @param origin defines the origin of the projection ray
      * @param result defines the Vector3 where to store the result
+     * @returns result input
      */
-    projectOnPlaneToRef(plane: Plane, origin: Vector3, result: Vector3): void;
+    projectOnPlaneToRef<T extends Vector3>(plane: Plane, origin: Vector3, result: T): T;
     /**
      * Returns true if the current Vector3 and the given vector coordinates are strictly equal
      * Example Playground https://playground.babylonjs.com/#R1F8YU#19
@@ -775,14 +790,14 @@ export declare class Vector3 {
      * @param otherVector defines the second operand
      * @returns the current updated Vector3
      */
-    multiplyInPlace(otherVector: DeepImmutable<Vector3>): Vector3;
+    multiplyInPlace(otherVector: DeepImmutable<Vector3>): 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<Vector3>): this;
     /**
      * 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
@@ -790,7 +805,7 @@ export declare class Vector3 {
      * @param result defines the Vector3 object where to store the result
      * @returns the result
      */
-    multiplyToRef(otherVector: DeepImmutable<Vector3>, result: Vector3): Vector3;
+    multiplyToRef<T extends Vector3>(otherVector: DeepImmutable<Vector3>, 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
@@ -799,14 +814,14 @@ export declare class Vector3 {
      * @param z defines the z coordinate of the operand
      * @returns the new Vector3
      */
-    multiplyByFloats(x: number, y: number, z: number): Vector3;
+    multiplyByFloats(x: number, y: number, z: number): this;
     /**
      * Returns a new Vector3 set with the result of the division of the current Vector3 coordinates by the given ones
      * Example Playground https://playground.babylonjs.com/#R1F8YU#16
      * @param otherVector defines the second operand
      * @returns the new Vector3
      */
-    divide(otherVector: DeepImmutable<Vector3>): Vector3;
+    divide(otherVector: DeepImmutable<Vector3>): this;
     /**
      * 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
@@ -814,28 +829,28 @@ export declare class Vector3 {
      * @param result defines the Vector3 object where to store the result
      * @returns the result
      */
-    divideToRef(otherVector: DeepImmutable<Vector3>, result: Vector3): Vector3;
+    divideToRef<T extends Vector3>(otherVector: DeepImmutable<Vector3>, 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: Vector3): Vector3;
+    divideInPlace(otherVector: 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
      * @param other defines the second operand
      * @returns the current updated Vector3
      */
-    minimizeInPlace(other: DeepImmutable<Vector3>): Vector3;
+    minimizeInPlace(other: DeepImmutable<Vector3>): 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>): Vector3;
+    maximizeInPlace(other: DeepImmutable<Vector3>): this;
     /**
      * Updates the current Vector3 with the minimal coordinate values between its and the given coordinates
      * Example Playground https://playground.babylonjs.com/#R1F8YU#30
@@ -844,7 +859,7 @@ export declare class Vector3 {
      * @param z defines the z coordinate of the operand
      * @returns the current updated Vector3
      */
-    minimizeInPlaceFromFloats(x: number, y: number, z: number): Vector3;
+    minimizeInPlaceFromFloats(x: number, y: number, z: number): this;
     /**
      * Updates the current Vector3 with the maximal coordinate values between its and the given coordinates.
      * Example Playground https://playground.babylonjs.com/#R1F8YU#28
@@ -853,7 +868,7 @@ export declare class Vector3 {
      * @param z defines the z coordinate of the operand
      * @returns the current updated Vector3
      */
-    maximizeInPlaceFromFloats(x: number, y: number, z: number): Vector3;
+    maximizeInPlaceFromFloats(x: number, y: number, z: number): this;
     /**
      * Due to float precision, scale of a mesh could be uniform but float values are off by a small fraction
      * Check if is non uniform within a certain amount of decimal places to account for this
@@ -870,13 +885,13 @@ export declare class Vector3 {
      * Example Playground https://playground.babylonjs.com/#R1F8YU#22
      * @returns a new Vector3
      */
-    floor(): Vector3;
+    floor(): this;
     /**
      * Gets a new Vector3 from current Vector3 fractional values
      * Example Playground https://playground.babylonjs.com/#R1F8YU#23
      * @returns a new Vector3
      */
-    fract(): Vector3;
+    fract(): this;
     /**
      * Gets the length of the Vector3
      * Example Playground https://playground.babylonjs.com/#R1F8YU#25
@@ -900,7 +915,7 @@ export declare class Vector3 {
      * Example Playground https://playground.babylonjs.com/#R1F8YU#122
      * @returns the current updated Vector3
      */
-    normalize(): Vector3;
+    normalize(): this;
     /**
      * Reorders the x y z properties of the vector in place
      * Example Playground https://playground.babylonjs.com/#R1F8YU#44
@@ -915,7 +930,7 @@ export declare class Vector3 {
      * @param result vector to store the result
      * @returns the resulting vector
      */
-    rotateByQuaternionToRef(quaternion: Quaternion, result: Vector3): Vector3;
+    rotateByQuaternionToRef<T extends Vector3>(quaternion: Quaternion, result: T): T;
     /**
      * Rotates a vector around a given point
      * Example Playground https://playground.babylonjs.com/#R1F8YU#46
@@ -924,7 +939,7 @@ export declare class Vector3 {
      * @param result vector to store the result
      * @returns the resulting vector
      */
-    rotateByQuaternionAroundPointToRef(quaternion: Quaternion, point: Vector3, result: Vector3): Vector3;
+    rotateByQuaternionAroundPointToRef<T extends Vector3>(quaternion: Quaternion, point: Vector3, result: T): T;
     /**
      * Returns a new Vector3 as the cross product of the current vector and the "other" one
      * The cross product is then orthogonal to both current and "other"
@@ -932,7 +947,7 @@ export declare class Vector3 {
      * @param other defines the right operand
      * @returns the cross product
      */
-    cross(other: Vector3): Vector3;
+    cross(other: Vector3): this;
     /**
      * Normalize the current Vector3 with the given input length.
      * Please note that this is an in place operation.
@@ -940,33 +955,33 @@ export declare class Vector3 {
      * @param len the length of the vector
      * @returns the current updated Vector3
      */
-    normalizeFromLength(len: number): Vector3;
+    normalizeFromLength(len: number): this;
     /**
      * Normalize the current Vector3 to a new vector
      * Example Playground https://playground.babylonjs.com/#R1F8YU#124
      * @returns the new Vector3
      */
-    normalizeToNew(): Vector3;
+    normalizeToNew(): this;
     /**
      * Normalize the current Vector3 to the reference
      * Example Playground https://playground.babylonjs.com/#R1F8YU#125
      * @param reference define the Vector3 to update
      * @returns the updated Vector3
      */
-    normalizeToRef(reference: Vector3): Vector3;
+    normalizeToRef<T extends Vector3>(reference: T): T;
     /**
      * Creates a new Vector3 copied from the current Vector3
      * Example Playground https://playground.babylonjs.com/#R1F8YU#11
      * @returns the new Vector3
      */
-    clone(): Vector3;
+    clone(): this;
     /**
      * Copies the given vector coordinates to the current Vector3 ones
      * Example Playground https://playground.babylonjs.com/#R1F8YU#12
      * @param source defines the source Vector3
      * @returns the current updated Vector3
      */
-    copyFrom(source: DeepImmutable<Vector3>): Vector3;
+    copyFrom(source: DeepImmutable<Vector3>): this;
     /**
      * Copies the given floats to the current Vector3 coordinates
      * Example Playground https://playground.babylonjs.com/#R1F8YU#13
@@ -975,7 +990,7 @@ export declare class Vector3 {
      * @param z defines the z coordinate of the operand
      * @returns the current updated Vector3
      */
-    copyFromFloats(x: number, y: number, z: number): Vector3;
+    copyFromFloats(x: number, y: number, z: number): this;
     /**
      * Copies the given floats to the current Vector3 coordinates
      * Example Playground https://playground.babylonjs.com/#R1F8YU#58
@@ -984,14 +999,14 @@ export declare class Vector3 {
      * @param z defines the z coordinate of the operand
      * @returns the current updated Vector3
      */
-    set(x: number, y: number, z: number): Vector3;
+    set(x: number, y: number, z: number): this;
     /**
      * Copies the given float to the current Vector3 coordinates
      * Example Playground https://playground.babylonjs.com/#R1F8YU#59
      * @param v defines the x, y and z coordinates of the operand
      * @returns the current updated Vector3
      */
-    setAll(v: number): Vector3;
+    setAll(v: number): this;
     /**
      * Get the clip factor between two vectors
      * Example Playground https://playground.babylonjs.com/#R1F8YU#126
@@ -1029,7 +1044,7 @@ export declare class Vector3 {
      * @param ref the vector3 to store the result
      * @returns ref in the form (pitch, yaw, 0)
      */
-    static PitchYawRollToMoveBetweenPointsToRef(start: Vector3, target: Vector3, ref: Vector3): Vector3;
+    static PitchYawRollToMoveBetweenPointsToRef<T extends Vector3>(start: Vector3, target: Vector3, ref: T): T;
     /**
      * Gets the rotation that aligns the roll axis (Y) to the line joining the start point to the target point
      * Example PG https://playground.babylonjs.com/#R1F8YU#188
@@ -1049,7 +1064,7 @@ export declare class Vector3 {
      * @param slerp amount (will be clamped between 0 and 1)
      * @param result The slerped vector
      */
-    static SlerpToRef(vector0: Vector3, vector1: Vector3, slerp: number, result: Vector3): void;
+    static SlerpToRef<T extends Vector3 = Vector3>(vector0: Vector3, vector1: Vector3, slerp: number, result: T): T;
     /**
      * Smooth interpolation between two vectors using Slerp
      * Example Playground https://playground.babylonjs.com/#R1F8YU#110
@@ -1059,7 +1074,7 @@ export declare class Vector3 {
      * @param lerpTime total interpolation time
      * @param result the smoothed vector
      */
-    static SmoothToRef(source: Vector3, goal: Vector3, deltaTime: number, lerpTime: number, result: Vector3): void;
+    static SmoothToRef<T extends Vector3 = Vector3>(source: Vector3, goal: Vector3, deltaTime: number, lerpTime: number, result: T): T;
     /**
      * Returns a new Vector3 set from the index "offset" of the given array
      * Example Playground https://playground.babylonjs.com/#R1F8YU#83
@@ -1082,8 +1097,9 @@ export declare class Vector3 {
      * @param array defines the source array
      * @param offset defines the offset in the source array
      * @param result defines the Vector3 where to store the result
+     * @returns result input
      */
-    static FromArrayToRef(array: DeepImmutable<ArrayLike<number>>, offset: number, result: Vector3): void;
+    static FromArrayToRef<T extends Vector3>(array: DeepImmutable<ArrayLike<number>>, offset: number, result: T): T;
     /**
      * Sets the given vector "result" with the element values from the index "offset" of the given Float32Array
      * @param array defines the source array
@@ -1091,7 +1107,7 @@ export declare class Vector3 {
      * @param result defines the Vector3 where to store the result
      * @deprecated Please use FromArrayToRef instead.
      */
-    static FromFloatArrayToRef(array: DeepImmutable<Float32Array>, offset: number, result: Vector3): void;
+    static FromFloatArrayToRef<T extends Vector3>(array: DeepImmutable<Float32Array>, offset: number, result: T): T;
     /**
      * Sets the given vector "result" with the given floats.
      * Example Playground https://playground.babylonjs.com/#R1F8YU#85
@@ -1100,7 +1116,7 @@ export declare class Vector3 {
      * @param z defines the z coordinate of the source
      * @param result defines the Vector3 where to store the result
      */
-    static FromFloatsToRef(x: number, y: number, z: number, result: Vector3): void;
+    static FromFloatsToRef<T extends Vector3 = Vector3>(x: number, y: number, z: number, result: T): T;
     /**
      * Returns a new Vector3 set to (0.0, 0.0, 0.0)
      * @returns a new empty Vector3
@@ -1185,7 +1201,7 @@ export declare class Vector3 {
      * @param transformation defines the transformation matrix
      * @returns the transformed Vector3
      */
-    static TransformCoordinates(vector: DeepImmutable<Vector3>, transformation: DeepImmutable<Matrix>): Vector3;
+    static TransformCoordinates<T extends Vector3>(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)
@@ -1193,8 +1209,9 @@ export declare class Vector3 {
      * @param vector defines the Vector3 to transform
      * @param transformation defines the transformation matrix
      * @param result defines the Vector3 where to store the result
+     * @returns result input
      */
-    static TransformCoordinatesToRef(vector: DeepImmutable<Vector3>, transformation: DeepImmutable<Matrix>, result: Vector3): void;
+    static TransformCoordinatesToRef<T extends Vector3>(vector: DeepImmutable<Vector3>, transformation: DeepImmutable<Matrix>, result: T): T;
     /**
      * Sets the given vector "result" coordinates with the result of the transformation by the given matrix of the given floats (x, y, z)
      * This method computes transformed coordinates only, not transformed direction vectors
@@ -1204,8 +1221,9 @@ export declare class Vector3 {
      * @param z define the z coordinate of the source vector
      * @param transformation defines the transformation matrix
      * @param result defines the Vector3 where to store the result
+     * @returns result input
      */
-    static TransformCoordinatesFromFloatsToRef(x: number, y: number, z: number, transformation: DeepImmutable<Matrix>, result: Vector3): void;
+    static TransformCoordinatesFromFloatsToRef<T extends Vector3>(x: number, y: number, z: number, transformation: DeepImmutable<Matrix>, result: T): T;
     /**
      * Returns a new Vector3 set with the result of the normal transformation by the given matrix of the given vector
      * This methods computes transformed normalized direction vectors only (ie. it does not apply translation)
@@ -1222,8 +1240,9 @@ export declare class Vector3 {
      * @param vector defines the Vector3 to transform
      * @param transformation defines the transformation matrix
      * @param result defines the Vector3 where to store the result
+     * @returns result input
      */
-    static TransformNormalToRef(vector: DeepImmutable<Vector3>, transformation: DeepImmutable<Matrix>, result: Vector3): void;
+    static TransformNormalToRef<T extends Vector3>(vector: DeepImmutable<Vector3>, transformation: DeepImmutable<Matrix>, result: T): T;
     /**
      * Sets the given vector "result" with the result of the normal transformation by the given matrix of the given floats (x, y, z)
      * This methods computes transformed normalized direction vectors only (ie. it does not apply translation)
@@ -1233,8 +1252,9 @@ export declare class Vector3 {
      * @param z define the z coordinate of the source vector
      * @param transformation defines the transformation matrix
      * @param result defines the Vector3 where to store the result
+     * @returns result input
      */
-    static TransformNormalFromFloatsToRef(x: number, y: number, z: number, transformation: DeepImmutable<Matrix>, result: Vector3): void;
+    static TransformNormalFromFloatsToRef<T extends Vector3>(x: number, y: number, z: number, transformation: DeepImmutable<Matrix>, result: T): T;
     /**
      * Returns a new Vector3 located for "amount" on the CatmullRom interpolation spline defined by the vectors "value1", "value2", "value3", "value4"
      * Example Playground https://playground.babylonjs.com/#R1F8YU#69
@@ -1245,7 +1265,7 @@ export declare class Vector3 {
      * @param amount defines the amount on the spline to use
      * @returns the new Vector3
      */
-    static CatmullRom(value1: DeepImmutable<Vector3>, value2: DeepImmutable<Vector3>, value3: DeepImmutable<Vector3>, value4: DeepImmutable<Vector3>, amount: number): Vector3;
+    static CatmullRom<T extends Vector3>(value1: DeepImmutable<T>, value2: DeepImmutable<Vector3>, value3: DeepImmutable<Vector3>, value4: DeepImmutable<Vector3>, amount: number): T;
     /**
      * Returns a new Vector3 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
@@ -1256,7 +1276,7 @@ export declare class Vector3 {
      * @param max defines the upper range value
      * @returns the new Vector3
      */
-    static Clamp(value: DeepImmutable<Vector3>, min: DeepImmutable<Vector3>, max: DeepImmutable<Vector3>): Vector3;
+    static Clamp<T extends Vector3>(value: DeepImmutable<T>, min: DeepImmutable<Vector3>, max: DeepImmutable<Vector3>): 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
@@ -1266,8 +1286,9 @@ export declare class Vector3 {
      * @param min defines the lower range value
      * @param max defines the upper range value
      * @param result defines the Vector3 where to store the result
+     * @returns result input
      */
-    static ClampToRef(value: DeepImmutable<Vector3>, min: DeepImmutable<Vector3>, max: DeepImmutable<Vector3>, result: Vector3): void;
+    static ClampToRef<T extends Vector3>(value: DeepImmutable<Vector3>, min: DeepImmutable<Vector3>, max: DeepImmutable<Vector3>, result: T): T;
     /**
      * Checks if a given vector is inside a specific range
      * Example Playground https://playground.babylonjs.com/#R1F8YU#75
@@ -1286,7 +1307,7 @@ export declare class Vector3 {
      * @param amount defines the amount on the interpolation spline (between 0 and 1)
      * @returns the new Vector3
      */
-    static Hermite(value1: DeepImmutable<Vector3>, tangent1: DeepImmutable<Vector3>, value2: DeepImmutable<Vector3>, tangent2: DeepImmutable<Vector3>, amount: number): Vector3;
+    static Hermite<T extends Vector3>(value1: DeepImmutable<T>, tangent1: DeepImmutable<Vector3>, value2: DeepImmutable<Vector3>, tangent2: DeepImmutable<Vector3>, amount: number): T;
     /**
      * Returns a new Vector3 which is the 1st derivative of the Hermite spline defined by the vectors "value1", "value2", "tangent1", "tangent2".
      * Example Playground https://playground.babylonjs.com/#R1F8YU#90
@@ -1297,7 +1318,7 @@ export declare class Vector3 {
      * @param time define where the derivative must be done
      * @returns 1st derivative
      */
-    static Hermite1stDerivative(value1: DeepImmutable<Vector3>, tangent1: DeepImmutable<Vector3>, value2: DeepImmutable<Vector3>, tangent2: DeepImmutable<Vector3>, time: number): Vector3;
+    static Hermite1stDerivative<T extends Vector3>(value1: DeepImmutable<T>, tangent1: DeepImmutable<Vector3>, value2: DeepImmutable<Vector3>, tangent2: DeepImmutable<Vector3>, time: number): T;
     /**
      * Update a Vector3 with the 1st derivative of the Hermite spline defined by the vectors "value1", "value2", "tangent1", "tangent2".
      * Example Playground https://playground.babylonjs.com/#R1F8YU#91
@@ -1307,8 +1328,9 @@ export declare class Vector3 {
      * @param tangent2 defines the second tangent
      * @param time define where the derivative must be done
      * @param result define where to store the derivative
+     * @returns result input
      */
-    static Hermite1stDerivativeToRef(value1: DeepImmutable<Vector3>, tangent1: DeepImmutable<Vector3>, value2: DeepImmutable<Vector3>, tangent2: DeepImmutable<Vector3>, time: number, result: Vector3): void;
+    static Hermite1stDerivativeToRef<T extends Vector3>(value1: DeepImmutable<Vector3>, tangent1: DeepImmutable<Vector3>, value2: DeepImmutable<Vector3>, tangent2: DeepImmutable<Vector3>, time: number, result: T): T;
     /**
      * Returns a new Vector3 located for "amount" (float) on the linear interpolation between the vectors "start" and "end"
      * Example Playground https://playground.babylonjs.com/#R1F8YU#95
@@ -1317,7 +1339,7 @@ export declare class Vector3 {
      * @param amount max defines amount between both (between 0 and 1)
      * @returns the new Vector3
      */
-    static Lerp(start: DeepImmutable<Vector3>, end: DeepImmutable<Vector3>, amount: number): Vector3;
+    static Lerp<T extends Vector3>(start: DeepImmutable<T>, end: DeepImmutable<Vector3>, amount: number): T;
     /**
      * Sets the given vector "result" with the result of the linear interpolation from the vector "start" for "amount" to the vector "end"
      * Example Playground https://playground.babylonjs.com/#R1F8YU#93
@@ -1325,8 +1347,9 @@ export declare class Vector3 {
      * @param end defines the end value
      * @param amount max defines amount between both (between 0 and 1)
      * @param result defines the Vector3 where to store the result
+     * @returns result input
      */
-    static LerpToRef(start: DeepImmutable<Vector3>, end: DeepImmutable<Vector3>, amount: number, result: Vector3): void;
+    static LerpToRef<T extends Vector3>(start: DeepImmutable<Vector3>, end: DeepImmutable<Vector3>, amount: number, result: T): T;
     /**
      * Returns the dot product (float) between the vectors "left" and "right"
      * Example Playground https://playground.babylonjs.com/#R1F8YU#82
@@ -1343,7 +1366,7 @@ export declare class Vector3 {
      * @param right defines the right operand
      * @returns the cross product
      */
-    static Cross(left: DeepImmutable<Vector3>, right: DeepImmutable<Vector3>): Vector3;
+    static Cross<T extends Vector3>(left: DeepImmutable<T>, right: DeepImmutable<Vector3>): T;
     /**
      * Sets the given vector "result" with the cross product of "left" and "right"
      * The cross product is then orthogonal to both "left" and "right"
@@ -1351,8 +1374,9 @@ export declare class Vector3 {
      * @param left defines the left operand
      * @param right defines the right operand
      * @param result defines the Vector3 where to store the result
+     * @returns result input
      */
-    static CrossToRef(left: DeepImmutable<Vector3>, right: DeepImmutable<Vector3>, result: Vector3): void;
+    static CrossToRef<T extends Vector3>(left: DeepImmutable<Vector3>, right: DeepImmutable<Vector3>, result: T): T;
     /**
      * Returns a new Vector3 as the normalization of the given vector
      * Example Playground https://playground.babylonjs.com/#R1F8YU#98
@@ -1365,8 +1389,9 @@ export declare class Vector3 {
      * Example Playground https://playground.babylonjs.com/#R1F8YU#98
      * @param vector defines the Vector3 to normalize
      * @param result defines the Vector3 where to store the result
+     * @returns result input
      */
-    static NormalizeToRef(vector: DeepImmutable<Vector3>, result: Vector3): void;
+    static NormalizeToRef<T extends Vector3>(vector: DeepImmutable<Vector3>, result: T): T;
     /**
      * Project a Vector3 onto screen space
      * Example Playground https://playground.babylonjs.com/#R1F8YU#101
@@ -1376,7 +1401,7 @@ export declare class Vector3 {
      * @param viewport defines the screen viewport to use
      * @returns the new Vector3
      */
-    static Project(vector: DeepImmutable<Vector3>, world: DeepImmutable<Matrix>, transform: DeepImmutable<Matrix>, viewport: DeepImmutable<Viewport>): Vector3;
+    static Project<T extends Vector3>(vector: DeepImmutable<T>, world: DeepImmutable<Matrix>, transform: DeepImmutable<Matrix>, viewport: DeepImmutable<Viewport>): T;
     /**
      * Project a Vector3 onto screen space to reference
      * Example Playground https://playground.babylonjs.com/#R1F8YU#102
@@ -1385,13 +1410,13 @@ export declare class Vector3 {
      * @param transform defines the transform (view x projection) matrix to use
      * @param viewport defines the screen viewport to use
      * @param result the vector in which the screen space will be stored
-     * @returns the new Vector3
+     * @returns result input
      */
-    static ProjectToRef(vector: DeepImmutable<Vector3>, world: DeepImmutable<Matrix>, transform: DeepImmutable<Matrix>, viewport: DeepImmutable<Viewport>, result: DeepImmutable<Vector3>): Vector3;
+    static ProjectToRef<T extends Vector3>(vector: DeepImmutable<Vector3>, world: DeepImmutable<Matrix>, transform: DeepImmutable<Matrix>, viewport: DeepImmutable<Viewport>, result: T): T;
     /**
      * @internal
      */
-    static _UnprojectFromInvertedMatrixToRef(source: DeepImmutable<Vector3>, matrix: DeepImmutable<Matrix>, result: Vector3): void;
+    static _UnprojectFromInvertedMatrixToRef<T extends Vector3>(source: DeepImmutable<Vector3>, matrix: DeepImmutable<Matrix>, result: T): T;
     /**
      * Unproject from screen space to object space
      * Example Playground https://playground.babylonjs.com/#R1F8YU#121
@@ -1402,7 +1427,7 @@ export declare class Vector3 {
      * @param transform defines the transform (view x projection) matrix to use
      * @returns the new Vector3
      */
-    static UnprojectFromTransform(source: Vector3, viewportWidth: number, viewportHeight: number, world: DeepImmutable<Matrix>, transform: DeepImmutable<Matrix>): Vector3;
+    static UnprojectFromTransform<T extends Vector3>(source: DeepImmutable<T>, viewportWidth: number, viewportHeight: number, world: DeepImmutable<Matrix>, transform: DeepImmutable<Matrix>): T;
     /**
      * Unproject from screen space to object space
      * Example Playground https://playground.babylonjs.com/#R1F8YU#117
@@ -1414,7 +1439,7 @@ export declare class Vector3 {
      * @param projection defines the projection matrix to use
      * @returns the new Vector3
      */
-    static Unproject(source: DeepImmutable<Vector3>, viewportWidth: number, viewportHeight: number, world: DeepImmutable<Matrix>, view: DeepImmutable<Matrix>, projection: DeepImmutable<Matrix>): Vector3;
+    static Unproject<T extends Vector3>(source: DeepImmutable<T>, viewportWidth: number, viewportHeight: number, world: DeepImmutable<Matrix>, view: DeepImmutable<Matrix>, projection: DeepImmutable<Matrix>): T;
     /**
      * Unproject from screen space to object space
      * Example Playground https://playground.babylonjs.com/#R1F8YU#119
@@ -1425,8 +1450,9 @@ export declare class Vector3 {
      * @param view defines the view matrix to use
      * @param projection defines the projection matrix to use
      * @param result defines the Vector3 where to store the result
+     * @returns result input
      */
-    static UnprojectToRef(source: DeepImmutable<Vector3>, viewportWidth: number, viewportHeight: number, world: DeepImmutable<Matrix>, view: DeepImmutable<Matrix>, projection: DeepImmutable<Matrix>, result: Vector3): void;
+    static UnprojectToRef<T extends Vector3>(source: DeepImmutable<Vector3>, viewportWidth: number, viewportHeight: number, world: DeepImmutable<Matrix>, view: DeepImmutable<Matrix>, projection: DeepImmutable<Matrix>, result: T): T;
     /**
      * Unproject from screen space to object space
      * Example Playground https://playground.babylonjs.com/#R1F8YU#120
@@ -1439,8 +1465,9 @@ export declare class Vector3 {
      * @param view defines the view matrix to use
      * @param projection defines the projection matrix to use
      * @param result defines the Vector3 where to store the result
+     * @returns result input
      */
-    static UnprojectFloatsToRef(sourceX: float, sourceY: float, sourceZ: float, viewportWidth: number, viewportHeight: number, world: DeepImmutable<Matrix>, view: DeepImmutable<Matrix>, projection: DeepImmutable<Matrix>, result: Vector3): void;
+    static UnprojectFloatsToRef<T extends Vector3>(sourceX: float, sourceY: float, sourceZ: float, viewportWidth: number, viewportHeight: number, world: DeepImmutable<Matrix>, view: DeepImmutable<Matrix>, projection: DeepImmutable<Matrix>, result: T): T;
     /**
      * Gets the minimal coordinate values between two Vector3
      * Example Playground https://playground.babylonjs.com/#R1F8YU#97
@@ -1448,7 +1475,7 @@ export declare class Vector3 {
      * @param right defines the second operand
      * @returns the new Vector3
      */
-    static Minimize(left: DeepImmutable<Vector3>, right: DeepImmutable<Vector3>): Vector3;
+    static Minimize<T extends Vector3>(left: DeepImmutable<T>, right: DeepImmutable<Vector3>): T;
     /**
      * Gets the maximal coordinate values between two Vector3
      * Example Playground https://playground.babylonjs.com/#R1F8YU#96
@@ -1456,7 +1483,7 @@ export declare class Vector3 {
      * @param right defines the second operand
      * @returns the new Vector3
      */
-    static Maximize(left: DeepImmutable<Vector3>, right: DeepImmutable<Vector3>): Vector3;
+    static Maximize<T extends Vector3>(left: DeepImmutable<T>, right: DeepImmutable<Vector3>): T;
     /**
      * Returns the distance between the vectors "value1" and "value2"
      * Example Playground https://playground.babylonjs.com/#R1F8YU#81
@@ -1503,7 +1530,7 @@ export declare class Vector3 {
      * @param ref defines third vector
      * @returns ref
      */
-    static CenterToRef(value1: DeepImmutable<Vector3>, value2: DeepImmutable<Vector3>, ref: DeepImmutable<Vector3>): Vector3;
+    static CenterToRef<T extends Vector3>(value1: DeepImmutable<Vector3>, value2: DeepImmutable<Vector3>, ref: T): T;
     /**
      * Given three orthogonal normalized left-handed oriented Vector3 axis in space (target system),
      * RotationFromAxis() returns the rotation Euler angles (ex : rotation.x, rotation.y, rotation.z) to apply
@@ -1516,7 +1543,7 @@ export declare class Vector3 {
      * @returns a new Vector3
      * @see https://doc.babylonjs.com/divingDeeper/mesh/transforms/center_origin/target_align
      */
-    static RotationFromAxis(axis1: DeepImmutable<Vector3>, axis2: DeepImmutable<Vector3>, axis3: DeepImmutable<Vector3>): Vector3;
+    static RotationFromAxis<T extends Vector3>(axis1: DeepImmutable<T>, axis2: DeepImmutable<Vector3>, axis3: DeepImmutable<Vector3>): T;
     /**
      * The same than RotationFromAxis but updates the given ref Vector3 parameter instead of returning a new Vector3
      * Example Playground https://playground.babylonjs.com/#R1F8YU#107
@@ -1524,8 +1551,9 @@ export declare class Vector3 {
      * @param axis2 defines the second axis
      * @param axis3 defines the third axis
      * @param ref defines the Vector3 where to store the result
+     * @returns result input
      */
-    static RotationFromAxisToRef(axis1: DeepImmutable<Vector3>, axis2: DeepImmutable<Vector3>, axis3: DeepImmutable<Vector3>, ref: Vector3): void;
+    static RotationFromAxisToRef<T extends Vector3>(axis1: DeepImmutable<Vector3>, axis2: DeepImmutable<Vector3>, axis3: DeepImmutable<Vector3>, ref: T): T;
 }
 /**
  * Vector4 class created for EulerAngle class conversion to Quaternion
@@ -1549,13 +1577,13 @@ export declare class Vector4 {
      */
     constructor(
     /** x value of the vector */
-    x: number, 
+    x?: number, 
     /** y value of the vector */
-    y: number, 
+    y?: number, 
     /** z value of the vector */
-    z: number, 
+    z?: number, 
     /** w value of the vector */
-    w: number);
+    w?: number);
     /**
      * Returns the string with the Vector4 coordinates.
      * @returns a string containing all the vector values
@@ -1582,52 +1610,52 @@ export declare class Vector4 {
      * @param index index of the array to start at (default: 0)
      * @returns the Vector4.
      */
-    toArray(array: FloatArray, index?: number): Vector4;
+    toArray(array: FloatArray, index?: number): this;
     /**
      * Update the current vector from an array
      * @param array defines the destination array
      * @param index defines the offset in the destination array
      * @returns the current Vector3
      */
-    fromArray(array: FloatArray, index?: number): Vector4;
+    fromArray(array: FloatArray, index?: number): this;
     /**
      * Adds the given vector to the current Vector4.
      * @param otherVector the vector to add
      * @returns the updated Vector4.
      */
-    addInPlace(otherVector: DeepImmutable<Vector4>): Vector4;
+    addInPlace(otherVector: DeepImmutable<Vector4>): 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
      * @returns the resulting vector
      */
-    add(otherVector: DeepImmutable<Vector4>): Vector4;
+    add(otherVector: DeepImmutable<Vector4>): this;
     /**
      * Updates the given vector "result" with the result of the addition of the current Vector4 and the given one.
      * @param otherVector the vector to add
      * @param result the vector to store the result
-     * @returns the current Vector4.
+     * @returns result input
      */
-    addToRef(otherVector: DeepImmutable<Vector4>, result: Vector4): Vector4;
+    addToRef<T extends Vector4>(otherVector: DeepImmutable<Vector4>, result: T): T;
     /**
      * Subtract in place the given vector from the current Vector4.
      * @param otherVector the vector to subtract
      * @returns the updated Vector4.
      */
-    subtractInPlace(otherVector: DeepImmutable<Vector4>): Vector4;
+    subtractInPlace(otherVector: DeepImmutable<Vector4>): this;
     /**
      * Returns a new Vector4 with the result of the subtraction of the given vector from the current Vector4.
      * @param otherVector the vector to add
      * @returns the new vector with the result
      */
-    subtract(otherVector: DeepImmutable<Vector4>): Vector4;
+    subtract(otherVector: DeepImmutable<Vector4>): this;
     /**
      * Sets the given vector "result" with the result of the subtraction of the given vector from the current Vector4.
      * @param otherVector the vector to subtract
      * @param result the vector to store the result
-     * @returns the current Vector4.
+     * @returns result input
      */
-    subtractToRef(otherVector: DeepImmutable<Vector4>, result: Vector4): Vector4;
+    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.
      */
@@ -1639,7 +1667,7 @@ export declare class Vector4 {
      * @param w value to subtract
      * @returns new vector containing the result
      */
-    subtractFromFloats(x: number, y: number, z: number, w: number): Vector4;
+    subtractFromFloats(x: number, y: number, z: number, w: number): this;
     /**
      * Sets the given vector "result" set with the result of the subtraction of the given floats from the current Vector4 coordinates.
      * @param x value to subtract
@@ -1647,51 +1675,51 @@ export declare class Vector4 {
      * @param z value to subtract
      * @param w value to subtract
      * @param result the vector to store the result in
-     * @returns the current Vector4.
+     * @returns result input
      */
-    subtractFromFloatsToRef(x: number, y: number, z: number, w: number, result: Vector4): Vector4;
+    subtractFromFloatsToRef<T extends Vector4>(x: number, y: number, z: number, w: number, result: T): T;
     /**
      * Returns a new Vector4 set with the current Vector4 negated coordinates.
      * @returns a new vector with the negated values
      */
-    negate(): Vector4;
+    negate(): this;
     /**
      * Negate this vector in place
      * @returns this
      */
-    negateInPlace(): Vector4;
+    negateInPlace(): this;
     /**
      * Negate the current Vector4 and stores the result in the given vector "result" coordinates
      * @param result defines the Vector3 object where to store the result
      * @returns the result
      */
-    negateToRef(result: Vector4): Vector4;
+    negateToRef<T extends Vector4>(result: T): T;
     /**
      * Multiplies the current Vector4 coordinates by scale (float).
      * @param scale the number to scale with
      * @returns the updated Vector4.
      */
-    scaleInPlace(scale: number): Vector4;
+    scaleInPlace(scale: number): this;
     /**
      * Returns a new Vector4 set with the current Vector4 coordinates multiplied by scale (float).
      * @param scale the number to scale with
      * @returns a new vector with the result
      */
-    scale(scale: number): Vector4;
+    scale(scale: number): this;
     /**
      * Sets the given vector "result" with the current Vector4 coordinates multiplied by scale (float).
      * @param scale the number to scale with
      * @param result a vector to store the result in
-     * @returns the current Vector4.
+     * @returns result input
      */
-    scaleToRef(scale: number, result: Vector4): Vector4;
+    scaleToRef<T extends Vector4>(scale: number, result: T): T;
     /**
      * Scale the current Vector4 values by a factor and add the result to a given Vector4
      * @param scale defines the scale factor
      * @param result defines the Vector4 object where to store the result
-     * @returns the unmodified current Vector4
+     * @returns result input
      */
-    scaleAndAddToRef(scale: number, result: Vector4): Vector4;
+    scaleAndAddToRef<T extends Vector4>(scale: number, result: T): T;
     /**
      * Boolean : True if the current Vector4 coordinates are stricly equal to the given ones.
      * @param otherVector the vector to compare against
@@ -1719,20 +1747,20 @@ export declare class Vector4 {
      * @param otherVector vector to multiple with
      * @returns the updated Vector4.
      */
-    multiplyInPlace(otherVector: Vector4): Vector4;
+    multiplyInPlace(otherVector: 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
      * @returns resulting new vector
      */
-    multiply(otherVector: DeepImmutable<Vector4>): Vector4;
+    multiply(otherVector: DeepImmutable<Vector4>): this;
     /**
      * Updates the given vector "result" with the multiplication result of the current Vector4 and the given one.
      * @param otherVector vector to multiple with
      * @param result vector to store the result
-     * @returns the current Vector4.
+     * @returns result input
      */
-    multiplyToRef(otherVector: DeepImmutable<Vector4>, result: Vector4): Vector4;
+    multiplyToRef<T extends Vector4>(otherVector: DeepImmutable<Vector4>, result: T): T;
     /**
      * Returns a new Vector4 set with the multiplication result of the given floats and the current Vector4 coordinates.
      * @param x x value multiply with
@@ -1741,48 +1769,48 @@ export declare class Vector4 {
      * @param w w value multiply with
      * @returns resulting new vector
      */
-    multiplyByFloats(x: number, y: number, z: number, w: number): Vector4;
+    multiplyByFloats(x: number, y: number, z: number, w: number): this;
     /**
      * Returns a new Vector4 set with the division result of the current Vector4 by the given one.
      * @param otherVector vector to devide with
      * @returns resulting new vector
      */
-    divide(otherVector: DeepImmutable<Vector4>): Vector4;
+    divide(otherVector: DeepImmutable<Vector4>): this;
     /**
      * Updates the given vector "result" with the division result of the current Vector4 by the given one.
      * @param otherVector vector to devide with
      * @param result vector to store the result
-     * @returns the current Vector4.
+     * @returns result input
      */
-    divideToRef(otherVector: DeepImmutable<Vector4>, result: Vector4): Vector4;
+    divideToRef<T extends Vector4>(otherVector: DeepImmutable<Vector4>, result: T): T;
     /**
      * Divides the current Vector3 coordinates by the given ones.
      * @param otherVector vector to devide with
      * @returns the updated Vector3.
      */
-    divideInPlace(otherVector: DeepImmutable<Vector4>): Vector4;
+    divideInPlace(otherVector: DeepImmutable<Vector4>): this;
     /**
      * Updates the Vector4 coordinates with the minimum values between its own and the given vector ones
      * @param other defines the second operand
      * @returns the current updated Vector4
      */
-    minimizeInPlace(other: DeepImmutable<Vector4>): Vector4;
+    minimizeInPlace(other: DeepImmutable<Vector4>): this;
     /**
      * Updates the Vector4 coordinates with the maximum values between its own and the given vector ones
      * @param other defines the second operand
      * @returns the current updated Vector4
      */
-    maximizeInPlace(other: DeepImmutable<Vector4>): Vector4;
+    maximizeInPlace(other: DeepImmutable<Vector4>): this;
     /**
      * Gets a new Vector4 from current Vector4 floored values
      * @returns a new Vector4
      */
-    floor(): Vector4;
+    floor(): this;
     /**
      * Gets a new Vector4 from current Vector4 fractional values
      * @returns a new Vector4
      */
-    fract(): Vector4;
+    fract(): this;
     /**
      * Returns the Vector4 length (float).
      * @returns the length
@@ -1797,7 +1825,7 @@ export declare class Vector4 {
      * Normalizes in place the Vector4.
      * @returns the updated Vector4.
      */
-    normalize(): Vector4;
+    normalize(): this;
     /**
      * Returns a new Vector3 from the Vector4 (x, y, z) coordinates.
      * @returns this converted to a new vector3
@@ -1807,13 +1835,13 @@ export declare class Vector4 {
      * Returns a new Vector4 copied from the current one.
      * @returns the new cloned vector
      */
-    clone(): Vector4;
+    clone(): this;
     /**
      * Updates the current Vector4 with the given one coordinates.
      * @param source the source vector to copy from
      * @returns the updated Vector4.
      */
-    copyFrom(source: DeepImmutable<Vector4>): Vector4;
+    copyFrom(source: DeepImmutable<Vector4>): this;
     /**
      * Updates the current Vector4 coordinates with the given floats.
      * @param x float to copy from
@@ -1822,7 +1850,7 @@ export declare class Vector4 {
      * @param w float to copy from
      * @returns the updated Vector4.
      */
-    copyFromFloats(x: number, y: number, z: number, w: number): Vector4;
+    copyFromFloats(x: number, y: number, z: number, w: number): this;
     /**
      * Updates the current Vector4 coordinates with the given floats.
      * @param x float to set from
@@ -1831,13 +1859,13 @@ export declare class Vector4 {
      * @param w float to set from
      * @returns the updated Vector4.
      */
-    set(x: number, y: number, z: number, w: number): Vector4;
+    set(x: number, y: number, z: number, w: number): this;
     /**
      * Copies the given float to the current Vector3 coordinates
      * @param v defines the x, y, z and w coordinates of the operand
      * @returns the current updated Vector3
      */
-    setAll(v: number): Vector4;
+    setAll(v: number): this;
     /**
      * Returns a new Vector4 set from the starting index of the given array.
      * @param array the array to pull values from
@@ -1850,15 +1878,17 @@ export declare class Vector4 {
      * @param array the array to pull values from
      * @param offset the offset into the array to start at
      * @param result the vector to store the result in
+     * @returns result input
      */
-    static FromArrayToRef(array: DeepImmutable<ArrayLike<number>>, offset: number, result: Vector4): void;
+    static FromArrayToRef<T extends Vector4>(array: DeepImmutable<ArrayLike<number>>, offset: number, result: T): T;
     /**
      * Updates the given vector "result" from the starting index of the given Float32Array.
      * @param array the array to pull values from
      * @param offset the offset into the array to start at
      * @param result the vector to store the result in
+     * @returns result input
      */
-    static FromFloatArrayToRef(array: DeepImmutable<Float32Array>, offset: number, result: Vector4): void;
+    static FromFloatArrayToRef<T extends Vector4>(array: DeepImmutable<Float32Array>, offset: number, result: T): T;
     /**
      * Updates the given vector "result" coordinates from the given floats.
      * @param x float to set from
@@ -1866,8 +1896,9 @@ export declare class Vector4 {
      * @param z float to set from
      * @param w float to set from
      * @param result the vector to the floats in
+     * @returns result input
      */
-    static FromFloatsToRef(x: number, y: number, z: number, w: number, result: Vector4): void;
+    static FromFloatsToRef<T extends Vector4>(x: number, y: number, z: number, w: number, result: T): T;
     /**
      * Returns a new Vector4 set to (0.0, 0.0, 0.0, 0.0)
      * @returns the new vector
@@ -1892,22 +1923,23 @@ export declare class Vector4 {
      * Updates the given vector "result" from the normalization of the given one.
      * @param vector the vector to normalize
      * @param result the vector to store the result in
+     * @returns result input
      */
-    static NormalizeToRef(vector: DeepImmutable<Vector4>, result: Vector4): void;
+    static NormalizeToRef<T extends Vector4>(vector: DeepImmutable<Vector4>, result: T): T;
     /**
      * Returns a vector with the minimum values from the left and right vectors
      * @param left left vector to minimize
      * @param right right vector to minimize
      * @returns a new vector with the minimum of the left and right vector values
      */
-    static Minimize(left: DeepImmutable<Vector4>, right: DeepImmutable<Vector4>): Vector4;
+    static Minimize<T extends Vector4>(left: DeepImmutable<T>, right: DeepImmutable<Vector4>): T;
     /**
      * Returns a vector with the maximum values from the left and right vectors
      * @param left left vector to maximize
      * @param right right vector to maximize
      * @returns a new vector with the maximum of the left and right vector values
      */
-    static Maximize(left: DeepImmutable<Vector4>, right: DeepImmutable<Vector4>): Vector4;
+    static Maximize<T extends Vector4>(left: DeepImmutable<T>, right: DeepImmutable<Vector4>): T;
     /**
      * Returns the distance (float) between the vectors "value1" and "value2".
      * @param value1 value to calulate the distance between
@@ -1936,7 +1968,7 @@ export declare class Vector4 {
      * @param ref defines third vector
      * @returns ref
      */
-    static CenterToRef(value1: DeepImmutable<Vector4>, value2: DeepImmutable<Vector4>, ref: DeepImmutable<Vector4>): Vector4;
+    static CenterToRef<T extends Vector4>(value1: DeepImmutable<Vector4>, value2: DeepImmutable<Vector4>, ref: T): T;
     /**
      * Returns a new Vector4 set with the result of the transformation by the given matrix of the given vector.
      * This method computes tranformed coordinates only, not transformed direction vectors (ie. it takes translation in account)
@@ -1953,8 +1985,9 @@ export declare class Vector4 {
      * @param vector defines the Vector3 to transform
      * @param transformation defines the transformation matrix
      * @param result defines the Vector4 where to store the result
+     * @returns result input
      */
-    static TransformCoordinatesToRef(vector: DeepImmutable<Vector3>, transformation: DeepImmutable<Matrix>, result: Vector4): void;
+    static TransformCoordinatesToRef<T extends Vector4>(vector: DeepImmutable<Vector3>, transformation: DeepImmutable<Matrix>, result: T): T;
     /**
      * Sets the given vector "result" coordinates with the result of the transformation by the given matrix of the given floats (x, y, z)
      * This method computes tranformed coordinates only, not transformed direction vectors
@@ -1964,8 +1997,9 @@ export declare class Vector4 {
      * @param z define the z coordinate of the source vector
      * @param transformation defines the transformation matrix
      * @param result defines the Vector4 where to store the result
+     * @returns result input
      */
-    static TransformCoordinatesFromFloatsToRef(x: number, y: number, z: number, transformation: DeepImmutable<Matrix>, result: Vector4): void;
+    static TransformCoordinatesFromFloatsToRef<T extends Vector4>(x: number, y: number, z: number, transformation: DeepImmutable<Matrix>, result: T): T;
     /**
      * Returns a new Vector4 set with the result of the normal transformation by the given matrix of the given vector.
      * This methods computes transformed normalized direction vectors only.
@@ -1973,15 +2007,16 @@ export declare class Vector4 {
      * @param transformation the transformation matrix to apply
      * @returns the new vector
      */
-    static TransformNormal(vector: DeepImmutable<Vector4>, transformation: DeepImmutable<Matrix>): Vector4;
+    static TransformNormal<T extends Vector4>(vector: DeepImmutable<T>, transformation: DeepImmutable<Matrix>): T;
     /**
      * Sets the given vector "result" with the result of the normal transformation by the given matrix of the given vector.
      * This methods computes transformed normalized direction vectors only.
      * @param vector the vector to transform
      * @param transformation the transformation matrix to apply
      * @param result the vector to store the result in
+     * @returns result input
      */
-    static TransformNormalToRef(vector: DeepImmutable<Vector4>, transformation: DeepImmutable<Matrix>, result: Vector4): void;
+    static TransformNormalToRef<T extends Vector4>(vector: DeepImmutable<Vector4>, transformation: DeepImmutable<Matrix>, result: T): T;
     /**
      * Sets the given vector "result" with the result of the normal transformation by the given matrix of the given floats (x, y, z, w).
      * This methods computes transformed normalized direction vectors only.
@@ -1991,8 +2026,9 @@ export declare class Vector4 {
      * @param w value to transform
      * @param transformation the transformation matrix to apply
      * @param result the vector to store the results in
+     * @returns result input
      */
-    static TransformNormalFromFloatsToRef(x: number, y: number, z: number, w: number, transformation: DeepImmutable<Matrix>, result: Vector4): void;
+    static TransformNormalFromFloatsToRef<T extends Vector4>(x: number, y: number, z: number, w: number, transformation: DeepImmutable<Matrix>, result: T): T;
     /**
      * Creates a new Vector4 from a Vector3
      * @param source defines the source data
@@ -2003,6 +2039,7 @@ export declare class Vector4 {
 }
 /**
  * Class used to store quaternion data
+ * Example Playground - Overview - https://playground.babylonjs.com/#L49EJ7#100
  * @see https://en.wikipedia.org/wiki/Quaternion
  * @see https://doc.babylonjs.com/features/position,_rotation,_scaling
  */
@@ -2054,11 +2091,13 @@ export declare class Quaternion {
     getHashCode(): number;
     /**
      * Copy the quaternion to an array
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#13
      * @returns a new array populated with 4 elements from the quaternion coordinates
      */
     asArray(): number[];
     /**
      * Stores from the starting index in the given array the Quaternion successive values
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#59
      * @param array defines the array where to store the x,y,z,w components
      * @param index defines an optional index in the target array to define where to start storing values
      * @returns the current Quaternion object
@@ -2066,12 +2105,14 @@ export declare class Quaternion {
     toArray(array: FloatArray, index?: number): Quaternion;
     /**
      * Check if two quaternions are equals
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#38
      * @param otherQuaternion defines the second operand
      * @returns true if the current quaternion and the given one coordinates are strictly equals
      */
     equals(otherQuaternion: DeepImmutable<Quaternion>): boolean;
     /**
      * Gets a boolean if two quaternions are equals (using an epsilon value)
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#37
      * @param otherQuaternion defines the other quaternion
      * @param epsilon defines the minimal distance to consider equality
      * @returns true if the given quaternion coordinates are close to the current ones by a distance of epsilon.
@@ -2079,204 +2120,219 @@ export declare class Quaternion {
     equalsWithEpsilon(otherQuaternion: DeepImmutable<Quaternion>, epsilon?: number): boolean;
     /**
      * Clone the current quaternion
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#12
      * @returns a new quaternion copied from the current one
      */
-    clone(): Quaternion;
+    clone(): this;
     /**
      * Copy a quaternion to the current one
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#86
      * @param other defines the other quaternion
      * @returns the updated current quaternion
      */
-    copyFrom(other: DeepImmutable<Quaternion>): Quaternion;
+    copyFrom(other: DeepImmutable<Quaternion>): this;
     /**
      * Updates the current quaternion with the given float coordinates
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#87
      * @param x defines the x coordinate
      * @param y defines the y coordinate
      * @param z defines the z coordinate
      * @param w defines the w coordinate
      * @returns the updated current quaternion
      */
-    copyFromFloats(x: number, y: number, z: number, w: number): Quaternion;
+    copyFromFloats(x: number, y: number, z: number, w: number): this;
     /**
      * Updates the current quaternion from the given float coordinates
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#56
      * @param x defines the x coordinate
      * @param y defines the y coordinate
      * @param z defines the z coordinate
      * @param w defines the w coordinate
      * @returns the updated current quaternion
      */
-    set(x: number, y: number, z: number, w: number): Quaternion;
+    set(x: number, y: number, z: number, w: number): this;
     /**
      * Adds two quaternions
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#10
      * @param other defines the second operand
      * @returns a new quaternion as the addition result of the given one and the current quaternion
      */
-    add(other: DeepImmutable<Quaternion>): Quaternion;
+    add(other: DeepImmutable<Quaternion>): this;
     /**
      * Add a quaternion to the current one
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#11
      * @param other defines the quaternion to add
      * @returns the current quaternion
      */
-    addInPlace(other: DeepImmutable<Quaternion>): Quaternion;
+    addInPlace(other: DeepImmutable<Quaternion>): this;
     /**
      * 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): Quaternion;
+    subtract(other: Quaternion): this;
     /**
      * Subtract a quaternion to the current one
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#58
      * @param other defines the quaternion to subtract
      * @returns the current quaternion
      */
-    subtractInPlace(other: DeepImmutable<Quaternion>): Quaternion;
+    subtractInPlace(other: DeepImmutable<Quaternion>): this;
     /**
      * Multiplies the current quaternion by a scale factor
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#88
      * @param value defines the scale factor
      * @returns a new quaternion set by multiplying the current quaternion coordinates by the float "scale"
      */
-    scale(value: number): Quaternion;
+    scale(value: number): this;
     /**
      * Scale the current quaternion values by a factor and stores the result to a given quaternion
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#89
      * @param scale defines the scale factor
      * @param result defines the Quaternion object where to store the result
-     * @returns the unmodified current quaternion
+     * @returns result input
      */
-    scaleToRef(scale: number, result: Quaternion): Quaternion;
+    scaleToRef<T extends Quaternion>(scale: number, result: T): T;
     /**
      * Multiplies in place the current quaternion by a scale factor
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#90
      * @param value defines the scale factor
      * @returns the current modified quaternion
      */
-    scaleInPlace(value: number): Quaternion;
+    scaleInPlace(value: number): this;
     /**
      * Scale the current quaternion values by a factor and add the result to a given quaternion
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#91
      * @param scale defines the scale factor
      * @param result defines the Quaternion object where to store the result
-     * @returns the unmodified current quaternion
+     * @returns result input
      */
-    scaleAndAddToRef(scale: number, result: Quaternion): Quaternion;
+    scaleAndAddToRef<T extends Quaternion>(scale: number, result: T): T;
     /**
      * Multiplies two quaternions
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#43
      * @param q1 defines the second operand
      * @returns a new quaternion set as the multiplication result of the current one with the given one "q1"
      */
-    multiply(q1: DeepImmutable<Quaternion>): Quaternion;
+    multiply(q1: DeepImmutable<Quaternion>): this;
     /**
      * Sets the given "result" as the the multiplication result of the current one with the given one "q1"
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#45
      * @param q1 defines the second operand
      * @param result defines the target quaternion
      * @returns the current quaternion
      */
-    multiplyToRef(q1: DeepImmutable<Quaternion>, result: Quaternion): Quaternion;
+    multiplyToRef<T extends Quaternion>(q1: DeepImmutable<Quaternion>, result: T): T;
     /**
      * 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
      * @returns the currentupdated quaternion
      */
-    multiplyInPlace(q1: DeepImmutable<Quaternion>): Quaternion;
+    multiplyInPlace(q1: DeepImmutable<Quaternion>): this;
     /**
      * Conjugates the current quaternion and stores the result in the given quaternion
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#81
      * @param ref defines the target quaternion
-     * @returns the current quaternion
+     * @returns result input
      */
-    conjugateToRef(ref: Quaternion): Quaternion;
+    conjugateToRef<T extends Quaternion>(ref: T): T;
     /**
      * Conjugates in place the current quaternion
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#82
      * @returns the current updated quaternion
      */
-    conjugateInPlace(): Quaternion;
+    conjugateInPlace(): this;
     /**
      * Conjugates (1-q) the current quaternion
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#83
      * @returns a new quaternion
      */
-    conjugate(): Quaternion;
+    conjugate(): this;
     /**
      * Returns the inverse of the current quaternion
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#84
      * @returns a new quaternion
      */
-    invert(): Quaternion;
+    invert(): this;
     /**
      * Invert in place the current quaternion
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#85
      * @returns this quaternion
      */
-    invertInPlace(): Quaternion;
+    invertInPlace(): this;
     /**
      * Gets squared length of current quaternion
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#29
      * @returns the quaternion length (float)
      */
     lengthSquared(): number;
     /**
      * Gets length of current quaternion
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#28
      * @returns the quaternion length (float)
      */
     length(): number;
     /**
      * Normalize in place the current quaternion
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#54
      * @returns the current updated quaternion
      */
-    normalize(): Quaternion;
+    normalize(): this;
     /**
      * Normalize a copy of the current quaternion
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#55
      * @returns the normalized quaternion
      */
-    normalizeToNew(): Quaternion;
+    normalizeToNew(): this;
     /**
      * Returns a new Vector3 set with the Euler angles translated from the current quaternion
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#32
      * @returns a new Vector3 containing the Euler angles
      * @see https://doc.babylonjs.com/divingDeeper/mesh/transforms/center_origin/rotation_conventions
      */
     toEulerAngles(): Vector3;
     /**
      * Sets the given vector3 "result" with the Euler angles translated from the current quaternion
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#31
      * @param result defines the vector which will be filled with the Euler angles
-     * @returns the current unchanged quaternion
+     * @returns result input
      * @see https://doc.babylonjs.com/divingDeeper/mesh/transforms/center_origin/rotation_conventions
      */
-    toEulerAnglesToRef(result: Vector3): Quaternion;
+    toEulerAnglesToRef<T extends Vector3>(result: T): T;
     /**
      * Updates the given rotation matrix with the current quaternion values
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#67
      * @param result defines the target matrix
      * @returns the current unchanged quaternion
      */
-    toRotationMatrix(result: Matrix): Quaternion;
+    toRotationMatrix<T extends Matrix>(result: T): T;
     /**
      * Updates the current quaternion from the given rotation matrix values
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#41
      * @param matrix defines the source matrix
      * @returns the current updated quaternion
      */
-    fromRotationMatrix(matrix: DeepImmutable<Matrix>): Quaternion;
+    fromRotationMatrix(matrix: DeepImmutable<Matrix>): this;
     /**
      * Creates a new quaternion from a rotation matrix
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#101
      * @param matrix defines the source matrix
      * @returns a new quaternion created from the given rotation matrix values
      */
     static FromRotationMatrix(matrix: DeepImmutable<Matrix>): Quaternion;
     /**
      * Updates the given quaternion with the given rotation matrix values
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#102
      * @param matrix defines the source matrix
      * @param result defines the target quaternion
+     * @returns result input
      */
-    static FromRotationMatrixToRef(matrix: DeepImmutable<Matrix>, result: Quaternion): void;
-    /**
-     * Creates the rotation quaternion needed to rotate from one Vector3 onto another Vector3
-     * Example PG https://playground.babylonjs.com/#L49EJ7#2
-     * @param fromVector the starting vector
-     * @param toVector the ending vector
-     * @returns the rotation quaternion needed
-     */
-    static RotationQuaternionFromOnto(fromVector: DeepImmutable<Vector3>, toVector: DeepImmutable<Vector3>): Quaternion;
-    /**
-     * Creates the rotation quaternion needed to rotate from one Vector3 onto another Vector3 and stores in a result Quaternion
-     * Example PG https://playground.babylonjs.com/#L49EJ7#3
-     * @param fromVector the starting vector
-     * @param toVector the ending vector
-     * @param result the rotation quaternion needed
-     * @returns the result
-     */
-    static RotationQuaternionFromOntoToRef(fromVector: DeepImmutable<Vector3>, toVector: DeepImmutable<Vector3>, result: DeepImmutable<Quaternion>): Quaternion;
+    static FromRotationMatrixToRef<T extends Quaternion>(matrix: DeepImmutable<Matrix>, result: T): T;
     /**
      * Returns the dot product (float) between the quaternions "left" and "right"
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#61
      * @param left defines the left operand
      * @param right defines the right operand
      * @returns the dot product
@@ -2284,6 +2340,7 @@ export declare class Quaternion {
     static Dot(left: DeepImmutable<Quaternion>, right: DeepImmutable<Quaternion>): number;
     /**
      * Checks if the orientations of two rotation quaternions are close to each other
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#60
      * @param quat0 defines the first quaternion to check
      * @param quat1 defines the second quaternion to check
      * @param epsilon defines closeness, 0 same orientation, 1 PI apart, default 0.1
@@ -2292,14 +2349,14 @@ export declare class Quaternion {
     static AreClose(quat0: DeepImmutable<Quaternion>, quat1: DeepImmutable<Quaternion>, epsilon?: number): boolean;
     /**
      * Smooth interpolation between two quaternions using Slerp
-     *
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#93
      * @param source source quaternion
      * @param goal goal quaternion
      * @param deltaTime current interpolation frame
      * @param lerpTime total interpolation time
      * @param result the smoothed quaternion
      */
-    static SmoothToRef(source: Quaternion, goal: Quaternion, deltaTime: number, lerpTime: number, result: Quaternion): void;
+    static SmoothToRef<T extends Quaternion>(source: Quaternion, goal: Quaternion, deltaTime: number, lerpTime: number, result: T): T;
     /**
      * Creates an empty quaternion
      * @returns a new quaternion set to (0.0, 0.0, 0.0)
@@ -2307,17 +2364,19 @@ export declare class Quaternion {
     static Zero(): Quaternion;
     /**
      * Inverse a given quaternion
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#103
      * @param q defines the source quaternion
      * @returns a new quaternion as the inverted current quaternion
      */
-    static Inverse(q: DeepImmutable<Quaternion>): Quaternion;
+    static Inverse<T extends Quaternion>(q: DeepImmutable<T>): T;
     /**
      * Inverse a given quaternion
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#104
      * @param q defines the source quaternion
      * @param result the quaternion the result will be stored in
      * @returns the result quaternion
      */
-    static InverseToRef(q: Quaternion, result: Quaternion): Quaternion;
+    static InverseToRef<T extends Quaternion>(q: Quaternion, result: T): T;
     /**
      * Creates an identity quaternion
      * @returns the identity quaternion
@@ -2331,6 +2390,7 @@ export declare class Quaternion {
     static IsIdentity(quaternion: DeepImmutable<Quaternion>): boolean;
     /**
      * Creates a quaternion from a rotation around an axis
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#72
      * @param axis defines the axis to use
      * @param angle defines the angle to use
      * @returns a new quaternion created from the given axis (Vector3) and angle in radians (float)
@@ -2338,14 +2398,16 @@ export declare class Quaternion {
     static RotationAxis(axis: DeepImmutable<Vector3>, angle: number): Quaternion;
     /**
      * Creates a rotation around an axis and stores it into the given quaternion
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#73
      * @param axis defines the axis to use
      * @param angle defines the angle to use
      * @param result defines the target quaternion
      * @returns the target quaternion
      */
-    static RotationAxisToRef(axis: DeepImmutable<Vector3>, angle: number, result: Quaternion): Quaternion;
+    static RotationAxisToRef<T extends Quaternion>(axis: DeepImmutable<Vector3>, angle: number, result: T): T;
     /**
      * Creates a new quaternion from data stored into an array
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#63
      * @param array defines the data source
      * @param offset defines the offset in the source array where the data starts
      * @returns a new quaternion
@@ -2353,13 +2415,16 @@ export declare class Quaternion {
     static FromArray(array: DeepImmutable<ArrayLike<number>>, offset?: number): Quaternion;
     /**
      * Updates the given quaternion "result" from the starting index of the given array.
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#64
      * @param array the array to pull values from
      * @param offset the offset into the array to start at
      * @param result the quaternion to store the result in
+     * @returns result input
      */
-    static FromArrayToRef(array: DeepImmutable<ArrayLike<number>>, offset: number, result: Quaternion): void;
+    static FromArrayToRef<T extends Quaternion>(array: DeepImmutable<ArrayLike<number>>, offset: number, result: T): T;
     /**
      * Create a quaternion from Euler rotation angles
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#33
      * @param x Pitch
      * @param y Yaw
      * @param z Roll
@@ -2368,36 +2433,41 @@ export declare class Quaternion {
     static FromEulerAngles(x: number, y: number, z: number): Quaternion;
     /**
      * Updates a quaternion from Euler rotation angles
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#34
      * @param x Pitch
      * @param y Yaw
      * @param z Roll
      * @param result the quaternion to store the result
      * @returns the updated quaternion
      */
-    static FromEulerAnglesToRef(x: number, y: number, z: number, result: Quaternion): Quaternion;
+    static FromEulerAnglesToRef<T extends Quaternion>(x: number, y: number, z: number, result: T): T;
     /**
      * Create a quaternion from Euler rotation vector
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#35
      * @param vec the Euler vector (x Pitch, y Yaw, z Roll)
      * @returns the new Quaternion
      */
     static FromEulerVector(vec: DeepImmutable<Vector3>): Quaternion;
     /**
      * Updates a quaternion from Euler rotation vector
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#36
      * @param vec the Euler vector (x Pitch, y Yaw, z Roll)
      * @param result the quaternion to store the result
      * @returns the updated quaternion
      */
-    static FromEulerVectorToRef(vec: DeepImmutable<Vector3>, result: Quaternion): Quaternion;
+    static FromEulerVectorToRef<T extends Quaternion>(vec: DeepImmutable<Vector3>, result: T): T;
     /**
      * Updates a quaternion so that it rotates vector vecFrom to vector vecTo
+     * Example Playground - https://playground.babylonjs.com/#L49EJ7#70
      * @param vecFrom defines the direction vector from which to rotate
      * @param vecTo defines the direction vector to which to rotate
      * @param result the quaternion to store the result
      * @returns the updated quaternion
      */
-    static FromUnitVectorsToRef(vecFrom: DeepImmutable<Vector3>, vecTo: DeepImmutable<Vector3>, result: Quaternion): Quaternion;
+    static FromUnitVectorsToRef<T extends Quaternion>(vecFrom: DeepImmutable<Vector3>, vecTo: DeepImmutable<Vector3>, result: T): T;
     /**
      * Creates a new quaternion from the given Euler float angles (y, x, z)
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#77
      * @param yaw defines the rotation around Y axis
      * @param pitch defines the rotation around X axis
      * @param roll defines the rotation around Z axis
@@ -2406,14 +2476,17 @@ export declare class Quaternion {
     static RotationYawPitchRoll(yaw: number, pitch: number, roll: number): Quaternion;
     /**
      * Creates a new rotation from the given Euler float angles (y, x, z) and stores it in the target quaternion
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#78
      * @param yaw defines the rotation around Y axis
      * @param pitch defines the rotation around X axis
      * @param roll defines the rotation around Z axis
      * @param result defines the target quaternion
+     * @returns result input
      */
-    static RotationYawPitchRollToRef(yaw: number, pitch: number, roll: number, result: Quaternion): void;
+    static RotationYawPitchRollToRef<T extends Quaternion>(yaw: number, pitch: number, roll: number, result: T): T;
     /**
      * Creates a new quaternion from the given Euler float angles expressed in z-x-z orientation
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#68
      * @param alpha defines the rotation around first axis
      * @param beta defines the rotation around second axis
      * @param gamma defines the rotation around third axis
@@ -2422,14 +2495,17 @@ export declare class Quaternion {
     static RotationAlphaBetaGamma(alpha: number, beta: number, gamma: number): Quaternion;
     /**
      * Creates a new quaternion from the given Euler float angles expressed in z-x-z orientation and stores it in the target quaternion
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#69
      * @param alpha defines the rotation around first axis
      * @param beta defines the rotation around second axis
      * @param gamma defines the rotation around third axis
      * @param result defines the target quaternion
+     * @returns result input
      */
-    static RotationAlphaBetaGammaToRef(alpha: number, beta: number, gamma: number, result: Quaternion): void;
+    static RotationAlphaBetaGammaToRef<T extends Quaternion>(alpha: number, beta: number, gamma: number, result: T): T;
     /**
      * Creates a new quaternion containing the rotation value to reach the target (axis1, axis2, axis3) orientation as a rotated XYZ system (axis1, axis2 and axis3 are normalized during this operation)
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#75
      * @param axis1 defines the first axis
      * @param axis2 defines the second axis
      * @param axis3 defines the third axis
@@ -2438,15 +2514,18 @@ export declare class Quaternion {
     static RotationQuaternionFromAxis(axis1: DeepImmutable<Vector3>, axis2: DeepImmutable<Vector3>, axis3: DeepImmutable<Vector3>): Quaternion;
     /**
      * Creates a rotation value to reach the target (axis1, axis2, axis3) orientation as a rotated XYZ system (axis1, axis2 and axis3 are normalized during this operation) and stores it in the target quaternion
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#76
      * @param axis1 defines the first axis
      * @param axis2 defines the second axis
      * @param axis3 defines the third axis
      * @param ref defines the target quaternion
+     * @returns result input
      */
-    static RotationQuaternionFromAxisToRef(axis1: DeepImmutable<Vector3>, axis2: DeepImmutable<Vector3>, axis3: DeepImmutable<Vector3>, ref: Quaternion): void;
+    static RotationQuaternionFromAxisToRef<T extends Quaternion>(axis1: DeepImmutable<Vector3>, axis2: DeepImmutable<Vector3>, axis3: DeepImmutable<Vector3>, ref: T): T;
     /**
      * Creates a new rotation value to orient an object to look towards the given forward direction, the up direction being oriented like "up".
      * This function works in left handed mode
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#96
      * @param forward defines the forward direction - Must be normalized and orthogonal to up.
      * @param up defines the up vector for the entity - Must be normalized and orthogonal to forward.
      * @returns A new quaternion oriented toward the specified forward and up.
@@ -2455,14 +2534,17 @@ export declare class Quaternion {
     /**
      * Creates a new rotation value to orient an object to look towards the given forward direction with the up direction being oriented like "up", and stores it in the target quaternion.
      * This function works in left handed mode
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#97
      * @param forward defines the forward direction - Must be normalized and orthogonal to up.
      * @param up defines the up vector for the entity - Must be normalized and orthogonal to forward.
      * @param ref defines the target quaternion.
+     * @returns result input
      */
-    static FromLookDirectionLHToRef(forward: DeepImmutable<Vector3>, up: DeepImmutable<Vector3>, ref: Quaternion): void;
+    static FromLookDirectionLHToRef<T extends Quaternion>(forward: DeepImmutable<Vector3>, up: DeepImmutable<Vector3>, ref: T): T;
     /**
      * Creates a new rotation value to orient an object to look towards the given forward direction, the up direction being oriented like "up".
      * This function works in right handed mode
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#98
      * @param forward defines the forward direction - Must be normalized and orthogonal to up.
      * @param up defines the up vector for the entity - Must be normalized and orthogonal to forward.
      * @returns A new quaternion oriented toward the specified forward and up.
@@ -2471,13 +2553,16 @@ export declare class Quaternion {
     /**
      * Creates a new rotation value to orient an object to look towards the given forward direction with the up direction being oriented like "up", and stores it in the target quaternion.
      * This function works in right handed mode
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#105
      * @param forward defines the forward direction - Must be normalized and orthogonal to up.
      * @param up defines the up vector for the entity - Must be normalized and orthogonal to forward.
      * @param ref defines the target quaternion.
+     * @returns result input
      */
-    static FromLookDirectionRHToRef(forward: DeepImmutable<Vector3>, up: DeepImmutable<Vector3>, ref: Quaternion): void;
+    static FromLookDirectionRHToRef<T extends Quaternion>(forward: DeepImmutable<Vector3>, up: DeepImmutable<Vector3>, ref: T): T;
     /**
      * Interpolates between two quaternions
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#79
      * @param left defines first quaternion
      * @param right defines second quaternion
      * @param amount defines the gradient to use
@@ -2486,14 +2571,18 @@ export declare class Quaternion {
     static Slerp(left: DeepImmutable<Quaternion>, right: DeepImmutable<Quaternion>, amount: number): Quaternion;
     /**
      * Interpolates between two quaternions and stores it into a target quaternion
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#92
      * @param left defines first quaternion
      * @param right defines second quaternion
      * @param amount defines the gradient to use
      * @param result defines the target quaternion
+     * @returns result input
      */
-    static SlerpToRef(left: DeepImmutable<Quaternion>, right: DeepImmutable<Quaternion>, amount: number, result: Quaternion): void;
+    static SlerpToRef<T extends Quaternion>(left: DeepImmutable<Quaternion>, right: DeepImmutable<Quaternion>, amount: number, result: T): T;
     /**
      * Interpolate between two quaternions using Hermite interpolation
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#47
+     * @see https://doc.babylonjs.com/features/featuresDeepDive/mesh/drawCurves#hermite-quaternion-spline
      * @param value1 defines first quaternion
      * @param tangent1 defines the incoming tangent
      * @param value2 defines second quaternion
@@ -2501,9 +2590,10 @@ export declare class Quaternion {
      * @param amount defines the target quaternion
      * @returns the new interpolated quaternion
      */
-    static Hermite(value1: DeepImmutable<Quaternion>, tangent1: DeepImmutable<Quaternion>, value2: DeepImmutable<Quaternion>, tangent2: DeepImmutable<Quaternion>, amount: number): Quaternion;
+    static Hermite<T extends Quaternion>(value1: DeepImmutable<T>, tangent1: DeepImmutable<Quaternion>, value2: DeepImmutable<Quaternion>, tangent2: DeepImmutable<Quaternion>, amount: number): T;
     /**
      * Returns a new Quaternion which is the 1st derivative of the Hermite spline defined by the quaternions "value1", "value2", "tangent1", "tangent2".
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#48
      * @param value1 defines the first control point
      * @param tangent1 defines the first tangent
      * @param value2 defines the second control point
@@ -2511,17 +2601,19 @@ export declare class Quaternion {
      * @param time define where the derivative must be done
      * @returns 1st derivative
      */
-    static Hermite1stDerivative(value1: DeepImmutable<Quaternion>, tangent1: DeepImmutable<Quaternion>, value2: DeepImmutable<Quaternion>, tangent2: DeepImmutable<Quaternion>, time: number): Quaternion;
+    static Hermite1stDerivative<T extends Quaternion>(value1: DeepImmutable<T>, tangent1: DeepImmutable<Quaternion>, value2: DeepImmutable<Quaternion>, tangent2: DeepImmutable<Quaternion>, time: number): T;
     /**
      * Update a Quaternion with the 1st derivative of the Hermite spline defined by the quaternions "value1", "value2", "tangent1", "tangent2".
+     * Example Playground https://playground.babylonjs.com/#L49EJ7#49
      * @param value1 defines the first control point
      * @param tangent1 defines the first tangent
      * @param value2 defines the second control point
      * @param tangent2 defines the second tangent
      * @param time define where the derivative must be done
      * @param result define where to store the derivative
+     * @returns result input
      */
-    static Hermite1stDerivativeToRef(value1: DeepImmutable<Quaternion>, tangent1: DeepImmutable<Quaternion>, value2: DeepImmutable<Quaternion>, tangent2: DeepImmutable<Quaternion>, time: number, result: Quaternion): void;
+    static Hermite1stDerivativeToRef<T extends Quaternion>(value1: DeepImmutable<Quaternion>, tangent1: DeepImmutable<Quaternion>, value2: DeepImmutable<Quaternion>, tangent2: DeepImmutable<Quaternion>, time: number, result: T): T;
 }
 /**
  * Class used to store matrix data (4x4)
@@ -2586,51 +2678,51 @@ export declare class Matrix {
      * Inverts the current matrix in place
      * @returns the current inverted matrix
      */
-    invert(): Matrix;
+    invert(): this;
     /**
      * Sets all the matrix elements to zero
      * @returns the current matrix
      */
-    reset(): Matrix;
+    reset(): this;
     /**
      * Adds the current matrix with a second one
      * @param other defines the matrix to add
      * @returns a new matrix as the addition of the current matrix and the given one
      */
-    add(other: DeepImmutable<Matrix>): Matrix;
+    add(other: DeepImmutable<Matrix>): this;
     /**
      * Sets the given matrix "result" to the addition of the current matrix and the given one
      * @param other defines the matrix to add
      * @param result defines the target matrix
-     * @returns the current matrix
+     * @returns result input
      */
-    addToRef(other: DeepImmutable<Matrix>, result: Matrix): Matrix;
+    addToRef<T extends Matrix>(other: DeepImmutable<Matrix>, result: T): T;
     /**
      * Adds in place the given matrix to the current matrix
      * @param other defines the second operand
      * @returns the current updated matrix
      */
-    addToSelf(other: DeepImmutable<Matrix>): Matrix;
+    addToSelf(other: DeepImmutable<Matrix>): this;
     /**
      * Sets the given matrix to the current inverted Matrix
      * @param other defines the target matrix
-     * @returns the unmodified current matrix
+     * @returns result input
      */
-    invertToRef(other: Matrix): Matrix;
+    invertToRef<T extends Matrix>(other: T): T;
     /**
      * add a value at the specified position in the current Matrix
      * @param index the index of the value within the matrix. between 0 and 15.
      * @param value the value to be added
      * @returns the current updated matrix
      */
-    addAtIndex(index: number, value: number): Matrix;
+    addAtIndex(index: number, value: number): this;
     /**
      * mutiply the specified position in the current Matrix by a value
      * @param index the index of the value within the matrix. between 0 and 15.
      * @param value the value to be added
      * @returns the current updated matrix
      */
-    multiplyAtIndex(index: number, value: number): Matrix;
+    multiplyAtIndex(index: number, value: number): this;
     /**
      * Inserts the translation vector (using 3 floats) in the current matrix
      * @param x defines the 1st component of the translation
@@ -2638,7 +2730,7 @@ export declare class Matrix {
      * @param z defines the 3rd component of the translation
      * @returns the current updated matrix
      */
-    setTranslationFromFloats(x: number, y: number, z: number): Matrix;
+    setTranslationFromFloats(x: number, y: number, z: number): this;
     /**
      * Adds the translation vector (using 3 floats) in the current matrix
      * @param x defines the 1st component of the translation
@@ -2646,13 +2738,13 @@ export declare class Matrix {
      * @param z defines the 3rd component of the translation
      * @returns the current updated matrix
      */
-    addTranslationFromFloats(x: number, y: number, z: number): Matrix;
+    addTranslationFromFloats(x: number, y: number, z: number): this;
     /**
      * Inserts the translation vector in the current matrix
      * @param vector3 defines the translation to insert
      * @returns the current updated matrix
      */
-    setTranslation(vector3: DeepImmutable<Vector3>): Matrix;
+    setTranslation(vector3: DeepImmutable<Vector3>): this;
     /**
      * Gets the translation value of the current matrix
      * @returns a new Vector3 as the extracted translation from the matrix
@@ -2663,38 +2755,38 @@ export declare class Matrix {
      * @param result defines the Vector3 where to store the translation
      * @returns the current matrix
      */
-    getTranslationToRef(result: Vector3): Matrix;
+    getTranslationToRef<T extends Vector3>(result: T): T;
     /**
      * Remove rotation and scaling part from the matrix
      * @returns the updated matrix
      */
-    removeRotationAndScaling(): Matrix;
+    removeRotationAndScaling(): this;
     /**
      * Multiply two matrices
      * @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>): Matrix;
+    multiply(other: DeepImmutable<Matrix>): this;
     /**
      * Copy the current matrix from the given one
      * @param other defines the source matrix
      * @returns the current updated matrix
      */
-    copyFrom(other: DeepImmutable<Matrix>): Matrix;
+    copyFrom(other: DeepImmutable<Matrix>): this;
     /**
      * Populates the given array from the starting index with the current matrix values
      * @param array defines the target array
      * @param offset defines the offset in the target array where to start storing values
      * @returns the current matrix
      */
-    copyToArray(array: Float32Array | Array<number>, offset?: number): Matrix;
+    copyToArray(array: Float32Array | Array<number>, offset?: number): this;
     /**
      * Sets the given matrix "result" with the multiplication result of the current Matrix and the given one
      * @param other defines the second operand
      * @param result defines the matrix where to store the multiplication
-     * @returns the current matrix
+     * @returns result input
      */
-    multiplyToRef(other: DeepImmutable<Matrix>, result: Matrix): Matrix;
+    multiplyToRef<T extends Matrix>(other: DeepImmutable<Matrix>, result: T): T;
     /**
      * Sets the Float32Array "result" from the given index "offset" with the multiplication of the current matrix and the given one
      * @param other defines the second operand
@@ -2702,7 +2794,7 @@ export declare class Matrix {
      * @param offset defines the offset in the target array where to start storing values
      * @returns the current matrix
      */
-    multiplyToArray(other: DeepImmutable<Matrix>, result: Float32Array | Array<number>, offset: number): Matrix;
+    multiplyToArray(other: DeepImmutable<Matrix>, result: Float32Array | Array<number>, offset: number): this;
     /**
      * Check equality between this matrix and a second one
      * @param value defines the second matrix to compare
@@ -2713,7 +2805,7 @@ export declare class Matrix {
      * Clone the current matrix
      * @returns a new matrix from the current matrix
      */
-    clone(): Matrix;
+    clone(): this;
     /**
      * Returns the name of the current matrix class
      * @returns the string "Matrix"
@@ -2749,27 +2841,27 @@ export declare class Matrix {
      * Gets specific row of the matrix to ref
      * @param index defines the number of the row to get
      * @param rowVector vector to store the index-th row of the current matrix
-     * @returns the current matrix
+     * @returns result input
      */
-    getRowToRef(index: number, rowVector: Vector4): Matrix;
+    getRowToRef<T extends Vector4>(index: number, rowVector: T): T;
     /**
      * Sets the index-th row of the current matrix to the vector4 values
      * @param index defines the number of the row to set
      * @param row defines the target vector4
      * @returns the updated current matrix
      */
-    setRow(index: number, row: Vector4): Matrix;
+    setRow(index: number, row: Vector4): this;
     /**
      * Compute the transpose of the matrix
      * @returns the new transposed matrix
      */
-    transpose(): Matrix;
+    transpose(): this;
     /**
      * Compute the transpose of the matrix and store it in a given matrix
      * @param result defines the target matrix
-     * @returns the current matrix
+     * @returns result input
      */
-    transposeToRef(result: Matrix): Matrix;
+    transposeToRef<T extends Matrix>(result: T): T;
     /**
      * Sets the index-th row of the current matrix with the given 4 x float values
      * @param index defines the row index
@@ -2779,51 +2871,51 @@ export declare class Matrix {
      * @param w defines the w component to set
      * @returns the updated current matrix
      */
-    setRowFromFloats(index: number, x: number, y: number, z: number, w: number): Matrix;
+    setRowFromFloats(index: number, x: number, y: number, z: number, w: number): this;
     /**
      * Compute a new matrix set with the current matrix values multiplied by scale (float)
      * @param scale defines the scale factor
      * @returns a new matrix
      */
-    scale(scale: number): Matrix;
+    scale(scale: number): this;
     /**
      * Scale the current matrix values by a factor to a given result matrix
      * @param scale defines the scale factor
      * @param result defines the matrix to store the result
-     * @returns the current matrix
+     * @returns result input
      */
-    scaleToRef(scale: number, result: Matrix): Matrix;
+    scaleToRef<T extends Matrix>(scale: number, result: T): T;
     /**
      * Scale the current matrix values by a factor and add the result to a given matrix
      * @param scale defines the scale factor
      * @param result defines the Matrix to store the result
-     * @returns the current matrix
+     * @returns result input
      */
-    scaleAndAddToRef(scale: number, result: Matrix): Matrix;
+    scaleAndAddToRef<T extends Matrix>(scale: number, result: T): T;
     /**
      * Writes to the given matrix a normal matrix, computed from this one (using values from identity matrix for fourth row and column).
      * @param ref matrix to store the result
      */
-    toNormalMatrix(ref: Matrix): void;
+    toNormalMatrix<T extends Matrix>(ref: T): T;
     /**
      * Gets only rotation part of the current matrix
      * @returns a new matrix sets to the extracted rotation matrix from the current one
      */
-    getRotationMatrix(): Matrix;
+    getRotationMatrix(): this;
     /**
      * Extracts the rotation matrix from the current one and sets it as the given "result"
      * @param result defines the target matrix to store data to
-     * @returns the current matrix
+     * @returns result input
      */
-    getRotationMatrixToRef(result: Matrix): Matrix;
+    getRotationMatrixToRef<T extends Matrix>(result: T): T;
     /**
      * Toggles model matrix from being right handed to left handed in place and vice versa
      */
-    toggleModelMatrixHandInPlace(): void;
+    toggleModelMatrixHandInPlace(): this;
     /**
      * Toggles projection matrix from being right handed to left handed in place and vice versa
      */
-    toggleProjectionMatrixHandInPlace(): void;
+    toggleProjectionMatrixHandInPlace(): this;
     /**
      * Creates a matrix from an array
      * @param array defines the source array
@@ -2836,16 +2928,18 @@ export declare class Matrix {
      * @param array defines the source array
      * @param offset defines an offset in the source array
      * @param result defines the target matrix
+     * @returns result input
      */
-    static FromArrayToRef(array: DeepImmutable<ArrayLike<number>>, offset: number, result: Matrix): void;
+    static FromArrayToRef<T extends Matrix>(array: DeepImmutable<ArrayLike<number>>, offset: number, result: T): T;
     /**
      * Stores an array into a matrix after having multiplied each component by a given factor
      * @param array defines the source array
      * @param offset defines the offset in the source array
      * @param scale defines the scaling factor
      * @param result defines the target matrix
+     * @returns result input
      */
-    static FromFloat32ArrayToRefScaled(array: DeepImmutable<Float32Array | Array<number>>, offset: number, scale: number, result: Matrix): void;
+    static FromFloat32ArrayToRefScaled<T extends Matrix>(array: DeepImmutable<Float32Array | Array<number>>, offset: number, scale: number, result: T): T;
     /**
      * Gets an identity matrix that must not be updated
      */
@@ -2869,6 +2963,7 @@ export declare class Matrix {
      * @param initialM43 defines 3rd value of 4th row
      * @param initialM44 defines 4th value of 4th row
      * @param result defines the target matrix
+     * @returns result input
      */
     static FromValuesToRef(initialM11: number, initialM12: number, initialM13: number, initialM14: number, initialM21: number, initialM22: number, initialM23: number, initialM24: number, initialM31: number, initialM32: number, initialM33: number, initialM34: number, initialM41: number, initialM42: number, initialM43: number, initialM44: number, result: Matrix): void;
     /**
@@ -2906,8 +3001,9 @@ export declare class Matrix {
      * @param rotation defines the rotation quaternion
      * @param translation defines the translation vector3
      * @param result defines the target matrix
+     * @returns result input
      */
-    static ComposeToRef(scale: DeepImmutable<Vector3>, rotation: DeepImmutable<Quaternion>, translation: DeepImmutable<Vector3>, result: Matrix): void;
+    static ComposeToRef<T extends Matrix>(scale: DeepImmutable<Vector3>, rotation: DeepImmutable<Quaternion>, translation: DeepImmutable<Vector3>, result: T): T;
     /**
      * Creates a new identity matrix
      * @returns a new identity matrix
@@ -2916,8 +3012,9 @@ export declare class Matrix {
     /**
      * Creates a new identity matrix and stores the result in a given matrix
      * @param result defines the target matrix
+     * @returns result input
      */
-    static IdentityToRef(result: Matrix): void;
+    static IdentityToRef<T extends Matrix>(result: T): T;
     /**
      * Creates a new zero matrix
      * @returns a new zero matrix
@@ -2934,13 +3031,14 @@ export declare class Matrix {
      * @param source defines the source matrix
      * @returns the new matrix
      */
-    static Invert(source: DeepImmutable<Matrix>): Matrix;
+    static Invert<T extends Matrix>(source: DeepImmutable<T>): T;
     /**
      * Creates a new rotation matrix for "angle" radians around the X axis and stores it in a given matrix
      * @param angle defines the angle (in radians) to use
      * @param result defines the target matrix
+     * @returns result input
      */
-    static RotationXToRef(angle: number, result: Matrix): void;
+    static RotationXToRef<T extends Matrix>(angle: number, result: T): T;
     /**
      * Creates a new rotation matrix for "angle" radians around the Y axis
      * @param angle defines the angle (in radians) to use
@@ -2951,8 +3049,9 @@ export declare class Matrix {
      * Creates a new rotation matrix for "angle" radians around the Y axis and stores it in a given matrix
      * @param angle defines the angle (in radians) to use
      * @param result defines the target matrix
+     * @returns result input
      */
-    static RotationYToRef(angle: number, result: Matrix): void;
+    static RotationYToRef<T extends Matrix>(angle: number, result: T): T;
     /**
      * Creates a new rotation matrix for "angle" radians around the Z axis
      * @param angle defines the angle (in radians) to use
@@ -2963,8 +3062,9 @@ export declare class Matrix {
      * Creates a new rotation matrix for "angle" radians around the Z axis and stores it in a given matrix
      * @param angle defines the angle (in radians) to use
      * @param result defines the target matrix
+     * @returns result input
      */
-    static RotationZToRef(angle: number, result: Matrix): void;
+    static RotationZToRef<T extends Matrix>(angle: number, result: T): T;
     /**
      * Creates a new rotation matrix for "angle" radians around the given axis
      * @param axis defines the axis to use
@@ -2977,16 +3077,18 @@ export declare class Matrix {
      * @param axis defines the axis to use
      * @param angle defines the angle (in radians) to use
      * @param result defines the target matrix
+     * @returns result input
      */
-    static RotationAxisToRef(axis: DeepImmutable<Vector3>, angle: number, result: Matrix): void;
+    static RotationAxisToRef<T extends Matrix>(axis: DeepImmutable<Vector3>, angle: number, result: T): T;
     /**
      * Takes normalised vectors and returns a rotation matrix to align "from" with "to".
      * Taken from http://www.iquilezles.org/www/articles/noacos/noacos.htm
      * @param from defines the vector to align
      * @param to defines the vector to align to
      * @param result defines the target matrix
+     * @returns result input
      */
-    static RotationAlignToRef(from: DeepImmutable<Vector3>, to: DeepImmutable<Vector3>, result: Matrix): void;
+    static RotationAlignToRef<T extends Matrix>(from: DeepImmutable<Vector3>, to: DeepImmutable<Vector3>, result: T): T;
     /**
      * Creates a rotation matrix
      * @param yaw defines the yaw angle in radians (Y axis)
@@ -3001,8 +3103,9 @@ export declare class Matrix {
      * @param pitch defines the pitch angle in radians (X axis)
      * @param roll defines the roll angle in radians (Z axis)
      * @param result defines the target matrix
+     * @returns result input
      */
-    static RotationYawPitchRollToRef(yaw: number, pitch: number, roll: number, result: Matrix): void;
+    static RotationYawPitchRollToRef<T extends Matrix>(yaw: number, pitch: number, roll: number, result: T): T;
     /**
      * Creates a scaling matrix
      * @param x defines the scale factor on X axis
@@ -3017,8 +3120,9 @@ export declare class Matrix {
      * @param y defines the scale factor on Y axis
      * @param z defines the scale factor on Z axis
      * @param result defines the target matrix
+     * @returns result input
      */
-    static ScalingToRef(x: number, y: number, z: number, result: Matrix): void;
+    static ScalingToRef<T extends Matrix>(x: number, y: number, z: number, result: T): T;
     /**
      * Creates a translation matrix
      * @param x defines the translation on X axis
@@ -3033,8 +3137,9 @@ export declare class Matrix {
      * @param y defines the translation on Y axis
      * @param z defines the translationon Z axis
      * @param result defines the target matrix
+     * @returns result input
      */
-    static TranslationToRef(x: number, y: number, z: number, result: Matrix): void;
+    static TranslationToRef<T extends Matrix>(x: number, y: number, z: number, result: T): T;
     /**
      * Returns a new Matrix whose values are the interpolated values for "gradient" (float) between the ones of the matrices "startValue" and "endValue".
      * @param startValue defines the start value
@@ -3042,15 +3147,16 @@ export declare class Matrix {
      * @param gradient defines the gradient factor
      * @returns the new matrix
      */
-    static Lerp(startValue: DeepImmutable<Matrix>, endValue: DeepImmutable<Matrix>, gradient: number): Matrix;
+    static Lerp<T extends Matrix>(startValue: DeepImmutable<T>, endValue: DeepImmutable<Matrix>, gradient: number): T;
     /**
      * Set the given matrix "result" as the interpolated values for "gradient" (float) between the ones of the matrices "startValue" and "endValue".
      * @param startValue defines the start value
      * @param endValue defines the end value
      * @param gradient defines the gradient factor
      * @param result defines the Matrix object where to store data
+     * @returns result input
      */
-    static LerpToRef(startValue: DeepImmutable<Matrix>, endValue: DeepImmutable<Matrix>, gradient: number, result: Matrix): void;
+    static LerpToRef<T extends Matrix>(startValue: DeepImmutable<Matrix>, endValue: DeepImmutable<Matrix>, gradient: number, result: T): T;
     /**
      * Builds a new matrix whose values are computed by:
      * * decomposing the the "startValue" and "endValue" matrices into their respective scale, rotation and translation matrices
@@ -3061,7 +3167,7 @@ export declare class Matrix {
      * @param gradient defines the gradient between the two matrices
      * @returns the new matrix
      */
-    static DecomposeLerp(startValue: DeepImmutable<Matrix>, endValue: DeepImmutable<Matrix>, gradient: number): Matrix;
+    static DecomposeLerp<T extends Matrix>(startValue: DeepImmutable<T>, endValue: DeepImmutable<Matrix>, gradient: number): T;
     /**
      * Update a matrix to values which are computed by:
      * * decomposing the the "startValue" and "endValue" matrices into their respective scale, rotation and translation matrices
@@ -3071,8 +3177,9 @@ export declare class Matrix {
      * @param endValue defines the second matrix
      * @param gradient defines the gradient between the two matrices
      * @param result defines the target matrix
+     * @returns result input
      */
-    static DecomposeLerpToRef(startValue: DeepImmutable<Matrix>, endValue: DeepImmutable<Matrix>, gradient: number, result: Matrix): void;
+    static DecomposeLerpToRef<T extends Matrix>(startValue: DeepImmutable<Matrix>, endValue: DeepImmutable<Matrix>, gradient: number, result: T): T;
     /**
      * Gets a new rotation matrix used to rotate an entity so as it looks at the target vector3, from the eye vector3 position, the up vector3 being oriented like "up"
      * This function works in left handed mode
@@ -3089,6 +3196,7 @@ export declare class Matrix {
      * @param target defines where the entity should look at
      * @param up defines the up vector for the entity
      * @param result defines the target matrix
+     * @returns result input
      */
     static LookAtLHToRef(eye: DeepImmutable<Vector3>, target: DeepImmutable<Vector3>, up: DeepImmutable<Vector3>, result: Matrix): void;
     /**
@@ -3107,8 +3215,9 @@ export declare class Matrix {
      * @param target defines where the entity should look at
      * @param up defines the up vector for the entity
      * @param result defines the target matrix
+     * @returns result input
      */
-    static LookAtRHToRef(eye: DeepImmutable<Vector3>, target: DeepImmutable<Vector3>, up: DeepImmutable<Vector3>, result: Matrix): void;
+    static LookAtRHToRef<T extends Matrix>(eye: DeepImmutable<Vector3>, target: DeepImmutable<Vector3>, up: DeepImmutable<Vector3>, result: T): T;
     /**
      * Gets a new rotation matrix used to rotate an entity so as it looks in the direction specified by forward from the eye position, the up direction being oriented like "up".
      * This function works in left handed mode
@@ -3123,8 +3232,9 @@ export declare class Matrix {
      * @param forward defines the forward direction - Must be normalized and orthogonal to up.
      * @param up defines the up vector for the entity - Must be normalized and orthogonal to forward.
      * @param result defines the target matrix
+     * @returns result input
      */
-    static LookDirectionLHToRef(forward: DeepImmutable<Vector3>, up: DeepImmutable<Vector3>, result: Matrix): void;
+    static LookDirectionLHToRef<T extends Matrix>(forward: DeepImmutable<Vector3>, up: DeepImmutable<Vector3>, result: T): T;
     /**
      * Gets a new rotation matrix used to rotate an entity so as it looks in the direction specified by forward from the eye position, the up Vector3 being oriented like "up".
      * This function works in right handed mode
@@ -3139,8 +3249,9 @@ export declare class Matrix {
      * @param forward defines the forward direction - Must be normalized and orthogonal to up.
      * @param up defines the up vector for the entity - Must be normalized and orthogonal to forward.
      * @param result defines the target matrix
+     * @returns result input
      */
-    static LookDirectionRHToRef(forward: DeepImmutable<Vector3>, up: DeepImmutable<Vector3>, result: Matrix): void;
+    static LookDirectionRHToRef<T extends Matrix>(forward: DeepImmutable<Vector3>, up: DeepImmutable<Vector3>, result: T): T;
     /**
      * Create a left-handed orthographic projection matrix
      * @param width defines the viewport width
@@ -3159,8 +3270,9 @@ export declare class Matrix {
      * @param zfar defines the far clip plane
      * @param result defines the target matrix
      * @param halfZRange true to generate NDC coordinates between 0 and 1 instead of -1 and 1 (default: false)
+     * @returns result input
      */
-    static OrthoLHToRef(width: number, height: number, znear: number, zfar: number, result: Matrix, halfZRange?: boolean): void;
+    static OrthoLHToRef<T extends Matrix>(width: number, height: number, znear: number, zfar: number, result: T, halfZRange?: boolean): T;
     /**
      * Create a left-handed orthographic projection matrix
      * @param left defines the viewport left coordinate
@@ -3183,8 +3295,9 @@ export declare class Matrix {
      * @param zfar defines the far clip plane
      * @param result defines the target matrix
      * @param halfZRange true to generate NDC coordinates between 0 and 1 instead of -1 and 1 (default: false)
+     * @returns result input
      */
-    static OrthoOffCenterLHToRef(left: number, right: number, bottom: number, top: number, znear: number, zfar: number, result: Matrix, halfZRange?: boolean): void;
+    static OrthoOffCenterLHToRef<T extends Matrix>(left: number, right: number, bottom: number, top: number, znear: number, zfar: number, result: T, halfZRange?: boolean): T;
     /**
      * Creates a right-handed orthographic projection matrix
      * @param left defines the viewport left coordinate
@@ -3207,8 +3320,9 @@ export declare class Matrix {
      * @param zfar defines the far clip plane
      * @param result defines the target matrix
      * @param halfZRange true to generate NDC coordinates between 0 and 1 instead of -1 and 1 (default: false)
+     * @returns result input
      */
-    static OrthoOffCenterRHToRef(left: number, right: number, bottom: number, top: number, znear: number, zfar: number, result: Matrix, halfZRange?: boolean): void;
+    static OrthoOffCenterRHToRef<T extends Matrix>(left: number, right: number, bottom: number, top: number, znear: number, zfar: number, result: T, halfZRange?: boolean): T;
     /**
      * Creates a left-handed perspective projection matrix
      * @param width defines the viewport width
@@ -3243,8 +3357,9 @@ export declare class Matrix {
      * @param halfZRange true to generate NDC coordinates between 0 and 1 instead of -1 and 1 (default: false)
      * @param projectionPlaneTilt optional tilt angle of the projection plane around the X axis (horizontal)
      * @param reverseDepthBufferMode true to indicate that we are in a reverse depth buffer mode (meaning znear and zfar have been inverted when calling the function)
+     * @returns result input
      */
-    static PerspectiveFovLHToRef(fov: number, aspect: number, znear: number, zfar: number, result: Matrix, isVerticalFovFixed?: boolean, halfZRange?: boolean, projectionPlaneTilt?: number, reverseDepthBufferMode?: boolean): void;
+    static PerspectiveFovLHToRef<T extends Matrix>(fov: number, aspect: number, znear: number, zfar: number, result: T, isVerticalFovFixed?: boolean, halfZRange?: boolean, projectionPlaneTilt?: number, reverseDepthBufferMode?: boolean): T;
     /**
      * Stores a left-handed perspective projection into a given matrix with depth reversed
      * @param fov defines the horizontal field of view
@@ -3255,8 +3370,9 @@ export declare class Matrix {
      * @param isVerticalFovFixed defines it the fov is vertically fixed (default) or horizontally
      * @param halfZRange true to generate NDC coordinates between 0 and 1 instead of -1 and 1 (default: false)
      * @param projectionPlaneTilt optional tilt angle of the projection plane around the X axis (horizontal)
+     * @returns result input
      */
-    static PerspectiveFovReverseLHToRef(fov: number, aspect: number, znear: number, zfar: number, result: Matrix, isVerticalFovFixed?: boolean, halfZRange?: boolean, projectionPlaneTilt?: number): void;
+    static PerspectiveFovReverseLHToRef<T extends Matrix>(fov: number, aspect: number, znear: number, zfar: number, result: T, isVerticalFovFixed?: boolean, halfZRange?: boolean, projectionPlaneTilt?: number): T;
     /**
      * Creates a right-handed perspective projection matrix
      * @param fov defines the horizontal field of view
@@ -3280,8 +3396,9 @@ export declare class Matrix {
      * @param halfZRange true to generate NDC coordinates between 0 and 1 instead of -1 and 1 (default: false)
      * @param projectionPlaneTilt optional tilt angle of the projection plane around the X axis (horizontal)
      * @param reverseDepthBufferMode true to indicate that we are in a reverse depth buffer mode (meaning znear and zfar have been inverted when calling the function)
+     * @returns result input
      */
-    static PerspectiveFovRHToRef(fov: number, aspect: number, znear: number, zfar: number, result: Matrix, isVerticalFovFixed?: boolean, halfZRange?: boolean, projectionPlaneTilt?: number, reverseDepthBufferMode?: boolean): void;
+    static PerspectiveFovRHToRef<T extends Matrix>(fov: number, aspect: number, znear: number, zfar: number, result: T, isVerticalFovFixed?: boolean, halfZRange?: boolean, projectionPlaneTilt?: number, reverseDepthBufferMode?: boolean): T;
     /**
      * Stores a right-handed perspective projection into a given matrix
      * @param fov defines the horizontal field of view
@@ -3292,8 +3409,9 @@ export declare class Matrix {
      * @param isVerticalFovFixed defines it the fov is vertically fixed (default) or horizontally
      * @param halfZRange true to generate NDC coordinates between 0 and 1 instead of -1 and 1 (default: false)
      * @param projectionPlaneTilt optional tilt angle of the projection plane around the X axis (horizontal)
+     * @returns result input
      */
-    static PerspectiveFovReverseRHToRef(fov: number, aspect: number, znear: number, zfar: number, result: Matrix, isVerticalFovFixed?: boolean, halfZRange?: boolean, projectionPlaneTilt?: number): void;
+    static PerspectiveFovReverseRHToRef<T extends Matrix>(fov: number, aspect: number, znear: number, zfar: number, result: T, isVerticalFovFixed?: boolean, halfZRange?: boolean, projectionPlaneTilt?: number): T;
     /**
      * Stores a perspective projection for WebVR info a given matrix
      * @param fov defines the field of view
@@ -3307,13 +3425,14 @@ export declare class Matrix {
      * @param rightHanded defines if the matrix must be in right-handed mode (false by default)
      * @param halfZRange true to generate NDC coordinates between 0 and 1 instead of -1 and 1 (default: false)
      * @param projectionPlaneTilt optional tilt angle of the projection plane around the X axis (horizontal)
+     * @returns result input
      */
-    static PerspectiveFovWebVRToRef(fov: {
+    static PerspectiveFovWebVRToRef<T extends Matrix>(fov: {
         upDegrees: number;
         downDegrees: number;
         leftDegrees: number;
         rightDegrees: number;
-    }, znear: number, zfar: number, result: Matrix, rightHanded?: boolean, halfZRange?: boolean, projectionPlaneTilt?: number): void;
+    }, znear: number, zfar: number, result: T, rightHanded?: boolean, halfZRange?: boolean, projectionPlaneTilt?: number): T;
     /**
      * Computes a complete transformation matrix
      * @param viewport defines the viewport to use
@@ -3324,7 +3443,7 @@ export declare class Matrix {
      * @param zmax defines the far clip plane
      * @returns the transformation matrix
      */
-    static GetFinalMatrix(viewport: DeepImmutable<Viewport>, world: DeepImmutable<Matrix>, view: DeepImmutable<Matrix>, projection: DeepImmutable<Matrix>, zmin: number, zmax: number): Matrix;
+    static GetFinalMatrix<T extends Matrix>(viewport: DeepImmutable<Viewport>, world: DeepImmutable<T>, view: DeepImmutable<Matrix>, projection: DeepImmutable<Matrix>, zmin: number, zmax: number): T;
     /**
      * Extracts a 2x2 matrix from a given matrix and store the result in a Float32Array
      * @param matrix defines the matrix to use
@@ -3342,13 +3461,14 @@ export declare class Matrix {
      * @param matrix defines the matrix to transpose
      * @returns the new matrix
      */
-    static Transpose(matrix: DeepImmutable<Matrix>): Matrix;
+    static Transpose<T extends Matrix>(matrix: DeepImmutable<T>): T;
     /**
      * Compute the transpose of a matrix and store it in a target matrix
      * @param matrix defines the matrix to transpose
      * @param result defines the target matrix
+     * @returns result input
      */
-    static TransposeToRef(matrix: DeepImmutable<Matrix>, result: Matrix): void;
+    static TransposeToRef<T extends Matrix>(matrix: DeepImmutable<Matrix>, result: T): T;
     /**
      * Computes a reflection matrix from a plane
      * @param plane defines the reflection plane
@@ -3359,22 +3479,25 @@ export declare class Matrix {
      * Computes a reflection matrix from a plane
      * @param plane defines the reflection plane
      * @param result defines the target matrix
+     * @returns result input
      */
-    static ReflectionToRef(plane: DeepImmutable<IPlaneLike>, result: Matrix): void;
+    static ReflectionToRef<T extends Matrix>(plane: DeepImmutable<IPlaneLike>, result: T): T;
     /**
      * Sets the given matrix as a rotation matrix composed from the 3 left handed axes
      * @param xaxis defines the value of the 1st axis
      * @param yaxis defines the value of the 2nd axis
      * @param zaxis defines the value of the 3rd axis
      * @param result defines the target matrix
+     * @returns result input
      */
-    static FromXYZAxesToRef(xaxis: DeepImmutable<Vector3>, yaxis: DeepImmutable<Vector3>, zaxis: DeepImmutable<Vector3>, result: Matrix): void;
+    static FromXYZAxesToRef<T extends Matrix>(xaxis: DeepImmutable<Vector3>, yaxis: DeepImmutable<Vector3>, zaxis: DeepImmutable<Vector3>, result: T): T;
     /**
      * Creates a rotation matrix from a quaternion and stores it in a target matrix
      * @param quat defines the quaternion to use
      * @param result defines the target matrix
+     * @returns result input
      */
-    static FromQuaternionToRef(quat: DeepImmutable<Quaternion>, result: Matrix): void;
+    static FromQuaternionToRef<T extends Matrix>(quat: DeepImmutable<Quaternion>, result: T): T;
 }
 /**
  * @internal