@babylonjs/core 6.45.0 → 6.46.0

package/Maths/math.color.d.ts

@@ -1,8 +1,10 @@
-import type { DeepImmutable, FloatArray } from "../types";
+import type { DeepImmutable, FloatArray, Tuple } from "../types";
+import type { Tensor } from "./tensor";
+import type { IColor3Like, IColor4Like } from "./math.like";
 /**
  * Class used to hold a RGB color
  */
-export declare class Color3 {
+export declare class Color3 implements Tensor<Tuple<number, 3>>, IColor3Like {
     /**
      * Defines the red component (between 0 and 1, default is 0)
      */
@@ -15,6 +17,14 @@ export declare class Color3 {
      * Defines the blue component (between 0 and 1, default is 0)
      */
     b: number;
+    /**
+     * @see Tensor.dimension
+     */
+    readonly dimension: [3];
+    /**
+     * @see Tensor.rank
+     */
+    readonly rank: 1;
     /**
      * Creates a new Color3 object from red, green, blue values, all between 0 and 1
      * @param r defines the red component (between 0 and 1, default is 0)
@@ -55,14 +65,14 @@ export declare class Color3 {
      * @param index defines an optional index in the target array to define where to start storing values
      * @returns the current Color3 object
      */
-    toArray(array: FloatArray, index?: number): Color3;
+    toArray(array: FloatArray, index?: number): this;
     /**
      * Update the current color with values stored in an array from the starting index of the given array
      * @param array defines the source array
      * @param offset defines an offset in the source array
      * @returns the current Color3 object
      */
-    fromArray(array: DeepImmutable<ArrayLike<number>>, offset?: number): Color3;
+    fromArray(array: DeepImmutable<ArrayLike<number>>, offset?: number): this;
     /**
      * Returns a new Color4 object from the current Color3 and the given alpha
      * @param alpha defines the alpha component on the new Color4 object (default is 1)
@@ -73,7 +83,7 @@ export declare class Color3 {
      * Returns a new array populated with 3 numeric elements : red, green and blue values
      * @returns the new array
      */
-    asArray(): number[];
+    asArray(): Tuple<number, 3>;
     /**
      * Returns the luminance value
      * @returns a float value
@@ -84,20 +94,105 @@ export declare class Color3 {
      * @param otherColor defines the second operand
      * @returns the new Color3 object
      */
-    multiply(otherColor: DeepImmutable<Color3>): Color3;
+    multiply(otherColor: DeepImmutable<this>): this;
     /**
      * Multiply the rgb values of the Color3 and the given Color3 and stores the result in the object "result"
      * @param otherColor defines the second operand
      * @param result defines the Color3 object where to store the result
-     * @returns the current Color3
+     * @returns the result Color3
+     */
+    multiplyToRef<T extends this>(otherColor: DeepImmutable<this>, result: T): T;
+    /**
+     * Multiplies the current Color3 coordinates by the given ones
+     * @param otherColor defines the second operand
+     * @returns the current updated Color3
+     */
+    multiplyInPlace(otherColor: DeepImmutable<Color3>): this;
+    /**
+     * Returns a new Color3 set with the result of the multiplication of the current Color3 coordinates by the given floats
+     * @param r defines the r coordinate of the operand
+     * @param g defines the g coordinate of the operand
+     * @param b defines the b coordinate of the operand
+     * @returns the new Color3
+     */
+    multiplyByFloats(r: number, g: number, b: number): this;
+    /**
+     * @internal
+     * Do not use
+     */
+    divide(_other: DeepImmutable<this>): this;
+    /**
+     * @internal
+     * Do not use
+     */
+    divideToRef<T extends this>(_other: DeepImmutable<this>, _result: T): T;
+    /**
+     * @internal
+     * Do not use
+     */
+    divideInPlace(_other: DeepImmutable<this>): this;
+    /**
+     * Updates the current Color3 with the minimal coordinate values between its and the given color ones
+     * @param other defines the second operand
+     * @returns the current updated Color3
+     */
+    minimizeInPlace(other: DeepImmutable<this>): this;
+    /**
+     * Updates the current Color3 with the maximal coordinate values between its and the given color ones.
+     * @param other defines the second operand
+     * @returns the current updated Color3
+     */
+    maximizeInPlace(other: DeepImmutable<this>): this;
+    /**
+     * Updates the current Color3 with the minimal coordinate values between its and the given coordinates
+     * @param r defines the r coordinate of the operand
+     * @param g defines the g coordinate of the operand
+     * @param b defines the b coordinate of the operand
+     * @returns the current updated Color3
+     */
+    minimizeInPlaceFromFloats(r: number, g: number, b: number): this;
+    /**
+     * Updates the current Color3 with the maximal coordinate values between its and the given coordinates.
+     * @param r defines the r coordinate of the operand
+     * @param g defines the g coordinate of the operand
+     * @param b defines the b coordinate of the operand
+     * @returns the current updated Color3
+     */
+    maximizeInPlaceFromFloats(r: number, g: number, b: number): this;
+    /**
+     * @internal
+     * Do not use
+     */
+    floorToRef<T extends this>(_result: T): T;
+    /**
+     * @internal
+     * Do not use
+     */
+    floor(): this;
+    /**
+     * @internal
+     * Do not use
+     */
+    fractToRef<T extends this>(_result: T): T;
+    /**
+     * @internal
+     * Do not use
      */
-    multiplyToRef(otherColor: DeepImmutable<Color3>, result: Color3): Color3;
+    fract(): this;
     /**
      * Determines equality between Color3 objects
      * @param otherColor defines the second operand
      * @returns true if the rgb values are equal to the given ones
      */
-    equals(otherColor: DeepImmutable<Color3>): boolean;
+    equals(otherColor: DeepImmutable<this>): boolean;
+    /**
+     * Alias for equalsToFloats
+     * @param r red color component
+     * @param g green color component
+     * @param b blue color component
+     * @returns boolean
+     */
+    equalsFloats(r: number, g: number, b: number): boolean;
     /**
      * Determines equality between the current Color3 object and a set of r,b,g values
      * @param r defines the red component to check
@@ -105,78 +200,137 @@ export declare class Color3 {
      * @param b defines the blue component to check
      * @returns true if the rgb values are equal to the given ones
      */
-    equalsFloats(r: number, g: number, b: number): boolean;
+    equalsToFloats(r: number, g: number, b: number): boolean;
+    /**
+     * Returns true if the current Color3 and the given color coordinates are distant less than epsilon
+     * @param otherColor defines the second operand
+     * @param epsilon defines the minimal distance to define values as equals
+     * @returns true if both colors are distant less than epsilon
+     */
+    equalsWithEpsilon(otherColor: DeepImmutable<this>, epsilon?: number): boolean;
+    /**
+     * @internal
+     * Do not use
+     */
+    negate(): this;
+    /**
+     * @internal
+     * Do not use
+     */
+    negateInPlace(): this;
+    /**
+     * @internal
+     * Do not use
+     */
+    negateToRef<T extends this>(_result: T): T;
     /**
      * Creates a new Color3 with the current Color3 values multiplied by scale
      * @param scale defines the scaling factor to apply
      * @returns a new Color3 object
      */
-    scale(scale: number): Color3;
+    scale(scale: number): this;
     /**
      * Multiplies the Color3 values by the float "scale"
      * @param scale defines the scaling factor to apply
      * @returns the current updated Color3
      */
-    scaleInPlace(scale: number): Color3;
+    scaleInPlace(scale: number): this;
     /**
      * Multiplies the rgb values by scale and stores the result into "result"
      * @param scale defines the scaling factor
      * @param result defines the Color3 object where to store the result
-     * @returns the unmodified current Color3
+     * @returns the result Color3
      */
-    scaleToRef(scale: number, result: Color3): Color3;
+    scaleToRef<T extends this>(scale: number, result: T): T;
     /**
      * Scale the current Color3 values by a factor and add the result to a given Color3
      * @param scale defines the scale factor
      * @param result defines color to store the result into
-     * @returns the unmodified current Color3
+     * @returns the result Color3
      */
-    scaleAndAddToRef(scale: number, result: Color3): Color3;
+    scaleAndAddToRef<T extends this>(scale: number, result: T): T;
     /**
      * Clamps the rgb values by the min and max values and stores the result into "result"
      * @param min defines minimum clamping value (default is 0)
      * @param max defines maximum clamping value (default is 1)
      * @param result defines color to store the result into
-     * @returns the original Color3
+     * @returns the result Color3
      */
-    clampToRef(min: number | undefined, max: number | undefined, result: Color3): Color3;
+    clampToRef<T extends this>(min: number | undefined, max: number | undefined, result: T): T;
     /**
      * Creates a new Color3 set with the added values of the current Color3 and of the given one
      * @param otherColor defines the second operand
      * @returns the new Color3
      */
-    add(otherColor: DeepImmutable<Color3>): Color3;
+    add(otherColor: DeepImmutable<this>): this;
+    /**
+     * Adds the given color to the current Color3
+     * @param otherColor defines the second operand
+     * @returns the current updated Color3
+     */
+    addInPlace(otherColor: DeepImmutable<this>): this;
+    /**
+     * Adds the given coordinates to the current Color3
+     * @param r defines the r coordinate of the operand
+     * @param g defines the g coordinate of the operand
+     * @param b defines the b coordinate of the operand
+     * @returns the current updated Color3
+     */
+    addInPlaceFromFloats(r: number, g: number, b: number): this;
     /**
      * Stores the result of the addition of the current Color3 and given one rgb values into "result"
      * @param otherColor defines the second operand
      * @param result defines Color3 object to store the result into
      * @returns the unmodified current Color3
      */
-    addToRef(otherColor: DeepImmutable<Color3>, result: Color3): Color3;
+    addToRef<T extends this>(otherColor: DeepImmutable<this>, result: T): T;
     /**
      * Returns a new Color3 set with the subtracted values of the given one from the current Color3
      * @param otherColor defines the second operand
      * @returns the new Color3
      */
-    subtract(otherColor: DeepImmutable<Color3>): Color3;
+    subtract(otherColor: DeepImmutable<this>): this;
     /**
      * Stores the result of the subtraction of given one from the current Color3 rgb values into "result"
      * @param otherColor defines the second operand
      * @param result defines Color3 object to store the result into
      * @returns the unmodified current Color3
      */
-    subtractToRef(otherColor: DeepImmutable<Color3>, result: Color3): Color3;
+    subtractToRef<T extends this>(otherColor: DeepImmutable<this>, result: T): T;
+    /**
+     * Subtract the given color from the current Color3
+     * @param otherColor defines the second operand
+     * @returns the current updated Color3
+     */
+    subtractInPlace(otherColor: DeepImmutable<this>): this;
+    /**
+     * Returns a new Color3 set with the subtraction of the given floats from the current Color3 coordinates
+     * @param r defines the r coordinate of the operand
+     * @param g defines the g coordinate of the operand
+     * @param b defines the b coordinate of the operand
+     * @returns the resulting Color3
+     */
+    subtractFromFloats(r: number, g: number, b: number): this;
+    /**
+     * Subtracts the given floats from the current Color3 coordinates and set the given color "result" with this result
+     * @param r defines the r coordinate of the operand
+     * @param g defines the g coordinate of the operand
+     * @param b defines the b coordinate of the operand
+     * @param result defines the Color3 object where to store the result
+     * @returns the result
+     */
+    subtractFromFloatsToRef<T extends Color3>(r: number, g: number, b: number, result: T): T;
     /**
      * Copy the current object
      * @returns a new Color3 copied the current one
      */
-    clone(): Color3;
+    clone(): this;
     /**
      * Copies the rgb values from the source in the current Color3
      * @param source defines the source Color3 object
      * @returns the updated Color3 object
      */
-    copyFrom(source: DeepImmutable<Color3>): Color3;
+    copyFrom(source: DeepImmutable<this>): this;
     /**
      * Updates the Color3 rgb values from the given floats
      * @param r defines the red component to read from
@@ -184,7 +338,7 @@ export declare class Color3 {
      * @param b defines the blue component to read from
      * @returns the current Color3 object
      */
-    copyFromFloats(r: number, g: number, b: number): Color3;
+    copyFromFloats(r: number, g: number, b: number): this;
     /**
      * Updates the Color3 rgb values from the given floats
      * @param r defines the red component to read from
@@ -192,7 +346,13 @@ export declare class Color3 {
      * @param b defines the blue component to read from
      * @returns the current Color3 object
      */
-    set(r: number, g: number, b: number): Color3;
+    set(r: number, g: number, b: number): this;
+    /**
+     * Copies the given float to the current Color3 coordinates
+     * @param v defines the r, g and b coordinates of the operand
+     * @returns the current updated Color3
+     */
+    setAll(v: number): this;
     /**
      * Compute the Color3 hexadecimal code as a string
      * @returns a string containing the hexadecimal representation of the Color3 object
@@ -202,38 +362,38 @@ export declare class Color3 {
      * Converts current color in rgb space to HSV values
      * @returns a new color3 representing the HSV values
      */
-    toHSV(): Color3;
+    toHSV(): this;
     /**
      * Converts current color in rgb space to HSV values
      * @param result defines the Color3 where to store the HSV values
      */
-    toHSVToRef(result: Color3): void;
+    toHSVToRef(result: this): void;
     /**
      * Computes a new Color3 converted from the current one to linear space
      * @param exact defines if the conversion will be done in an exact way which is slower but more accurate (default is false)
      * @returns a new Color3 object
      */
-    toLinearSpace(exact?: boolean): Color3;
+    toLinearSpace(exact?: boolean): this;
     /**
      * Converts the Color3 values to linear space and stores the result in "convertedColor"
      * @param convertedColor defines the Color3 object where to store the linear space version
      * @param exact defines if the conversion will be done in an exact way which is slower but more accurate (default is false)
      * @returns the unmodified Color3
      */
-    toLinearSpaceToRef(convertedColor: Color3, exact?: boolean): Color3;
+    toLinearSpaceToRef(convertedColor: this, exact?: boolean): this;
     /**
      * Computes a new Color3 converted from the current one to gamma space
      * @param exact defines if the conversion will be done in an exact way which is slower but more accurate (default is false)
      * @returns a new Color3 object
      */
-    toGammaSpace(exact?: boolean): Color3;
+    toGammaSpace(exact?: boolean): this;
     /**
      * Converts the Color3 values to gamma space and stores the result in "convertedColor"
      * @param convertedColor defines the Color3 object where to store the gamma space version
      * @param exact defines if the conversion will be done in an exact way which is slower but more accurate (default is false)
      * @returns the unmodified Color3
      */
-    toGammaSpaceToRef(convertedColor: Color3, exact?: boolean): Color3;
+    toGammaSpaceToRef(convertedColor: this, exact?: boolean): this;
     private static _BlackReadOnly;
     /**
      * Converts Hue, saturation and value to a Color3 (RGB)
@@ -272,7 +432,7 @@ export declare class Color3 {
      */
     static FromArrayToRef(array: DeepImmutable<ArrayLike<number>>, offset: number | undefined, result: Color3): void;
     /**
-     * Creates a new Color3 from integer values (< 256)
+     * Creates a new Color3 from integer values (\< 256)
      * @param r defines the red component to read from (value between 0 and 255)
      * @param g defines the green component to read from (value between 0 and 255)
      * @param b defines the blue component to read from (value between 0 and 255)
@@ -388,7 +548,7 @@ export declare class Color3 {
 /**
  * Class used to hold a RBGA color
  */
-export declare class Color4 {
+export declare class Color4 implements Tensor<Tuple<number, 4>>, IColor4Like {
     /**
      * Defines the red component (between 0 and 1, default is 0)
      */
@@ -405,6 +565,14 @@ export declare class Color4 {
      * Defines the alpha component (between 0 and 1, default is 1)
      */
     a: number;
+    /**
+     * @see Tensor.dimension
+     */
+    readonly dimension: [4];
+    /**
+     * @see Tensor.rank
+     */
+    readonly rank: 1;
     /**
      * Creates a new Color4 object from red, green, blue values, all between 0 and 1
      * @param r defines the red component (between 0 and 1, default is 0)
@@ -429,103 +597,255 @@ export declare class Color4 {
      * Defines the alpha component (between 0 and 1, default is 1)
      */
     a?: number);
-    /**
-     * Adds in place the given Color4 values to the current Color4 object
-     * @param right defines the second operand
-     * @returns the current updated Color4 object
-     */
-    addInPlace(right: DeepImmutable<Color4>): Color4;
     /**
      * Creates a new array populated with 4 numeric elements : red, green, blue, alpha values
      * @returns the new array
      */
-    asArray(): number[];
+    asArray(): Tuple<number, 4>;
     /**
      * Stores from the starting index in the given array the Color4 successive values
      * @param array defines the array where to store the r,g,b components
      * @param index defines an optional index in the target array to define where to start storing values
      * @returns the current Color4 object
      */
-    toArray(array: FloatArray, index?: number): Color4;
+    toArray(array: FloatArray, index?: number): this;
     /**
      * Update the current color with values stored in an array from the starting index of the given array
      * @param array defines the source array
      * @param offset defines an offset in the source array
      * @returns the current Color4 object
      */
-    fromArray(array: DeepImmutable<ArrayLike<number>>, offset?: number): Color4;
+    fromArray(array: DeepImmutable<ArrayLike<number>>, offset?: number): this;
     /**
      * Determines equality between Color4 objects
      * @param otherColor defines the second operand
      * @returns true if the rgba values are equal to the given ones
      */
-    equals(otherColor: DeepImmutable<Color4>): boolean;
+    equals(otherColor: DeepImmutable<this>): boolean;
     /**
      * Creates a new Color4 set with the added values of the current Color4 and of the given one
-     * @param right defines the second operand
+     * @param otherColor defines the second operand
      * @returns a new Color4 object
      */
-    add(right: DeepImmutable<Color4>): Color4;
+    add(otherColor: DeepImmutable<this>): this;
+    /**
+     * Updates the given color "result" with the result of the addition of the current Color4 and the given one.
+     * @param otherColor the color to add
+     * @param result the color to store the result
+     * @returns result input
+     */
+    addToRef<T extends Color4>(otherColor: DeepImmutable<this>, result: T): T;
+    /**
+     * Adds in place the given Color4 values to the current Color4 object
+     * @param otherColor defines the second operand
+     * @returns the current updated Color4 object
+     */
+    addInPlace(otherColor: DeepImmutable<this>): this;
+    /**
+     * Adds the given coordinates to the current Color4
+     * @param r defines the r coordinate of the operand
+     * @param g defines the g coordinate of the operand
+     * @param b defines the b coordinate of the operand
+     * @param a defines the a coordinate of the operand
+     * @returns the current updated Color4
+     */
+    addInPlaceFromFloats(r: number, g: number, b: number, a: number): this;
     /**
      * Creates a new Color4 set with the subtracted values of the given one from the current Color4
-     * @param right defines the second operand
+     * @param otherColor defines the second operand
      * @returns a new Color4 object
      */
-    subtract(right: DeepImmutable<Color4>): Color4;
+    subtract(otherColor: DeepImmutable<this>): this;
     /**
      * Subtracts the given ones from the current Color4 values and stores the results in "result"
-     * @param right defines the second operand
+     * @param otherColor defines the second operand
      * @param result defines the Color4 object where to store the result
-     * @returns the current Color4 object
+     * @returns the result Color4 object
+     */
+    subtractToRef<T extends this>(otherColor: DeepImmutable<this>, result: T): T;
+    /**
+     * Subtract in place the given color from the current Color4.
+     * @param otherColor the color to subtract
+     * @returns the updated Color4.
+     */
+    subtractInPlace(otherColor: DeepImmutable<Color4>): this;
+    /**
+     * Returns a new Color4 set with the result of the subtraction of the given floats from the current Color4 coordinates.
+     * @param r value to subtract
+     * @param g value to subtract
+     * @param b value to subtract
+     * @param a value to subtract
+     * @returns new color containing the result
+     */
+    subtractFromFloats(r: number, g: number, b: number, a: number): this;
+    /**
+     * Sets the given color "result" set with the result of the subtraction of the given floats from the current Color4 coordinates.
+     * @param r value to subtract
+     * @param g value to subtract
+     * @param b value to subtract
+     * @param a value to subtract
+     * @param result the color to store the result in
+     * @returns result input
      */
-    subtractToRef(right: DeepImmutable<Color4>, result: Color4): Color4;
+    subtractFromFloatsToRef<T extends Color4>(r: number, g: number, b: number, a: number, result: T): T;
     /**
      * Creates a new Color4 with the current Color4 values multiplied by scale
      * @param scale defines the scaling factor to apply
      * @returns a new Color4 object
      */
-    scale(scale: number): Color4;
+    scale(scale: number): this;
     /**
      * Multiplies the Color4 values by the float "scale"
      * @param scale defines the scaling factor to apply
      * @returns the current updated Color4
      */
-    scaleInPlace(scale: number): Color4;
+    scaleInPlace(scale: number): this;
     /**
      * Multiplies the current Color4 values by scale and stores the result in "result"
      * @param scale defines the scaling factor to apply
      * @param result defines the Color4 object where to store the result
-     * @returns the current unmodified Color4
+     * @returns the result Color4
      */
-    scaleToRef(scale: number, result: Color4): Color4;
+    scaleToRef<T extends this>(scale: number, result: T): T;
     /**
      * Scale the current Color4 values by a factor and add the result to a given Color4
      * @param scale defines the scale factor
      * @param result defines the Color4 object where to store the result
-     * @returns the unmodified current Color4
+     * @returns the result Color4
      */
-    scaleAndAddToRef(scale: number, result: Color4): Color4;
+    scaleAndAddToRef<T extends this>(scale: number, result: T): T;
     /**
      * Clamps the rgb values by the min and max values and stores the result into "result"
      * @param min defines minimum clamping value (default is 0)
      * @param max defines maximum clamping value (default is 1)
      * @param result defines color to store the result into.
-     * @returns the current Color4
+     * @returns the result Color4
      */
-    clampToRef(min: number | undefined, max: number | undefined, result: Color4): Color4;
+    clampToRef<T extends this>(min: number | undefined, max: number | undefined, result: T): T;
     /**
      * Multiply an Color4 value by another and return a new Color4 object
      * @param color defines the Color4 value to multiply by
      * @returns a new Color4 object
      */
-    multiply(color: Color4): Color4;
+    multiply(color: DeepImmutable<this>): this;
     /**
      * Multiply a Color4 value by another and push the result in a reference value
      * @param color defines the Color4 value to multiply by
      * @param result defines the Color4 to fill the result in
      * @returns the result Color4
      */
-    multiplyToRef(color: Color4, result: Color4): Color4;
+    multiplyToRef<T extends this>(color: DeepImmutable<this>, result: T): T;
+    /**
+     * Multiplies in place the current Color4 by the given one.
+     * @param otherColor color to multiple with
+     * @returns the updated Color4.
+     */
+    multiplyInPlace(otherColor: DeepImmutable<Color4>): this;
+    /**
+     * Returns a new Color4 set with the multiplication result of the given floats and the current Color4 coordinates.
+     * @param r value multiply with
+     * @param g value multiply with
+     * @param b value multiply with
+     * @param a value multiply with
+     * @returns resulting new color
+     */
+    multiplyByFloats(r: number, g: number, b: number, a: number): this;
+    /**
+     * @internal
+     * Do not use
+     */
+    divide(_other: DeepImmutable<this>): this;
+    /**
+     * @internal
+     * Do not use
+     */
+    divideToRef<T extends this>(_other: DeepImmutable<this>, _result: T): T;
+    /**
+     * @internal
+     * Do not use
+     */
+    divideInPlace(_other: DeepImmutable<this>): this;
+    /**
+     * Updates the Color4 coordinates with the minimum values between its own and the given color ones
+     * @param other defines the second operand
+     * @returns the current updated Color4
+     */
+    minimizeInPlace(other: DeepImmutable<Color4>): this;
+    /**
+     * Updates the Color4 coordinates with the maximum values between its own and the given color ones
+     * @param other defines the second operand
+     * @returns the current updated Color4
+     */
+    maximizeInPlace(other: DeepImmutable<Color4>): this;
+    /**
+     * Updates the current Color4 with the minimal coordinate values between its and the given coordinates
+     * @param r defines the r coordinate of the operand
+     * @param g defines the g coordinate of the operand
+     * @param b defines the b coordinate of the operand
+     * @param a defines the a coordinate of the operand
+     * @returns the current updated Color4
+     */
+    minimizeInPlaceFromFloats(r: number, g: number, b: number, a: number): this;
+    /**
+     * Updates the current Color4 with the maximal coordinate values between its and the given coordinates.
+     * @param r defines the r coordinate of the operand
+     * @param g defines the g coordinate of the operand
+     * @param b defines the b coordinate of the operand
+     * @param a defines the a coordinate of the operand
+     * @returns the current updated Color4
+     */
+    maximizeInPlaceFromFloats(r: number, g: number, b: number, a: number): this;
+    /**
+     * @internal
+     * Do not use
+     */
+    floorToRef<T extends this>(_result: T): T;
+    /**
+     * @internal
+     * Do not use
+     */
+    floor(): this;
+    /**
+     * @internal
+     * Do not use
+     */
+    fractToRef<T extends this>(_result: T): T;
+    /**
+     * @internal
+     * Do not use
+     */
+    fract(): this;
+    /**
+     * @internal
+     * Do not use
+     */
+    negate(): this;
+    /**
+     * @internal
+     * Do not use
+     */
+    negateInPlace(): this;
+    /**
+     * @internal
+     * Do not use
+     */
+    negateToRef<T extends this>(_result: T): T;
+    /**
+     * Boolean : True if the current Color4 coordinates are each beneath the distance "epsilon" from the given color ones.
+     * @param otherColor color to compare against
+     * @param epsilon (Default: very small number)
+     * @returns true if they are equal
+     */
+    equalsWithEpsilon(otherColor: DeepImmutable<Color4>, epsilon?: number): boolean;
+    /**
+     * Boolean : True if the given floats are strictly equal to the current Color4 coordinates.
+     * @param x x value to compare against
+     * @param y y value to compare against
+     * @param z z value to compare against
+     * @param w w value to compare against
+     * @returns true if equal
+     */
+    equalsToFloats(x: number, y: number, z: number, w: number): boolean;
     /**
      * Creates a string with the Color4 current values
      * @returns the string representation of the Color4 object
@@ -545,13 +865,13 @@ export declare class Color4 {
      * Creates a new Color4 copied from the current one
      * @returns a new Color4 object
      */
-    clone(): Color4;
+    clone(): this;
     /**
      * Copies the given Color4 values into the current one
      * @param source defines the source Color4 object
      * @returns the current updated Color4 object
      */
-    copyFrom(source: Color4): Color4;
+    copyFrom(source: DeepImmutable<Color4>): this;
     /**
      * Copies the given float values into the current one
      * @param r defines the red component to read from
@@ -560,7 +880,7 @@ export declare class Color4 {
      * @param a defines the alpha component to read from
      * @returns the current updated Color4 object
      */
-    copyFromFloats(r: number, g: number, b: number, a: number): Color4;
+    copyFromFloats(r: number, g: number, b: number, a: number): this;
     /**
      * Copies the given float values into the current one
      * @param r defines the red component to read from
@@ -569,7 +889,13 @@ export declare class Color4 {
      * @param a defines the alpha component to read from
      * @returns the current updated Color4 object
      */
-    set(r: number, g: number, b: number, a: number): Color4;
+    set(r: number, g: number, b: number, a: number): this;
+    /**
+     * Copies the given float to the current Vector4 coordinates
+     * @param v defines the r, g, b, and a coordinates of the operand
+     * @returns the current updated Vector4
+     */
+    setAll(v: number): this;
     /**
      * Compute the Color4 hexadecimal code as a string
      * @param returnAsColor3 defines if the string should only contains RGB values (off by default)
@@ -685,7 +1011,7 @@ export declare class Color4 {
      */
     static FromArrayToRef(array: DeepImmutable<ArrayLike<number>>, offset: number | undefined, result: Color4): void;
     /**
-     * Creates a new Color3 from integer values (< 256)
+     * Creates a new Color3 from integer values (less than 256)
      * @param r defines the red component to read from (value between 0 and 255)
      * @param g defines the green component to read from (value between 0 and 255)
      * @param b defines the blue component to read from (value between 0 and 255)