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

package/dist/node_modules/@babylonjs/core/Misc/HighDynamicRange/cubemapToSphericalPolynomial.esm.js

@@ -0,0 +1,111 @@
+import { Vector3 as n } from "../../Maths/math.vector.esm.js";
+import { Scalar as A } from "../../Maths/math.scalar.esm.js";
+import { SphericalHarmonics as V, SphericalPolynomial as D } from "../../Maths/sphericalPolynomial.esm.js";
+import { ToLinearSpace as _ } from "../../Maths/math.constants.esm.js";
+import { Color3 as H } from "../../Maths/math.color.esm.js";
+class S {
+  constructor(e, i, p, c) {
+    this.name = e, this.worldAxisForNormal = i, this.worldAxisForFileX = p, this.worldAxisForFileY = c;
+  }
+}
+class T {
+  /**
+   * Converts a texture to the according Spherical Polynomial data.
+   * This extracts the first 3 orders only as they are the only one used in the lighting.
+   *
+   * @param texture The texture to extract the information from.
+   * @returns The Spherical Polynomial data.
+   */
+  static ConvertCubeMapTextureToSphericalPolynomial(e) {
+    var i;
+    if (!e.isCube)
+      return null;
+    (i = e.getScene()) === null || i === void 0 || i.getEngine().flushFramebuffer();
+    const p = e.getSize().width, c = e.readPixels(0, void 0, void 0, !1), u = e.readPixels(1, void 0, void 0, !1);
+    let a, w;
+    e.isRenderTarget ? (a = e.readPixels(3, void 0, void 0, !1), w = e.readPixels(2, void 0, void 0, !1)) : (a = e.readPixels(2, void 0, void 0, !1), w = e.readPixels(3, void 0, void 0, !1));
+    const R = e.readPixels(4, void 0, void 0, !1), v = e.readPixels(5, void 0, void 0, !1), x = e.gammaSpace, E = 5;
+    let h = 0;
+    return (e.textureType == 1 || e.textureType == 2) && (h = 1), new Promise((P) => {
+      Promise.all([u, c, a, w, R, v]).then(([F, r, t, m, d, f]) => {
+        const g = {
+          size: p,
+          right: r,
+          left: F,
+          up: t,
+          down: m,
+          front: d,
+          back: f,
+          format: E,
+          type: h,
+          gammaSpace: x
+        };
+        P(this.ConvertCubeMapToSphericalPolynomial(g));
+      });
+    });
+  }
+  /**
+   * Compute the area on the unit sphere of the rectangle defined by (x,y) and the origin
+   * See https://www.rorydriscoll.com/2012/01/15/cubemap-texel-solid-angle/
+   * @param x
+   * @param y
+   */
+  static _AreaElement(e, i) {
+    return Math.atan2(e * i, Math.sqrt(e * e + i * i + 1));
+  }
+  /**
+   * Converts a cubemap to the according Spherical Polynomial data.
+   * This extracts the first 3 orders only as they are the only one used in the lighting.
+   *
+   * @param cubeInfo The Cube map to extract the information from.
+   * @returns The Spherical Polynomial data.
+   */
+  static ConvertCubeMapToSphericalPolynomial(e) {
+    const i = new V();
+    let p = 0;
+    const c = 2 / e.size, u = c, a = 0.5 * c, w = a - 1;
+    for (let h = 0; h < 6; h++) {
+      const P = this._FileFaces[h], F = e[P.name];
+      let r = w;
+      const t = e.format === 5 ? 4 : 3;
+      for (let m = 0; m < e.size; m++) {
+        let d = w;
+        for (let f = 0; f < e.size; f++) {
+          const g = P.worldAxisForFileX.scale(d).add(P.worldAxisForFileY.scale(r)).add(P.worldAxisForNormal);
+          g.normalize();
+          const y = this._AreaElement(d - a, r - a) - this._AreaElement(d - a, r + a) - this._AreaElement(d + a, r - a) + this._AreaElement(d + a, r + a);
+          let o = F[m * e.size * t + f * t + 0], l = F[m * e.size * t + f * t + 1], s = F[m * e.size * t + f * t + 2];
+          isNaN(o) && (o = 0), isNaN(l) && (l = 0), isNaN(s) && (s = 0), e.type === 0 && (o /= 255, l /= 255, s /= 255), e.gammaSpace && (o = Math.pow(A.Clamp(o), _), l = Math.pow(A.Clamp(l), _), s = Math.pow(A.Clamp(s), _));
+          const C = this.MAX_HDRI_VALUE;
+          if (this.PRESERVE_CLAMPED_COLORS) {
+            const z = Math.max(o, l, s);
+            if (z > C) {
+              const M = C / z;
+              o *= M, l *= M, s *= M;
+            }
+          } else
+            o = A.Clamp(o, 0, C), l = A.Clamp(l, 0, C), s = A.Clamp(s, 0, C);
+          const N = new H(o, l, s);
+          i.addLight(g, N, y), p += y, d += c;
+        }
+        r += u;
+      }
+    }
+    const E = 4 * Math.PI * 6 / 6 / p;
+    return i.scaleInPlace(E), i.convertIncidentRadianceToIrradiance(), i.convertIrradianceToLambertianRadiance(), D.FromHarmonics(i);
+  }
+}
+T._FileFaces = [
+  new S("right", new n(1, 0, 0), new n(0, 0, -1), new n(0, -1, 0)),
+  new S("left", new n(-1, 0, 0), new n(0, 0, 1), new n(0, -1, 0)),
+  new S("up", new n(0, 1, 0), new n(1, 0, 0), new n(0, 0, 1)),
+  new S("down", new n(0, -1, 0), new n(1, 0, 0), new n(0, 0, -1)),
+  new S("front", new n(0, 0, 1), new n(1, 0, 0), new n(0, -1, 0)),
+  new S("back", new n(0, 0, -1), new n(-1, 0, 0), new n(0, -1, 0))
+  // -Z bottom
+];
+T.MAX_HDRI_VALUE = 4096;
+T.PRESERVE_CLAMPED_COLORS = !1;
+export {
+  T as CubeMapToSphericalPolynomialTools
+};

