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

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

@@ -1,903 +0,0 @@
-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
-};