@spiffcommerce/preview 3.6.2-rc.4 → 3.6.2-rc.5

package/dist/node_modules/@babylonjs/core/Maths/math.color.esm.js

@@ -0,0 +1,903 @@
+import { Scalar as p } from "./math.scalar.esm.js";
+import { ToLinearSpace as G, ToGammaSpace as I } from "./math.constants.esm.js";
+import { ArrayTools as B } from "../Misc/arrayTools.esm.js";
+import { RegisterClass as L } from "../Misc/typeStore.esm.js";
+function R(T) {
+  return Math.pow(T, G);
+}
+function f(T) {
+  return T <= 0.04045 ? 0.0773993808 * T : Math.pow(0.947867299 * (T + 0.055), 2.4);
+}
+function m(T) {
+  return Math.pow(T, I);
+}
+function S(T) {
+  return T <= 31308e-7 ? 12.92 * T : 1.055 * Math.pow(T, 0.41666) - 0.055;
+}
+class b {
+  /**
+   * 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)
+   * @param g defines the green component (between 0 and 1, default is 0)
+   * @param b defines the blue component (between 0 and 1, default is 0)
+   */
+  constructor(t = 0, s = 0, i = 0) {
+    this.r = t, this.g = s, this.b = i;
+  }
+  /**
+   * Creates a string with the Color3 current values
+   * @returns the string representation of the Color3 object
+   */
+  toString() {
+    return "{R: " + this.r + " G:" + this.g + " B:" + this.b + "}";
+  }
+  /**
+   * Returns the string "Color3"
+   * @returns "Color3"
+   */
+  getClassName() {
+    return "Color3";
+  }
+  /**
+   * Compute the Color3 hash code
+   * @returns an unique number that can be used to hash Color3 objects
+   */
+  getHashCode() {
+    let t = this.r * 255 | 0;
+    return t = t * 397 ^ (this.g * 255 | 0), t = t * 397 ^ (this.b * 255 | 0), t;
+  }
+  // Operators
+  /**
+   * Stores in the given array from the given starting index the red, green, blue values as successive elements
+   * @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 Color3 object
+   */
+  toArray(t, s = 0) {
+    return t[s] = this.r, t[s + 1] = this.g, t[s + 2] = this.b, 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(t, s = 0) {
+    return b.FromArrayToRef(t, s, this), 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)
+   * @returns a new Color4 object
+   */
+  toColor4(t = 1) {
+    return new e(this.r, this.g, this.b, t);
+  }
+  /**
+   * Returns a new array populated with 3 numeric elements : red, green and blue values
+   * @returns the new array
+   */
+  asArray() {
+    return [this.r, this.g, this.b];
+  }
+  /**
+   * Returns the luminance value
+   * @returns a float value
+   */
+  toLuminance() {
+    return this.r * 0.3 + this.g * 0.59 + this.b * 0.11;
+  }
+  /**
+   * Multiply each Color3 rgb values by the given Color3 rgb values in a new Color3 object
+   * @param otherColor defines the second operand
+   * @returns the new Color3 object
+   */
+  multiply(t) {
+    return new b(this.r * t.r, this.g * t.g, this.b * t.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
+   */
+  multiplyToRef(t, s) {
+    return s.r = this.r * t.r, s.g = this.g * t.g, s.b = this.b * t.b, 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(t) {
+    return t && this.r === t.r && this.g === t.g && this.b === t.b;
+  }
+  /**
+   * Determines equality between the current Color3 object and a set of r,b,g values
+   * @param r defines the red component to check
+   * @param g defines the green component to check
+   * @param b defines the blue component to check
+   * @returns true if the rgb values are equal to the given ones
+   */
+  equalsFloats(t, s, i) {
+    return this.r === t && this.g === s && this.b === i;
+  }
+  /**
+   * 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(t) {
+    return new b(this.r * t, this.g * t, this.b * t);
+  }
+  /**
+   * Multiplies the Color3 values by the float "scale"
+   * @param scale defines the scaling factor to apply
+   * @returns the current updated Color3
+   */
+  scaleInPlace(t) {
+    return this.r *= t, this.g *= t, this.b *= t, 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
+   */
+  scaleToRef(t, s) {
+    return s.r = this.r * t, s.g = this.g * t, s.b = this.b * t, this;
+  }
+  /**
+   * 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
+   */
+  scaleAndAddToRef(t, s) {
+    return s.r += this.r * t, s.g += this.g * t, s.b += this.b * t, this;
+  }
+  /**
+   * 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
+   */
+  clampToRef(t = 0, s = 1, i) {
+    return i.r = p.Clamp(this.r, t, s), i.g = p.Clamp(this.g, t, s), i.b = p.Clamp(this.b, t, s), this;
+  }
+  /**
+   * 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(t) {
+    return new b(this.r + t.r, this.g + t.g, this.b + t.b);
+  }
+  /**
+   * 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(t, s) {
+    return s.r = this.r + t.r, s.g = this.g + t.g, s.b = this.b + t.b, this;
+  }
+  /**
+   * 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(t) {
+    return new b(this.r - t.r, this.g - t.g, this.b - t.b);
+  }
+  /**
+   * 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(t, s) {
+    return s.r = this.r - t.r, s.g = this.g - t.g, s.b = this.b - t.b, this;
+  }
+  /**
+   * Copy the current object
+   * @returns a new Color3 copied the current one
+   */
+  clone() {
+    return new b(this.r, this.g, this.b);
+  }
+  /**
+   * Copies the rgb values from the source in the current Color3
+   * @param source defines the source Color3 object
+   * @returns the updated Color3 object
+   */
+  copyFrom(t) {
+    return this.r = t.r, this.g = t.g, this.b = t.b, this;
+  }
+  /**
+   * Updates the Color3 rgb values from the given floats
+   * @param r defines the red component to read from
+   * @param g defines the green component to read from
+   * @param b defines the blue component to read from
+   * @returns the current Color3 object
+   */
+  copyFromFloats(t, s, i) {
+    return this.r = t, this.g = s, this.b = i, this;
+  }
+  /**
+   * Updates the Color3 rgb values from the given floats
+   * @param r defines the red component to read from
+   * @param g defines the green component to read from
+   * @param b defines the blue component to read from
+   * @returns the current Color3 object
+   */
+  set(t, s, i) {
+    return this.copyFromFloats(t, s, i);
+  }
+  /**
+   * Compute the Color3 hexadecimal code as a string
+   * @returns a string containing the hexadecimal representation of the Color3 object
+   */
+  toHexString() {
+    const t = Math.round(this.r * 255), s = Math.round(this.g * 255), i = Math.round(this.b * 255);
+    return "#" + p.ToHex(t) + p.ToHex(s) + p.ToHex(i);
+  }
+  /**
+   * Converts current color in rgb space to HSV values
+   * @returns a new color3 representing the HSV values
+   */
+  toHSV() {
+    const t = new b();
+    return this.toHSVToRef(t), t;
+  }
+  /**
+   * Converts current color in rgb space to HSV values
+   * @param result defines the Color3 where to store the HSV values
+   */
+  toHSVToRef(t) {
+    const s = this.r, i = this.g, h = this.b, r = Math.max(s, i, h), a = Math.min(s, i, h);
+    let n = 0, c = 0;
+    const u = r, g = r - a;
+    r !== 0 && (c = g / r), r != a && (r == s ? (n = (i - h) / g, i < h && (n += 6)) : r == i ? n = (h - s) / g + 2 : r == h && (n = (s - i) / g + 4), n *= 60), t.r = n, t.g = c, t.b = u;
+  }
+  /**
+   * 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(t = !1) {
+    const s = new b();
+    return this.toLinearSpaceToRef(s, t), s;
+  }
+  /**
+   * 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(t, s = !1) {
+    return s ? (t.r = f(this.r), t.g = f(this.g), t.b = f(this.b)) : (t.r = R(this.r), t.g = R(this.g), t.b = R(this.b)), 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(t = !1) {
+    const s = new b();
+    return this.toGammaSpaceToRef(s, t), s;
+  }
+  /**
+   * 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(t, s = !1) {
+    return s ? (t.r = S(this.r), t.g = S(this.g), t.b = S(this.b)) : (t.r = m(this.r), t.g = m(this.g), t.b = m(this.b)), this;
+  }
+  /**
+   * Converts Hue, saturation and value to a Color3 (RGB)
+   * @param hue defines the hue
+   * @param saturation defines the saturation
+   * @param value defines the value
+   * @param result defines the Color3 where to store the RGB values
+   */
+  static HSVtoRGBToRef(t, s, i, h) {
+    const r = i * s, a = t / 60, n = r * (1 - Math.abs(a % 2 - 1));
+    let c = 0, u = 0, g = 0;
+    a >= 0 && a <= 1 ? (c = r, u = n) : a >= 1 && a <= 2 ? (c = n, u = r) : a >= 2 && a <= 3 ? (u = r, g = n) : a >= 3 && a <= 4 ? (u = n, g = r) : a >= 4 && a <= 5 ? (c = n, g = r) : a >= 5 && a <= 6 && (c = r, g = n);
+    const w = i - r;
+    h.set(c + w, u + w, g + w);
+  }
+  /**
+   * Converts Hue, saturation and value to a new Color3 (RGB)
+   * @param hue defines the hue (value between 0 and 360)
+   * @param saturation defines the saturation (value between 0 and 1)
+   * @param value defines the value (value between 0 and 1)
+   * @returns a new Color3 object
+   */
+  static FromHSV(t, s, i) {
+    const h = new b(0, 0, 0);
+    return b.HSVtoRGBToRef(t, s, i, h), h;
+  }
+  /**
+   * Creates a new Color3 from the string containing valid hexadecimal values
+   * @param hex defines a string containing valid hexadecimal values
+   * @returns a new Color3 object
+   */
+  static FromHexString(t) {
+    if (t.substring(0, 1) !== "#" || t.length !== 7)
+      return new b(0, 0, 0);
+    const s = parseInt(t.substring(1, 3), 16), i = parseInt(t.substring(3, 5), 16), h = parseInt(t.substring(5, 7), 16);
+    return b.FromInts(s, i, h);
+  }
+  /**
+   * Creates a new Color3 from the starting index of the given array
+   * @param array defines the source array
+   * @param offset defines an offset in the source array
+   * @returns a new Color3 object
+   */
+  static FromArray(t, s = 0) {
+    return new b(t[s], t[s + 1], t[s + 2]);
+  }
+  /**
+   * Creates a new Color3 from the starting index element of the given array
+   * @param array defines the source array to read from
+   * @param offset defines the offset in the source array
+   * @param result defines the target Color3 object
+   */
+  static FromArrayToRef(t, s = 0, i) {
+    i.r = t[s], i.g = t[s + 1], i.b = t[s + 2];
+  }
+  /**
+   * 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)
+   * @returns a new Color3 object
+   */
+  static FromInts(t, s, i) {
+    return new b(t / 255, s / 255, i / 255);
+  }
+  /**
+   * Creates a new Color3 with values linearly interpolated of "amount" between the start Color3 and the end Color3
+   * @param start defines the start Color3 value
+   * @param end defines the end Color3 value
+   * @param amount defines the gradient value between start and end
+   * @returns a new Color3 object
+   */
+  static Lerp(t, s, i) {
+    const h = new b(0, 0, 0);
+    return b.LerpToRef(t, s, i, h), h;
+  }
+  /**
+   * Creates a new Color3 with values linearly interpolated of "amount" between the start Color3 and the end Color3
+   * @param left defines the start value
+   * @param right defines the end value
+   * @param amount defines the gradient factor
+   * @param result defines the Color3 object where to store the result
+   */
+  static LerpToRef(t, s, i, h) {
+    h.r = t.r + (s.r - t.r) * i, h.g = t.g + (s.g - t.g) * i, h.b = t.b + (s.b - t.b) * i;
+  }
+  /**
+   * Returns a new Color3 located for "amount" (float) on the Hermite interpolation spline defined by the vectors "value1", "tangent1", "value2", "tangent2"
+   * @param value1 defines the first control point
+   * @param tangent1 defines the first tangent Color3
+   * @param value2 defines the second control point
+   * @param tangent2 defines the second tangent Color3
+   * @param amount defines the amount on the interpolation spline (between 0 and 1)
+   * @returns the new Color3
+   */
+  static Hermite(t, s, i, h, r) {
+    const a = r * r, n = r * a, c = 2 * n - 3 * a + 1, u = -2 * n + 3 * a, g = n - 2 * a + r, w = n - a, H = t.r * c + i.r * u + s.r * g + h.r * w, F = t.g * c + i.g * u + s.g * g + h.g * w, A = t.b * c + i.b * u + s.b * g + h.b * w;
+    return new b(H, F, A);
+  }
+  /**
+   * Returns a new Color3 which is the 1st derivative of the Hermite spline defined by the colors "value1", "value2", "tangent1", "tangent2".
+   * @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
+   * @returns 1st derivative
+   */
+  static Hermite1stDerivative(t, s, i, h, r) {
+    const a = b.Black();
+    return this.Hermite1stDerivativeToRef(t, s, i, h, r, a), a;
+  }
+  /**
+   * Returns a new Color3 which is the 1st derivative of the Hermite spline defined by the colors "value1", "value2", "tangent1", "tangent2".
+   * @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
+   */
+  static Hermite1stDerivativeToRef(t, s, i, h, r, a) {
+    const n = r * r;
+    a.r = (n - r) * 6 * t.r + (3 * n - 4 * r + 1) * s.r + (-n + r) * 6 * i.r + (3 * n - 2 * r) * h.r, a.g = (n - r) * 6 * t.g + (3 * n - 4 * r + 1) * s.g + (-n + r) * 6 * i.g + (3 * n - 2 * r) * h.g, a.b = (n - r) * 6 * t.b + (3 * n - 4 * r + 1) * s.b + (-n + r) * 6 * i.b + (3 * n - 2 * r) * h.b;
+  }
+  /**
+   * Returns a Color3 value containing a red color
+   * @returns a new Color3 object
+   */
+  static Red() {
+    return new b(1, 0, 0);
+  }
+  /**
+   * Returns a Color3 value containing a green color
+   * @returns a new Color3 object
+   */
+  static Green() {
+    return new b(0, 1, 0);
+  }
+  /**
+   * Returns a Color3 value containing a blue color
+   * @returns a new Color3 object
+   */
+  static Blue() {
+    return new b(0, 0, 1);
+  }
+  /**
+   * Returns a Color3 value containing a black color
+   * @returns a new Color3 object
+   */
+  static Black() {
+    return new b(0, 0, 0);
+  }
+  /**
+   * Gets a Color3 value containing a black color that must not be updated
+   */
+  static get BlackReadOnly() {
+    return b._BlackReadOnly;
+  }
+  /**
+   * Returns a Color3 value containing a white color
+   * @returns a new Color3 object
+   */
+  static White() {
+    return new b(1, 1, 1);
+  }
+  /**
+   * Returns a Color3 value containing a purple color
+   * @returns a new Color3 object
+   */
+  static Purple() {
+    return new b(0.5, 0, 0.5);
+  }
+  /**
+   * Returns a Color3 value containing a magenta color
+   * @returns a new Color3 object
+   */
+  static Magenta() {
+    return new b(1, 0, 1);
+  }
+  /**
+   * Returns a Color3 value containing a yellow color
+   * @returns a new Color3 object
+   */
+  static Yellow() {
+    return new b(1, 1, 0);
+  }
+  /**
+   * Returns a Color3 value containing a gray color
+   * @returns a new Color3 object
+   */
+  static Gray() {
+    return new b(0.5, 0.5, 0.5);
+  }
+  /**
+   * Returns a Color3 value containing a teal color
+   * @returns a new Color3 object
+   */
+  static Teal() {
+    return new b(0, 1, 1);
+  }
+  /**
+   * Returns a Color3 value containing a random color
+   * @returns a new Color3 object
+   */
+  static Random() {
+    return new b(Math.random(), Math.random(), Math.random());
+  }
+}
+b._BlackReadOnly = b.Black();
+class e {
+  /**
+   * 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)
+   * @param g defines the green component (between 0 and 1, default is 0)
+   * @param b defines the blue component (between 0 and 1, default is 0)
+   * @param a defines the alpha component (between 0 and 1, default is 1)
+   */
+  constructor(t = 0, s = 0, i = 0, h = 1) {
+    this.r = t, this.g = s, this.b = i, this.a = h;
+  }
+  // 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(t) {
+    return this.r += t.r, this.g += t.g, this.b += t.b, this.a += t.a, this;
+  }
+  /**
+   * Creates a new array populated with 4 numeric elements : red, green, blue, alpha values
+   * @returns the new array
+   */
+  asArray() {
+    return [this.r, this.g, this.b, this.a];
+  }
+  /**
+   * 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(t, s = 0) {
+    return t[s] = this.r, t[s + 1] = this.g, t[s + 2] = this.b, t[s + 3] = this.a, 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(t, s = 0) {
+    return e.FromArrayToRef(t, s, this), 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(t) {
+    return t && this.r === t.r && this.g === t.g && this.b === t.b && this.a === t.a;
+  }
+  /**
+   * Creates a new Color4 set with the added values of the current Color4 and of the given one
+   * @param right defines the second operand
+   * @returns a new Color4 object
+   */
+  add(t) {
+    return new e(this.r + t.r, this.g + t.g, this.b + t.b, this.a + t.a);
+  }
+  /**
+   * Creates a new Color4 set with the subtracted values of the given one from the current Color4
+   * @param right defines the second operand
+   * @returns a new Color4 object
+   */
+  subtract(t) {
+    return new e(this.r - t.r, this.g - t.g, this.b - t.b, this.a - t.a);
+  }
+  /**
+   * Subtracts the given ones from the current Color4 values and stores the results in "result"
+   * @param right defines the second operand
+   * @param result defines the Color4 object where to store the result
+   * @returns the current Color4 object
+   */
+  subtractToRef(t, s) {
+    return s.r = this.r - t.r, s.g = this.g - t.g, s.b = this.b - t.b, s.a = this.a - t.a, this;
+  }
+  /**
+   * 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(t) {
+    return new e(this.r * t, this.g * t, this.b * t, this.a * t);
+  }
+  /**
+   * Multiplies the Color4 values by the float "scale"
+   * @param scale defines the scaling factor to apply
+   * @returns the current updated Color4
+   */
+  scaleInPlace(t) {
+    return this.r *= t, this.g *= t, this.b *= t, this.a *= t, 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
+   */
+  scaleToRef(t, s) {
+    return s.r = this.r * t, s.g = this.g * t, s.b = this.b * t, s.a = this.a * t, this;
+  }
+  /**
+   * 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
+   */
+  scaleAndAddToRef(t, s) {
+    return s.r += this.r * t, s.g += this.g * t, s.b += this.b * t, s.a += this.a * t, this;
+  }
+  /**
+   * 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
+   */
+  clampToRef(t = 0, s = 1, i) {
+    return i.r = p.Clamp(this.r, t, s), i.g = p.Clamp(this.g, t, s), i.b = p.Clamp(this.b, t, s), i.a = p.Clamp(this.a, t, s), this;
+  }
+  /**
+   * 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(t) {
+    return new e(this.r * t.r, this.g * t.g, this.b * t.b, this.a * t.a);
+  }
+  /**
+   * 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(t, s) {
+    return s.r = this.r * t.r, s.g = this.g * t.g, s.b = this.b * t.b, s.a = this.a * t.a, s;
+  }
+  /**
+   * Creates a string with the Color4 current values
+   * @returns the string representation of the Color4 object
+   */
+  toString() {
+    return "{R: " + this.r + " G:" + this.g + " B:" + this.b + " A:" + this.a + "}";
+  }
+  /**
+   * Returns the string "Color4"
+   * @returns "Color4"
+   */
+  getClassName() {
+    return "Color4";
+  }
+  /**
+   * Compute the Color4 hash code
+   * @returns an unique number that can be used to hash Color4 objects
+   */
+  getHashCode() {
+    let t = this.r * 255 | 0;
+    return t = t * 397 ^ (this.g * 255 | 0), t = t * 397 ^ (this.b * 255 | 0), t = t * 397 ^ (this.a * 255 | 0), t;
+  }
+  /**
+   * Creates a new Color4 copied from the current one
+   * @returns a new Color4 object
+   */
+  clone() {
+    return new e(this.r, this.g, this.b, this.a);
+  }
+  /**
+   * Copies the given Color4 values into the current one
+   * @param source defines the source Color4 object
+   * @returns the current updated Color4 object
+   */
+  copyFrom(t) {
+    return this.r = t.r, this.g = t.g, this.b = t.b, this.a = t.a, this;
+  }
+  /**
+   * Copies the given float values into the current one
+   * @param r defines the red component to read from
+   * @param g defines the green component to read from
+   * @param b defines the blue component to read from
+   * @param a defines the alpha component to read from
+   * @returns the current updated Color4 object
+   */
+  copyFromFloats(t, s, i, h) {
+    return this.r = t, this.g = s, this.b = i, this.a = h, this;
+  }
+  /**
+   * Copies the given float values into the current one
+   * @param r defines the red component to read from
+   * @param g defines the green component to read from
+   * @param b defines the blue component to read from
+   * @param a defines the alpha component to read from
+   * @returns the current updated Color4 object
+   */
+  set(t, s, i, h) {
+    return this.copyFromFloats(t, s, i, h);
+  }
+  /**
+   * Compute the Color4 hexadecimal code as a string
+   * @param returnAsColor3 defines if the string should only contains RGB values (off by default)
+   * @returns a string containing the hexadecimal representation of the Color4 object
+   */
+  toHexString(t = !1) {
+    const s = Math.round(this.r * 255), i = Math.round(this.g * 255), h = Math.round(this.b * 255);
+    if (t)
+      return "#" + p.ToHex(s) + p.ToHex(i) + p.ToHex(h);
+    const r = Math.round(this.a * 255);
+    return "#" + p.ToHex(s) + p.ToHex(i) + p.ToHex(h) + p.ToHex(r);
+  }
+  /**
+   * Computes a new Color4 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 Color4 object
+   */
+  toLinearSpace(t = !1) {
+    const s = new e();
+    return this.toLinearSpaceToRef(s, t), s;
+  }
+  /**
+   * Converts the Color4 values to linear space and stores the result in "convertedColor"
+   * @param convertedColor defines the Color4 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 Color4
+   */
+  toLinearSpaceToRef(t, s = !1) {
+    return s ? (t.r = f(this.r), t.g = f(this.g), t.b = f(this.b)) : (t.r = R(this.r), t.g = R(this.g), t.b = R(this.b)), t.a = this.a, this;
+  }
+  /**
+   * Computes a new Color4 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 Color4 object
+   */
+  toGammaSpace(t = !1) {
+    const s = new e();
+    return this.toGammaSpaceToRef(s, t), s;
+  }
+  /**
+   * Converts the Color4 values to gamma space and stores the result in "convertedColor"
+   * @param convertedColor defines the Color4 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 Color4
+   */
+  toGammaSpaceToRef(t, s = !1) {
+    return s ? (t.r = S(this.r), t.g = S(this.g), t.b = S(this.b)) : (t.r = m(this.r), t.g = m(this.g), t.b = m(this.b)), t.a = this.a, this;
+  }
+  // Statics
+  /**
+   * Creates a new Color4 from the string containing valid hexadecimal values.
+   *
+   * A valid hex string is either in the format #RRGGBB or #RRGGBBAA.
+   *
+   * When a hex string without alpha is passed, the resulting Color4 has
+   * its alpha value set to 1.0.
+   *
+   * An invalid string results in a Color with all its channels set to 0.0,
+   * i.e. "transparent black".
+   *
+   * @param hex defines a string containing valid hexadecimal values
+   * @returns a new Color4 object
+   */
+  static FromHexString(t) {
+    if (t.substring(0, 1) !== "#" || t.length !== 9 && t.length !== 7)
+      return new e(0, 0, 0, 0);
+    const s = parseInt(t.substring(1, 3), 16), i = parseInt(t.substring(3, 5), 16), h = parseInt(t.substring(5, 7), 16), r = t.length === 9 ? parseInt(t.substring(7, 9), 16) : 255;
+    return e.FromInts(s, i, h, r);
+  }
+  /**
+   * Creates a new Color4 object set with the linearly interpolated values of "amount" between the left Color4 object and the right Color4 object
+   * @param left defines the start value
+   * @param right defines the end value
+   * @param amount defines the gradient factor
+   * @returns a new Color4 object
+   */
+  static Lerp(t, s, i) {
+    const h = new e(0, 0, 0, 0);
+    return e.LerpToRef(t, s, i, h), h;
+  }
+  /**
+   * Set the given "result" with the linearly interpolated values of "amount" between the left Color4 object and the right Color4 object
+   * @param left defines the start value
+   * @param right defines the end value
+   * @param amount defines the gradient factor
+   * @param result defines the Color4 object where to store data
+   */
+  static LerpToRef(t, s, i, h) {
+    h.r = t.r + (s.r - t.r) * i, h.g = t.g + (s.g - t.g) * i, h.b = t.b + (s.b - t.b) * i, h.a = t.a + (s.a - t.a) * i;
+  }
+  /**
+   * Interpolate between two Color4 using Hermite interpolation
+   * @param value1 defines first Color4
+   * @param tangent1 defines the incoming tangent
+   * @param value2 defines second Color4
+   * @param tangent2 defines the outgoing tangent
+   * @param amount defines the target Color4
+   * @returns the new interpolated Color4
+   */
+  static Hermite(t, s, i, h, r) {
+    const a = r * r, n = r * a, c = 2 * n - 3 * a + 1, u = -2 * n + 3 * a, g = n - 2 * a + r, w = n - a, H = t.r * c + i.r * u + s.r * g + h.r * w, F = t.g * c + i.g * u + s.g * g + h.g * w, A = t.b * c + i.b * u + s.b * g + h.b * w, d = t.a * c + i.a * u + s.a * g + h.a * w;
+    return new e(H, F, A, d);
+  }
+  /**
+   * Returns a new Color4 which is the 1st derivative of the Hermite spline defined by the colors "value1", "value2", "tangent1", "tangent2".
+   * @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
+   * @returns 1st derivative
+   */
+  static Hermite1stDerivative(t, s, i, h, r) {
+    const a = new e();
+    return this.Hermite1stDerivativeToRef(t, s, i, h, r, a), a;
+  }
+  /**
+   * Update a Color4 with the 1st derivative of the Hermite spline defined by the colors "value1", "value2", "tangent1", "tangent2".
+   * @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
+   */
+  static Hermite1stDerivativeToRef(t, s, i, h, r, a) {
+    const n = r * r;
+    a.r = (n - r) * 6 * t.r + (3 * n - 4 * r + 1) * s.r + (-n + r) * 6 * i.r + (3 * n - 2 * r) * h.r, a.g = (n - r) * 6 * t.g + (3 * n - 4 * r + 1) * s.g + (-n + r) * 6 * i.g + (3 * n - 2 * r) * h.g, a.b = (n - r) * 6 * t.b + (3 * n - 4 * r + 1) * s.b + (-n + r) * 6 * i.b + (3 * n - 2 * r) * h.b, a.a = (n - r) * 6 * t.a + (3 * n - 4 * r + 1) * s.a + (-n + r) * 6 * i.a + (3 * n - 2 * r) * h.a;
+  }
+  /**
+   * Creates a new Color4 from a Color3 and an alpha value
+   * @param color3 defines the source Color3 to read from
+   * @param alpha defines the alpha component (1.0 by default)
+   * @returns a new Color4 object
+   */
+  static FromColor3(t, s = 1) {
+    return new e(t.r, t.g, t.b, s);
+  }
+  /**
+   * Creates a new Color4 from the starting index element of the given array
+   * @param array defines the source array to read from
+   * @param offset defines the offset in the source array
+   * @returns a new Color4 object
+   */
+  static FromArray(t, s = 0) {
+    return new e(t[s], t[s + 1], t[s + 2], t[s + 3]);
+  }
+  /**
+   * Creates a new Color4 from the starting index element of the given array
+   * @param array defines the source array to read from
+   * @param offset defines the offset in the source array
+   * @param result defines the target Color4 object
+   */
+  static FromArrayToRef(t, s = 0, i) {
+    i.r = t[s], i.g = t[s + 1], i.b = t[s + 2], i.a = t[s + 3];
+  }
+  /**
+   * 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)
+   * @param a defines the alpha component to read from (value between 0 and 255)
+   * @returns a new Color3 object
+   */
+  static FromInts(t, s, i, h) {
+    return new e(t / 255, s / 255, i / 255, h / 255);
+  }
+  /**
+   * Check the content of a given array and convert it to an array containing RGBA data
+   * If the original array was already containing count * 4 values then it is returned directly
+   * @param colors defines the array to check
+   * @param count defines the number of RGBA data to expect
+   * @returns an array containing count * 4 values (RGBA)
+   */
+  static CheckColors4(t, s) {
+    if (t.length === s * 3) {
+      const i = [];
+      for (let h = 0; h < t.length; h += 3) {
+        const r = h / 3 * 4;
+        i[r] = t[h], i[r + 1] = t[h + 1], i[r + 2] = t[h + 2], i[r + 3] = 1;
+      }
+      return i;
+    }
+    return t;
+  }
+}
+class M {
+}
+M.Color3 = B.BuildArray(3, b.Black);
+M.Color4 = B.BuildArray(3, () => new e(0, 0, 0, 0));
+L("BABYLON.Color3", b);
+L("BABYLON.Color4", e);
+export {
+  b as Color3,
+  e as Color4,
+  M as TmpColors
+};