package/dist/node_modules/@babylonjs/core/Misc/HighDynamicRange/hdr.esm.js

@@ -0,0 +1,122 @@
+import { PanoramaToCubeMapTools as B } from "./panoramaToCubemap.esm.js";
+class p {
+  static _Ldexp(e, t) {
+    return t > 1023 ? e * Math.pow(2, 1023) * Math.pow(2, t - 1023) : t < -1074 ? e * Math.pow(2, -1074) * Math.pow(2, t + 1074) : e * Math.pow(2, t);
+  }
+  static _Rgbe2float(e, t, r, i, a, s) {
+    a > 0 ? (a = this._Ldexp(1, a - (128 + 8)), e[s + 0] = t * a, e[s + 1] = r * a, e[s + 2] = i * a) : (e[s + 0] = 0, e[s + 1] = 0, e[s + 2] = 0);
+  }
+  static _ReadStringLine(e, t) {
+    let r = "", i = "";
+    for (let a = t; a < e.length - t && (i = String.fromCharCode(e[a]), i != `
+`); a++)
+      r += i;
+    return r;
+  }
+  /**
+   * Reads header information from an RGBE texture stored in a native array.
+   * More information on this format are available here:
+   * https://en.wikipedia.org/wiki/RGBE_image_format
+   *
+   * @param uint8array The binary file stored in  native array.
+   * @returns The header information.
+   */
+  // eslint-disable-next-line @typescript-eslint/naming-convention
+  static RGBE_ReadHeader(e) {
+    let t = 0, r = 0, i = this._ReadStringLine(e, 0);
+    if (i[0] != "#" || i[1] != "?")
+      throw "Bad HDR Format.";
+    let a = !1, s = !1, l = 0;
+    do
+      l += i.length + 1, i = this._ReadStringLine(e, l), i == "FORMAT=32-bit_rle_rgbe" ? s = !0 : i.length == 0 && (a = !0);
+    while (!a);
+    if (!s)
+      throw "HDR Bad header format, unsupported FORMAT";
+    l += i.length + 1, i = this._ReadStringLine(e, l);
+    const h = /^-Y (.*) \+X (.*)$/g.exec(i);
+    if (!h || h.length < 3)
+      throw "HDR Bad header format, no size";
+    if (r = parseInt(h[2]), t = parseInt(h[1]), r < 8 || r > 32767)
+      throw "HDR Bad header format, unsupported size";
+    return l += i.length + 1, {
+      height: t,
+      width: r,
+      dataPosition: l
+    };
+  }
+  /**
+   * Returns the cubemap information (each faces texture data) extracted from an RGBE texture.
+   * This RGBE texture needs to store the information as a panorama.
+   *
+   * More information on this format are available here:
+   * https://en.wikipedia.org/wiki/RGBE_image_format
+   *
+   * @param buffer The binary file stored in an array buffer.
+   * @param size The expected size of the extracted cubemap.
+   * @returns The Cube Map information.
+   */
+  static GetCubeMapTextureData(e, t, r = !1) {
+    const i = new Uint8Array(e), a = this.RGBE_ReadHeader(i), s = this.RGBE_ReadPixels(i, a);
+    return B.ConvertPanoramaToCubemap(s, a.width, a.height, t, r);
+  }
+  /**
+   * Returns the pixels data extracted from an RGBE texture.
+   * This pixels will be stored left to right up to down in the R G B order in one array.
+   *
+   * More information on this format are available here:
+   * https://en.wikipedia.org/wiki/RGBE_image_format
+   *
+   * @param uint8array The binary file stored in an array buffer.
+   * @param hdrInfo The header information of the file.
+   * @returns The pixels data in RGB right to left up to down order.
+   */
+  // eslint-disable-next-line @typescript-eslint/naming-convention
+  static RGBE_ReadPixels(e, t) {
+    return this._RGBEReadPixelsRLE(e, t);
+  }
+  static _RGBEReadPixelsRLE(e, t) {
+    let r = t.height;
+    const i = t.width;
+    let a, s, l, c, h, d = t.dataPosition, o = 0, R = 0, n = 0;
+    const u = new ArrayBuffer(i * 4), w = new Uint8Array(u), _ = new ArrayBuffer(t.width * t.height * 4 * 3), f = new Float32Array(_);
+    for (; r > 0; ) {
+      if (a = e[d++], s = e[d++], l = e[d++], c = e[d++], a != 2 || s != 2 || l & 128 || t.width < 8 || t.width > 32767)
+        return this._RGBEReadPixelsNOTRLE(e, t);
+      if ((l << 8 | c) != i)
+        throw "HDR Bad header format, wrong scan line width";
+      for (o = 0, n = 0; n < 4; n++)
+        for (R = (n + 1) * i; o < R; )
+          if (a = e[d++], s = e[d++], a > 128) {
+            if (h = a - 128, h == 0 || h > R - o)
+              throw "HDR Bad Format, bad scanline data (run)";
+            for (; h-- > 0; )
+              w[o++] = s;
+          } else {
+            if (h = a, h == 0 || h > R - o)
+              throw "HDR Bad Format, bad scanline data (non-run)";
+            if (w[o++] = s, --h > 0)
+              for (let g = 0; g < h; g++)
+                w[o++] = e[d++];
+          }
+      for (n = 0; n < i; n++)
+        a = w[n], s = w[n + i], l = w[n + 2 * i], c = w[n + 3 * i], this._Rgbe2float(f, a, s, l, c, (t.height - r) * i * 3 + n * 3);
+      r--;
+    }
+    return f;
+  }
+  static _RGBEReadPixelsNOTRLE(e, t) {
+    let r = t.height;
+    const i = t.width;
+    let a, s, l, c, h, d = t.dataPosition;
+    const o = new ArrayBuffer(t.width * t.height * 4 * 3), R = new Float32Array(o);
+    for (; r > 0; ) {
+      for (h = 0; h < t.width; h++)
+        a = e[d++], s = e[d++], l = e[d++], c = e[d++], this._Rgbe2float(R, a, s, l, c, (t.height - r) * i * 3 + h * 3);
+      r--;
+    }
+    return R;
+  }
+}
+export {
+  p as HDRTools
+};

