@babylonjs/core 6.45.0 → 6.46.0

package/Maths/math.color.js

@@ -1,5 +1,6 @@
 import { Scalar } from "./math.scalar.js";
-import { ToLinearSpace, ToGammaSpace } from "./math.constants.js";
+import { Clamp, ToHex } from "./math.scalar.functions.js";
+import { ToLinearSpace, ToGammaSpace, Epsilon } from "./math.constants.js";
 import { ArrayTools } from "../Misc/arrayTools.js";
 import { RegisterClass } from "../Misc/typeStore.js";
 function colorChannelToLinearSpace(color) {
@@ -122,20 +123,132 @@ export class Color3 {
      * @returns the new Color3 object
      */
     multiply(otherColor) {
-        return new Color3(this.r * otherColor.r, this.g * otherColor.g, this.b * otherColor.b);
+        return new this.constructor(this.r * otherColor.r, this.g * otherColor.g, this.b * otherColor.b);
     }
     /**
      * 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(otherColor, result) {
         result.r = this.r * otherColor.r;
         result.g = this.g * otherColor.g;
         result.b = this.b * otherColor.b;
+        return result;
+    }
+    /**
+     * Multiplies the current Color3 coordinates by the given ones
+     * @param otherColor defines the second operand
+     * @returns the current updated Color3
+     */
+    multiplyInPlace(otherColor) {
+        this.r *= otherColor.r;
+        this.g *= otherColor.g;
+        this.b *= otherColor.b;
+        return 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, g, b) {
+        return new this.constructor(this.r * r, this.g * g, this.b * b);
+    }
+    /**
+     * @internal
+     * Do not use
+     */
+    divide(_other) {
+        throw new ReferenceError("Can not divide a color");
+    }
+    /**
+     * @internal
+     * Do not use
+     */
+    divideToRef(_other, _result) {
+        throw new ReferenceError("Can not divide a color");
+    }
+    /**
+     * @internal
+     * Do not use
+     */
+    divideInPlace(_other) {
+        throw new ReferenceError("Can not divide a color");
+    }
+    /**
+     * 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) {
+        return this.minimizeInPlaceFromFloats(other.r, other.g, other.b);
+    }
+    /**
+     * 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) {
+        return this.maximizeInPlaceFromFloats(other.r, other.g, other.b);
+    }
+    /**
+     * 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, g, b) {
+        this.r = Math.min(r, this.r);
+        this.g = Math.min(g, this.g);
+        this.b = Math.min(b, this.b);
+        return 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, g, b) {
+        this.r = Math.max(r, this.r);
+        this.g = Math.max(g, this.g);
+        this.b = Math.max(b, this.b);
         return this;
     }
+    /**
+     * @internal
+     * Do not use
+     */
+    floorToRef(_result) {
+        throw new ReferenceError("Can not floor a color");
+    }
+    /**
+     * @internal
+     * Do not use
+     */
+    floor() {
+        throw new ReferenceError("Can not floor a color");
+    }
+    /**
+     * @internal
+     * Do not use
+     */
+    fractToRef(_result) {
+        throw new ReferenceError("Can not fract a color");
+    }
+    /**
+     * @internal
+     * Do not use
+     */
+    fract() {
+        throw new ReferenceError("Can not fract a color");
+    }
     /**
      * Determines equality between Color3 objects
      * @param otherColor defines the second operand
@@ -144,6 +257,16 @@ export class Color3 {
     equals(otherColor) {
         return otherColor && this.r === otherColor.r && this.g === otherColor.g && this.b === otherColor.b;
     }
+    /**
+     * Alias for equalsToFloats
+     * @param r red color component
+     * @param g green color component
+     * @param b blue color component
+     * @returns boolean
+     */
+    equalsFloats(r, g, b) {
+        return this.equalsToFloats(r, g, b);
+    }
     /**
      * Determines equality between the current Color3 object and a set of r,b,g values
      * @param r defines the red component to check
@@ -151,16 +274,46 @@ export class Color3 {
      * @param b defines the blue component to check
      * @returns true if the rgb values are equal to the given ones
      */
-    equalsFloats(r, g, b) {
+    equalsToFloats(r, g, b) {
         return this.r === r && this.g === g && this.b === b;
     }
+    /**
+     * 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, epsilon = Epsilon) {
+        return Scalar.WithinEpsilon(this.r, otherColor.r, epsilon) && Scalar.WithinEpsilon(this.g, otherColor.g, epsilon) && Scalar.WithinEpsilon(this.b, otherColor.b, epsilon);
+    }
+    /**
+     * @internal
+     * Do not use
+     */
+    negate() {
+        throw new ReferenceError("Can not negate a color");
+    }
+    /**
+     * @internal
+     * Do not use
+     */
+    negateInPlace() {
+        throw new ReferenceError("Can not negate a color");
+    }
+    /**
+     * @internal
+     * Do not use
+     */
+    negateToRef(_result) {
+        throw new ReferenceError("Can not negate a color");
+    }
     /**
      * 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) {
-        return new Color3(this.r * scale, this.g * scale, this.b * scale);
+        return new this.constructor(this.r * scale, this.g * scale, this.b * scale);
     }
     /**
      * Multiplies the Color3 values by the float "scale"
@@ -177,38 +330,38 @@ export class Color3 {
      * 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, result) {
         result.r = this.r * scale;
         result.g = this.g * scale;
         result.b = this.b * scale;
-        return this;
+        return result;
     }
     /**
      * 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, result) {
         result.r += this.r * scale;
         result.g += this.g * scale;
         result.b += this.b * scale;
-        return this;
+        return result;
     }
     /**
      * 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 = 0, max = 1, result) {
-        result.r = Scalar.Clamp(this.r, min, max);
-        result.g = Scalar.Clamp(this.g, min, max);
-        result.b = Scalar.Clamp(this.b, min, max);
-        return this;
+        result.r = Clamp(this.r, min, max);
+        result.g = Clamp(this.g, min, max);
+        result.b = Clamp(this.b, min, max);
+        return result;
     }
     /**
      * Creates a new Color3 set with the added values of the current Color3 and of the given one
@@ -216,7 +369,31 @@ export class Color3 {
      * @returns the new Color3
      */
     add(otherColor) {
-        return new Color3(this.r + otherColor.r, this.g + otherColor.g, this.b + otherColor.b);
+        return new this.constructor(this.r + otherColor.r, this.g + otherColor.g, this.b + otherColor.b);
+    }
+    /**
+     * Adds the given color to the current Color3
+     * @param otherColor defines the second operand
+     * @returns the current updated Color3
+     */
+    addInPlace(otherColor) {
+        this.r += otherColor.r;
+        this.g += otherColor.g;
+        this.b += otherColor.b;
+        return 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, g, b) {
+        this.r += r;
+        this.g += g;
+        this.b += b;
+        return this;
     }
     /**
      * Stores the result of the addition of the current Color3 and given one rgb values into "result"
@@ -228,7 +405,7 @@ export class Color3 {
         result.r = this.r + otherColor.r;
         result.g = this.g + otherColor.g;
         result.b = this.b + otherColor.b;
-        return this;
+        return result;
     }
     /**
      * Returns a new Color3 set with the subtracted values of the given one from the current Color3
@@ -236,7 +413,7 @@ export class Color3 {
      * @returns the new Color3
      */
     subtract(otherColor) {
-        return new Color3(this.r - otherColor.r, this.g - otherColor.g, this.b - otherColor.b);
+        return new this.constructor(this.r - otherColor.r, this.g - otherColor.g, this.b - otherColor.b);
     }
     /**
      * Stores the result of the subtraction of given one from the current Color3 rgb values into "result"
@@ -248,14 +425,46 @@ export class Color3 {
         result.r = this.r - otherColor.r;
         result.g = this.g - otherColor.g;
         result.b = this.b - otherColor.b;
+        return result;
+    }
+    /**
+     * Subtract the given color from the current Color3
+     * @param otherColor defines the second operand
+     * @returns the current updated Color3
+     */
+    subtractInPlace(otherColor) {
+        this.r -= otherColor.r;
+        this.g -= otherColor.g;
+        this.b -= otherColor.b;
         return 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, g, b) {
+        return new this.constructor(this.r - r, this.g - g, this.b - b);
+    }
+    /**
+     * 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(r, g, b, result) {
+        return result.copyFromFloats(this.r - r, this.g - g, this.b - b);
+    }
     /**
      * Copy the current object
      * @returns a new Color3 copied the current one
      */
     clone() {
-        return new Color3(this.r, this.g, this.b);
+        return new this.constructor(this.r, this.g, this.b);
     }
     /**
      * Copies the rgb values from the source in the current Color3
@@ -291,6 +500,15 @@ export class Color3 {
     set(r, g, b) {
         return this.copyFromFloats(r, g, b);
     }
+    /**
+     * 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) {
+        this.r = this.g = this.b = v;
+        return this;
+    }
     /**
      * Compute the Color3 hexadecimal code as a string
      * @returns a string containing the hexadecimal representation of the Color3 object
@@ -299,14 +517,14 @@ export class Color3 {
         const intR = Math.round(this.r * 255);
         const intG = Math.round(this.g * 255);
         const intB = Math.round(this.b * 255);
-        return "#" + Scalar.ToHex(intR) + Scalar.ToHex(intG) + Scalar.ToHex(intB);
+        return "#" + ToHex(intR) + ToHex(intG) + ToHex(intB);
     }
     /**
      * Converts current color in rgb space to HSV values
      * @returns a new color3 representing the HSV values
      */
     toHSV() {
-        const result = new Color3();
+        const result = new this.constructor();
         this.toHSVToRef(result);
         return result;
     }
@@ -352,7 +570,7 @@ export class Color3 {
      * @returns a new Color3 object
      */
     toLinearSpace(exact = false) {
-        const convertedColor = new Color3();
+        const convertedColor = new this.constructor();
         this.toLinearSpaceToRef(convertedColor, exact);
         return convertedColor;
     }
@@ -381,7 +599,7 @@ export class Color3 {
      * @returns a new Color3 object
      */
     toGammaSpace(exact = false) {
-        const convertedColor = new Color3();
+        const convertedColor = new this.constructor();
         this.toGammaSpaceToRef(convertedColor, exact);
         return convertedColor;
     }
@@ -492,7 +710,7 @@ export class Color3 {
         result.b = array[offset + 2];
     }
     /**
-     * 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)
@@ -661,6 +879,10 @@ export class Color3 {
 }
 // Statics
 Color3._BlackReadOnly = Color3.Black();
+Object.defineProperties(Color3.prototype, {
+    dimension: { value: [3] },
+    rank: { value: 1 },
+});
 /**
  * Class used to hold a RBGA color
  */
@@ -695,18 +917,6 @@ export class Color4 {
         this.a = a;
     }
     // Operators
-    /**
-     * 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) {
-        this.r += right.r;
-        this.g += right.g;
-        this.b += right.b;
-        this.a += right.a;
-        return this;
-    }
     /**
      * Creates a new array populated with 4 numeric elements : red, green, blue, alpha values
      * @returns the new array
@@ -734,7 +944,10 @@ export class Color4 {
      * @returns the current Color4 object
      */
     fromArray(array, offset = 0) {
-        Color4.FromArrayToRef(array, offset, this);
+        this.r = array[offset];
+        this.g = array[offset + 1];
+        this.b = array[offset + 2];
+        this.a = array[offset + 3];
         return this;
     }
     /**
@@ -747,40 +960,119 @@ export class Color4 {
     }
     /**
      * 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) {
-        return new Color4(this.r + right.r, this.g + right.g, this.b + right.b, this.a + right.a);
+    add(otherColor) {
+        return new this.constructor(this.r + otherColor.r, this.g + otherColor.g, this.b + otherColor.b, this.a + otherColor.a);
+    }
+    /**
+     * 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(otherColor, result) {
+        result.r = this.r + otherColor.r;
+        result.g = this.g + otherColor.g;
+        result.b = this.b + otherColor.b;
+        result.a = this.a + otherColor.a;
+        return result;
+    }
+    /**
+     * 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) {
+        this.r += otherColor.r;
+        this.g += otherColor.g;
+        this.b += otherColor.b;
+        this.a += otherColor.a;
+        return 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, g, b, a) {
+        this.r += r;
+        this.g += g;
+        this.b += b;
+        this.a += a;
+        return 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) {
-        return new Color4(this.r - right.r, this.g - right.g, this.b - right.b, this.a - right.a);
+    subtract(otherColor) {
+        return new this.constructor(this.r - otherColor.r, this.g - otherColor.g, this.b - otherColor.b, this.a - otherColor.a);
     }
     /**
      * 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(right, result) {
-        result.r = this.r - right.r;
-        result.g = this.g - right.g;
-        result.b = this.b - right.b;
-        result.a = this.a - right.a;
+    subtractToRef(otherColor, result) {
+        result.r = this.r - otherColor.r;
+        result.g = this.g - otherColor.g;
+        result.b = this.b - otherColor.b;
+        result.a = this.a - otherColor.a;
+        return result;
+    }
+    /**
+     * Subtract in place the given color from the current Color4.
+     * @param otherColor the color to subtract
+     * @returns the updated Color4.
+     */
+    subtractInPlace(otherColor) {
+        this.r -= otherColor.r;
+        this.g -= otherColor.g;
+        this.b -= otherColor.b;
+        this.a -= otherColor.a;
         return 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, g, b, a) {
+        return new this.constructor(this.r - r, this.g - g, this.b - b, this.a - a);
+    }
+    /**
+     * 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
+     */
+    subtractFromFloatsToRef(r, g, b, a, result) {
+        result.r = this.r - r;
+        result.g = this.g - g;
+        result.b = this.b - b;
+        result.a = this.a - a;
+        return result;
+    }
     /**
      * 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) {
-        return new Color4(this.r * scale, this.g * scale, this.b * scale, this.a * scale);
+        return new this.constructor(this.r * scale, this.g * scale, this.b * scale, this.a * scale);
     }
     /**
      * Multiplies the Color4 values by the float "scale"
@@ -798,41 +1090,41 @@ export class Color4 {
      * 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, result) {
         result.r = this.r * scale;
         result.g = this.g * scale;
         result.b = this.b * scale;
         result.a = this.a * scale;
-        return this;
+        return result;
     }
     /**
      * 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, result) {
         result.r += this.r * scale;
         result.g += this.g * scale;
         result.b += this.b * scale;
         result.a += this.a * scale;
-        return this;
+        return result;
     }
     /**
      * 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 = 0, max = 1, result) {
-        result.r = Scalar.Clamp(this.r, min, max);
-        result.g = Scalar.Clamp(this.g, min, max);
-        result.b = Scalar.Clamp(this.b, min, max);
-        result.a = Scalar.Clamp(this.a, min, max);
-        return this;
+        result.r = Clamp(this.r, min, max);
+        result.g = Clamp(this.g, min, max);
+        result.b = Clamp(this.b, min, max);
+        result.a = Clamp(this.a, min, max);
+        return result;
     }
     /**
      * Multiply an Color4 value by another and return a new Color4 object
@@ -840,7 +1132,7 @@ export class Color4 {
      * @returns a new Color4 object
      */
     multiply(color) {
-        return new Color4(this.r * color.r, this.g * color.g, this.b * color.b, this.a * color.a);
+        return new this.constructor(this.r * color.r, this.g * color.g, this.b * color.b, this.a * color.a);
     }
     /**
      * Multiply a Color4 value by another and push the result in a reference value
@@ -855,6 +1147,176 @@ export class Color4 {
         result.a = this.a * color.a;
         return result;
     }
+    /**
+     * Multiplies in place the current Color4 by the given one.
+     * @param otherColor color to multiple with
+     * @returns the updated Color4.
+     */
+    multiplyInPlace(otherColor) {
+        this.r *= otherColor.r;
+        this.g *= otherColor.g;
+        this.b *= otherColor.b;
+        this.a *= otherColor.a;
+        return 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, g, b, a) {
+        return new this.constructor(this.r * r, this.g * g, this.b * b, this.a * a);
+    }
+    /**
+     * @internal
+     * Do not use
+     */
+    divide(_other) {
+        throw new ReferenceError("Can not divide a color");
+    }
+    /**
+     * @internal
+     * Do not use
+     */
+    divideToRef(_other, _result) {
+        throw new ReferenceError("Can not divide a color");
+    }
+    /**
+     * @internal
+     * Do not use
+     */
+    divideInPlace(_other) {
+        throw new ReferenceError("Can not divide a color");
+    }
+    /**
+     * 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) {
+        this.r = Math.min(this.r, other.r);
+        this.g = Math.min(this.g, other.g);
+        this.b = Math.min(this.b, other.b);
+        this.a = Math.min(this.a, other.a);
+        return 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) {
+        this.r = Math.max(this.r, other.r);
+        this.g = Math.max(this.g, other.g);
+        this.b = Math.max(this.b, other.b);
+        this.a = Math.max(this.a, other.a);
+        return 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, g, b, a) {
+        this.r = Math.min(r, this.r);
+        this.g = Math.min(g, this.g);
+        this.b = Math.min(b, this.b);
+        this.a = Math.min(a, this.a);
+        return 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, g, b, a) {
+        this.r = Math.max(r, this.r);
+        this.g = Math.max(g, this.g);
+        this.b = Math.max(b, this.b);
+        this.a = Math.max(a, this.a);
+        return this;
+    }
+    /**
+     * @internal
+     * Do not use
+     */
+    floorToRef(_result) {
+        throw new ReferenceError("Can not floor a color");
+    }
+    /**
+     * @internal
+     * Do not use
+     */
+    floor() {
+        throw new ReferenceError("Can not floor a color");
+    }
+    /**
+     * @internal
+     * Do not use
+     */
+    fractToRef(_result) {
+        throw new ReferenceError("Can not fract a color");
+    }
+    /**
+     * @internal
+     * Do not use
+     */
+    fract() {
+        throw new ReferenceError("Can not fract a color");
+    }
+    /**
+     * @internal
+     * Do not use
+     */
+    negate() {
+        throw new ReferenceError("Can not negate a color");
+    }
+    /**
+     * @internal
+     * Do not use
+     */
+    negateInPlace() {
+        throw new ReferenceError("Can not negate a color");
+    }
+    /**
+     * @internal
+     * Do not use
+     */
+    negateToRef(_result) {
+        throw new ReferenceError("Can not negate a color");
+    }
+    /**
+     * 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, epsilon = Epsilon) {
+        return (Scalar.WithinEpsilon(this.r, otherColor.r, epsilon) &&
+            Scalar.WithinEpsilon(this.g, otherColor.g, epsilon) &&
+            Scalar.WithinEpsilon(this.b, otherColor.b, epsilon) &&
+            Scalar.WithinEpsilon(this.a, otherColor.a, epsilon));
+    }
+    /**
+     * 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, y, z, w) {
+        return this.r === x && this.g === y && this.b === z && this.a === w;
+    }
     /**
      * Creates a string with the Color4 current values
      * @returns the string representation of the Color4 object
@@ -885,7 +1347,8 @@ export class Color4 {
      * @returns a new Color4 object
      */
     clone() {
-        return new Color4(this.r, this.g, this.b, this.a);
+        const result = new this.constructor();
+        return result.copyFrom(this);
     }
     /**
      * Copies the given Color4 values into the current one
@@ -925,6 +1388,15 @@ export class Color4 {
     set(r, g, b, a) {
         return this.copyFromFloats(r, g, b, a);
     }
+    /**
+     * 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) {
+        this.r = this.g = this.b = this.a = v;
+        return this;
+    }
     /**
      * Compute the Color4 hexadecimal code as a string
      * @param returnAsColor3 defines if the string should only contains RGB values (off by default)
@@ -935,10 +1407,10 @@ export class Color4 {
         const intG = Math.round(this.g * 255);
         const intB = Math.round(this.b * 255);
         if (returnAsColor3) {
-            return "#" + Scalar.ToHex(intR) + Scalar.ToHex(intG) + Scalar.ToHex(intB);
+            return "#" + ToHex(intR) + ToHex(intG) + ToHex(intB);
         }
         const intA = Math.round(this.a * 255);
-        return "#" + Scalar.ToHex(intR) + Scalar.ToHex(intG) + Scalar.ToHex(intB) + Scalar.ToHex(intA);
+        return "#" + ToHex(intR) + ToHex(intG) + ToHex(intB) + ToHex(intA);
     }
     /**
      * Computes a new Color4 converted from the current one to linear space
@@ -1133,7 +1605,7 @@ export class Color4 {
         result.a = array[offset + 3];
     }
     /**
-     * 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)
@@ -1166,6 +1638,10 @@ export class Color4 {
         return colors;
     }
 }
+Object.defineProperties(Color4.prototype, {
+    dimension: { value: [4] },
+    rank: { value: 1 },
+});
 /**
  * @internal
  */