package/dist/node_modules/@babylonjs/core/Misc/HighDynamicRange/panoramaToCubemap.esm.js

@@ -0,0 +1,78 @@
+import { Vector3 as t } from "../../Maths/math.vector.esm.js";
+class b {
+  /**
+   * Converts a panorama stored in RGB right to left up to down format into a cubemap (6 faces).
+   *
+   * @param float32Array The source data.
+   * @param inputWidth The width of the input panorama.
+   * @param inputHeight The height of the input panorama.
+   * @param size The willing size of the generated cubemap (each faces will be size * size pixels)
+   * @returns The cubemap data
+   */
+  static ConvertPanoramaToCubemap(e, o, n, r, a = !1) {
+    if (!e)
+      throw "ConvertPanoramaToCubemap: input cannot be null";
+    if (e.length != o * n * 3)
+      throw "ConvertPanoramaToCubemap: input size is wrong";
+    const F = this.CreateCubemapTexture(r, this.FACE_FRONT, e, o, n, a), l = this.CreateCubemapTexture(r, this.FACE_BACK, e, o, n, a), w = this.CreateCubemapTexture(r, this.FACE_LEFT, e, o, n, a), s = this.CreateCubemapTexture(r, this.FACE_RIGHT, e, o, n, a), c = this.CreateCubemapTexture(r, this.FACE_UP, e, o, n, a), C = this.CreateCubemapTexture(r, this.FACE_DOWN, e, o, n, a);
+    return {
+      front: F,
+      back: l,
+      left: w,
+      right: s,
+      up: c,
+      down: C,
+      size: r,
+      type: 1,
+      format: 4,
+      gammaSpace: !1
+    };
+  }
+  static CreateCubemapTexture(e, o, n, r, a, F = !1) {
+    const l = new ArrayBuffer(e * e * 4 * 3), w = new Float32Array(l), s = F ? Math.max(1, Math.round(r / 4 / e)) : 1, c = 1 / s, C = c * c, u = o[1].subtract(o[0]).scale(c / e), E = o[3].subtract(o[2]).scale(c / e), P = 1 / e;
+    let _ = 0;
+    for (let m = 0; m < e; m++)
+      for (let f = 0; f < s; f++) {
+        let h = o[0], x = o[2];
+        for (let T = 0; T < e; T++)
+          for (let A = 0; A < s; A++) {
+            const I = x.subtract(h).scale(_).add(h);
+            I.normalize();
+            const M = this.CalcProjectionSpherical(I, n, r, a);
+            w[m * e * 3 + T * 3 + 0] += M.r * C, w[m * e * 3 + T * 3 + 1] += M.g * C, w[m * e * 3 + T * 3 + 2] += M.b * C, h = h.add(u), x = x.add(E);
+          }
+        _ += P * c;
+      }
+    return w;
+  }
+  static CalcProjectionSpherical(e, o, n, r) {
+    let a = Math.atan2(e.z, e.x);
+    const F = Math.acos(e.y);
+    for (; a < -Math.PI; )
+      a += 2 * Math.PI;
+    for (; a > Math.PI; )
+      a -= 2 * Math.PI;
+    let l = a / Math.PI;
+    const w = F / Math.PI;
+    l = l * 0.5 + 0.5;
+    let s = Math.round(l * n);
+    s < 0 ? s = 0 : s >= n && (s = n - 1);
+    let c = Math.round(w * r);
+    c < 0 ? c = 0 : c >= r && (c = r - 1);
+    const C = r - c - 1, u = o[C * n * 3 + s * 3 + 0], E = o[C * n * 3 + s * 3 + 1], P = o[C * n * 3 + s * 3 + 2];
+    return {
+      r: u,
+      g: E,
+      b: P
+    };
+  }
+}
+b.FACE_LEFT = [new t(-1, -1, -1), new t(1, -1, -1), new t(-1, 1, -1), new t(1, 1, -1)];
+b.FACE_RIGHT = [new t(1, -1, 1), new t(-1, -1, 1), new t(1, 1, 1), new t(-1, 1, 1)];
+b.FACE_FRONT = [new t(1, -1, -1), new t(1, -1, 1), new t(1, 1, -1), new t(1, 1, 1)];
+b.FACE_BACK = [new t(-1, -1, 1), new t(-1, -1, -1), new t(-1, 1, 1), new t(-1, 1, -1)];
+b.FACE_DOWN = [new t(1, 1, -1), new t(1, 1, 1), new t(-1, 1, -1), new t(-1, 1, 1)];
+b.FACE_UP = [new t(-1, -1, -1), new t(-1, -1, 1), new t(1, -1, -1), new t(1, -1, 1)];
+export {
+  b as PanoramaToCubeMapTools
+};

package/dist/node_modules/@babylonjs/core/Misc/andOrNotEvaluator.esm.js

@@ -0,0 +1,41 @@
+class r {
+  /**
+   * Evaluate a query
+   * @param query defines the query to evaluate
+   * @param evaluateCallback defines the callback used to filter result
+   * @returns true if the query matches
+   */
+  static Eval(e, t) {
+    return e.match(/\([^()]*\)/g) ? e = e.replace(/\([^()]*\)/g, (s) => (s = s.slice(1, s.length - 1), r._HandleParenthesisContent(s, t))) : e = r._HandleParenthesisContent(e, t), e === "true" ? !0 : e === "false" ? !1 : r.Eval(e, t);
+  }
+  static _HandleParenthesisContent(e, t) {
+    t = t || ((n) => n === "true");
+    let s;
+    const p = e.split("||");
+    for (const n in p)
+      if (Object.prototype.hasOwnProperty.call(p, n)) {
+        let i = r._SimplifyNegation(p[n].trim());
+        const h = i.split("&&");
+        if (h.length > 1)
+          for (let l = 0; l < h.length; ++l) {
+            const f = r._SimplifyNegation(h[l].trim());
+            if (f !== "true" && f !== "false" ? f[0] === "!" ? s = !t(f.substring(1)) : s = t(f) : s = f === "true", !s) {
+              i = "false";
+              break;
+            }
+          }
+        if (s || i === "true") {
+          s = !0;
+          break;
+        }
+        i !== "true" && i !== "false" ? i[0] === "!" ? s = !t(i.substring(1)) : s = t(i) : s = i === "true";
+      }
+    return s ? "true" : "false";
+  }
+  static _SimplifyNegation(e) {
+    return e = e.replace(/^[\s!]+/, (t) => (t = t.replace(/[\s]/g, () => ""), t.length % 2 ? "!" : "")), e = e.trim(), e === "!true" ? e = "false" : e === "!false" && (e = "true"), e;
+  }
+}
+export {
+  r as AndOrNotEvaluator
+};

package/dist/node_modules/@babylonjs/core/Misc/arrayTools.esm.js

@@ -0,0 +1,52 @@
+class o {
+  /**
+   * Returns an array of the given size filled with elements built from the given constructor and the parameters.
+   * @param size the number of element to construct and put in the array.
+   * @param itemBuilder a callback responsible for creating new instance of item. Called once per array entry.
+   * @returns a new array filled with new objects.
+   */
+  static BuildArray(e, u) {
+    const n = [];
+    for (let r = 0; r < e; ++r)
+      n.push(u());
+    return n;
+  }
+  /**
+   * Returns a tuple of the given size filled with elements built from the given constructor and the parameters.
+   * @param size he number of element to construct and put in the tuple.
+   * @param itemBuilder a callback responsible for creating new instance of item. Called once per tuple entry.
+   * @returns a new tuple filled with new objects.
+   */
+  static BuildTuple(e, u) {
+    return o.BuildArray(e, u);
+  }
+}
+function p(t, e, u) {
+  const n = t[e];
+  if (typeof n != "function")
+    return null;
+  const r = function() {
+    const s = t.length, i = r.previous.apply(t, arguments);
+    return u(e, s), i;
+  };
+  return n.next = r, r.previous = n, t[e] = r, () => {
+    const s = r.previous;
+    if (!s)
+      return;
+    const i = r.next;
+    i ? (s.next = i, i.previous = s) : (s.next = void 0, t[e] = s), r.next = void 0, r.previous = void 0;
+  };
+}
+const l = ["push", "splice", "pop", "shift", "unshift"];
+function c(t, e) {
+  const u = l.map((n) => p(t, n, e));
+  return () => {
+    u.forEach((n) => {
+      n == null || n();
+    });
+  };
+}
+export {
+  o as ArrayTools,
+  c as _ObserveArray
+};