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

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

@@ -0,0 +1,44 @@
+function g(t, i, c = !1) {
+  const n = i.width, e = i.height;
+  if (t instanceof Float32Array) {
+    let a = t.byteLength / t.BYTES_PER_ELEMENT;
+    const r = new Uint8Array(a);
+    for (; --a >= 0; ) {
+      let s = t[a];
+      s < 0 ? s = 0 : s > 1 && (s = 1), r[a] = s * 255;
+    }
+    t = r;
+  }
+  const l = document.createElement("canvas");
+  l.width = n, l.height = e;
+  const o = l.getContext("2d");
+  if (!o)
+    return null;
+  const u = o.createImageData(n, e);
+  if (u.data.set(t), o.putImageData(u, 0, 0), c) {
+    const a = document.createElement("canvas");
+    a.width = n, a.height = e;
+    const r = a.getContext("2d");
+    return r ? (r.translate(0, e), r.scale(1, -1), r.drawImage(l, 0, 0), a.toDataURL("image/png")) : null;
+  }
+  return l.toDataURL("image/png");
+}
+function h(t, i = 0, c = 0) {
+  const n = t.getInternalTexture();
+  if (!n)
+    return null;
+  const e = t._readPixelsSync(i, c);
+  return e ? g(e, t.getSize(), n.invertY) : null;
+}
+async function m(t, i = 0, c = 0) {
+  const n = t.getInternalTexture();
+  if (!n)
+    return null;
+  const e = await t.readPixels(i, c);
+  return e ? g(e, t.getSize(), n.invertY) : null;
+}
+export {
+  g as GenerateBase64StringFromPixelData,
+  h as GenerateBase64StringFromTexture,
+  m as GenerateBase64StringFromTextureAsync
+};

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

@@ -0,0 +1,53 @@
+function f(u, n, t) {
+  try {
+    const e = u.next();
+    e.done ? n(e) : e.value ? e.value.then(() => {
+      e.value = void 0, n(e);
+    }, t) : n(e);
+  } catch (e) {
+    t(e);
+  }
+}
+function a(u = 25) {
+  let n;
+  return (t, e, i) => {
+    const c = performance.now();
+    n === void 0 || c - n > u ? (n = c, setTimeout(() => {
+      f(t, e, i);
+    }, 0)) : f(t, e, i);
+  };
+}
+function l(u, n, t, e, i) {
+  const c = () => {
+    let r;
+    const o = (d) => {
+      d.done ? t(d.value) : r === void 0 ? r = !0 : c();
+    };
+    do
+      r = void 0, !i || !i.aborted ? n(u, o, e) : e(new Error("Aborted")), r === void 0 && (r = !1);
+    while (r);
+  };
+  c();
+}
+function s(u, n) {
+  let t;
+  return l(u, f, (e) => t = e, (e) => {
+    throw e;
+  }, n), t;
+}
+function h(u, n, t) {
+  return new Promise((e, i) => {
+    l(u, n, e, i, t);
+  });
+}
+function m(u, n) {
+  return (...t) => s(u(...t), n);
+}
+export {
+  a as createYieldingScheduler,
+  f as inlineScheduler,
+  m as makeSyncFunction,
+  l as runCoroutine,
+  h as runCoroutineAsync,
+  s as runCoroutineSync
+};

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

@@ -0,0 +1,55 @@
+import { Decode as s } from "./stringTools.esm.js";
+class i {
+  /**
+   * Constructor
+   * @param buffer The buffer to read
+   */
+  constructor(t) {
+    this.byteOffset = 0, this.buffer = t;
+  }
+  /**
+   * Loads the given byte length.
+   * @param byteLength The byte length to load
+   * @returns A promise that resolves when the load is complete
+   */
+  loadAsync(t) {
+    return this.buffer.readAsync(this.byteOffset, t).then((e) => {
+      this._dataView = new DataView(e.buffer, e.byteOffset, e.byteLength), this._dataByteOffset = 0;
+    });
+  }
+  /**
+   * Read a unsigned 32-bit integer from the currently loaded data range.
+   * @returns The 32-bit integer read
+   */
+  readUint32() {
+    const t = this._dataView.getUint32(this._dataByteOffset, !0);
+    return this._dataByteOffset += 4, this.byteOffset += 4, t;
+  }
+  /**
+   * Read a byte array from the currently loaded data range.
+   * @param byteLength The byte length to read
+   * @returns The byte array read
+   */
+  readUint8Array(t) {
+    const e = new Uint8Array(this._dataView.buffer, this._dataView.byteOffset + this._dataByteOffset, t);
+    return this._dataByteOffset += t, this.byteOffset += t, e;
+  }
+  /**
+   * Read a string from the currently loaded data range.
+   * @param byteLength The byte length to read
+   * @returns The string read
+   */
+  readString(t) {
+    return s(this.readUint8Array(t));
+  }
+  /**
+   * Skips the given byte length the currently loaded data range.
+   * @param byteLength The byte length to skip
+   */
+  skipBytes(t) {
+    this._dataByteOffset += t, this.byteOffset += t;
+  }
+}
+export {
+  i as DataReader
+};

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

@@ -0,0 +1,329 @@
+import { Scalar as R } from "../Maths/math.scalar.esm.js";
+import { SphericalPolynomial as Ae } from "../Maths/sphericalPolynomial.esm.js";
+import { InternalTextureSource as q, InternalTexture as pe } from "../Materials/Textures/internalTexture.esm.js";
+import { Logger as H } from "./logger.esm.js";
+import { CubeMapToSphericalPolynomialTools as ye } from "./HighDynamicRange/cubemapToSphericalPolynomial.esm.js";
+import { BaseTexture as me } from "../Materials/Textures/baseTexture.esm.js";
+import { ThinEngine as Ce } from "../Engines/thinEngine.esm.js";
+import { FromHalfFloat as E, ToHalfFloat as L } from "./textureTools.esm.js";
+import "../Engines/Extensions/engine.cubeTexture.esm.js";
+const _e = 542327876, J = 131072, K = 512, Q = 4, Z = 64, $ = 131072;
+function D(G) {
+  return G.charCodeAt(0) + (G.charCodeAt(1) << 8) + (G.charCodeAt(2) << 16) + (G.charCodeAt(3) << 24);
+}
+function Fe(G) {
+  return String.fromCharCode(G & 255, G >> 8 & 255, G >> 16 & 255, G >> 24 & 255);
+}
+const v = D("DXT1"), ee = D("DXT3"), te = D("DXT5"), z = D("DX10"), re = 113, ae = 116, se = 2, oe = 10, he = 88, S = 31, xe = 0, Ge = 1, ne = 2, fe = 3, V = 4, ce = 7, Y = 20, le = 21, be = 22, Be = 23, Re = 24, de = 25, Ue = 26, Oe = 28, Ee = 32;
+class u {
+  /**
+   * Gets DDS information from an array buffer
+   * @param data defines the array buffer view to read data from
+   * @returns the DDS information
+   */
+  static GetDDSInfo(a) {
+    const f = new Int32Array(a.buffer, a.byteOffset, S), o = new Int32Array(a.buffer, a.byteOffset, S + 4);
+    let c = 1;
+    f[ne] & J && (c = Math.max(1, f[ce]));
+    const A = f[le], C = A === z ? o[Ee] : 0;
+    let r = 0;
+    switch (A) {
+      case re:
+        r = 2;
+        break;
+      case ae:
+        r = 1;
+        break;
+      case z:
+        if (C === oe) {
+          r = 2;
+          break;
+        }
+        if (C === se) {
+          r = 1;
+          break;
+        }
+    }
+    return {
+      width: f[V],
+      height: f[fe],
+      mipmapCount: c,
+      isFourCC: (f[Y] & Q) === Q,
+      isRGB: (f[Y] & Z) === Z,
+      isLuminance: (f[Y] & $) === $,
+      isCube: (f[Oe] & K) === K,
+      isCompressed: A === v || A === ee || A === te,
+      dxgiFormat: C,
+      textureType: r
+    };
+  }
+  static _GetHalfFloatAsFloatRGBAArrayBuffer(a, f, o, c, A, C) {
+    const r = new Float32Array(c), l = new Uint16Array(A, o);
+    let e = 0;
+    for (let t = 0; t < f; t++)
+      for (let n = 0; n < a; n++) {
+        const s = (n + t * a) * 4;
+        r[e] = E(l[s]), r[e + 1] = E(l[s + 1]), r[e + 2] = E(l[s + 2]), u.StoreLODInAlphaChannel ? r[e + 3] = C : r[e + 3] = E(l[s + 3]), e += 4;
+      }
+    return r;
+  }
+  static _GetHalfFloatRGBAArrayBuffer(a, f, o, c, A, C) {
+    if (u.StoreLODInAlphaChannel) {
+      const r = new Uint16Array(c), l = new Uint16Array(A, o);
+      let e = 0;
+      for (let t = 0; t < f; t++)
+        for (let n = 0; n < a; n++) {
+          const s = (n + t * a) * 4;
+          r[e] = l[s], r[e + 1] = l[s + 1], r[e + 2] = l[s + 2], r[e + 3] = L(C), e += 4;
+        }
+      return r;
+    }
+    return new Uint16Array(A, o, c);
+  }
+  static _GetFloatRGBAArrayBuffer(a, f, o, c, A, C) {
+    if (u.StoreLODInAlphaChannel) {
+      const r = new Float32Array(c), l = new Float32Array(A, o);
+      let e = 0;
+      for (let t = 0; t < f; t++)
+        for (let n = 0; n < a; n++) {
+          const s = (n + t * a) * 4;
+          r[e] = l[s], r[e + 1] = l[s + 1], r[e + 2] = l[s + 2], r[e + 3] = C, e += 4;
+        }
+      return r;
+    }
+    return new Float32Array(A, o, c);
+  }
+  static _GetFloatAsHalfFloatRGBAArrayBuffer(a, f, o, c, A, C) {
+    const r = new Uint16Array(c), l = new Float32Array(A, o);
+    let e = 0;
+    for (let t = 0; t < f; t++)
+      for (let n = 0; n < a; n++)
+        r[e] = L(l[e]), r[e + 1] = L(l[e + 1]), r[e + 2] = L(l[e + 2]), u.StoreLODInAlphaChannel ? r[e + 3] = L(C) : r[e + 3] = L(l[e + 3]), e += 4;
+    return r;
+  }
+  static _GetFloatAsUIntRGBAArrayBuffer(a, f, o, c, A, C) {
+    const r = new Uint8Array(c), l = new Float32Array(A, o);
+    let e = 0;
+    for (let t = 0; t < f; t++)
+      for (let n = 0; n < a; n++) {
+        const s = (n + t * a) * 4;
+        r[e] = R.Clamp(l[s]) * 255, r[e + 1] = R.Clamp(l[s + 1]) * 255, r[e + 2] = R.Clamp(l[s + 2]) * 255, u.StoreLODInAlphaChannel ? r[e + 3] = C : r[e + 3] = R.Clamp(l[s + 3]) * 255, e += 4;
+      }
+    return r;
+  }
+  static _GetHalfFloatAsUIntRGBAArrayBuffer(a, f, o, c, A, C) {
+    const r = new Uint8Array(c), l = new Uint16Array(A, o);
+    let e = 0;
+    for (let t = 0; t < f; t++)
+      for (let n = 0; n < a; n++) {
+        const s = (n + t * a) * 4;
+        r[e] = R.Clamp(E(l[s])) * 255, r[e + 1] = R.Clamp(E(l[s + 1])) * 255, r[e + 2] = R.Clamp(E(l[s + 2])) * 255, u.StoreLODInAlphaChannel ? r[e + 3] = C : r[e + 3] = R.Clamp(E(l[s + 3])) * 255, e += 4;
+      }
+    return r;
+  }
+  static _GetRGBAArrayBuffer(a, f, o, c, A, C, r, l, e) {
+    const t = new Uint8Array(c), n = new Uint8Array(A, o);
+    let s = 0;
+    for (let p = 0; p < f; p++)
+      for (let i = 0; i < a; i++) {
+        const y = (i + p * a) * 4;
+        t[s] = n[y + C], t[s + 1] = n[y + r], t[s + 2] = n[y + l], t[s + 3] = n[y + e], s += 4;
+      }
+    return t;
+  }
+  static _ExtractLongWordOrder(a) {
+    return a === 0 || a === 255 || a === -16777216 ? 0 : 1 + u._ExtractLongWordOrder(a >> 8);
+  }
+  static _GetRGBArrayBuffer(a, f, o, c, A, C, r, l) {
+    const e = new Uint8Array(c), t = new Uint8Array(A, o);
+    let n = 0;
+    for (let s = 0; s < f; s++)
+      for (let p = 0; p < a; p++) {
+        const i = (p + s * a) * 3;
+        e[n] = t[i + C], e[n + 1] = t[i + r], e[n + 2] = t[i + l], n += 3;
+      }
+    return e;
+  }
+  static _GetLuminanceArrayBuffer(a, f, o, c, A) {
+    const C = new Uint8Array(c), r = new Uint8Array(A, o);
+    let l = 0;
+    for (let e = 0; e < f; e++)
+      for (let t = 0; t < a; t++) {
+        const n = t + e * a;
+        C[l] = r[n], l++;
+      }
+    return C;
+  }
+  /**
+   * Uploads DDS Levels to a Babylon Texture
+   * @internal
+   */
+  static UploadDDSLevels(a, f, o, c, A, C, r = -1, l, e = !0) {
+    let t = null;
+    c.sphericalPolynomial && (t = new Array());
+    const n = !!a.getCaps().s3tc;
+    f.generateMipMaps = A;
+    const s = new Int32Array(o.buffer, o.byteOffset, S);
+    let p, i, y, _ = 0, F, b, w, U, T = 0, P = 1;
+    if (s[xe] !== _e) {
+      H.Error("Invalid magic number in DDS header");
+      return;
+    }
+    if (!c.isFourCC && !c.isRGB && !c.isLuminance) {
+      H.Error("Unsupported format, must contain a FourCC, RGB or LUMINANCE code");
+      return;
+    }
+    if (c.isCompressed && !n) {
+      H.Error("Compressed textures are not supported on this platform.");
+      return;
+    }
+    let m = s[be];
+    F = s[Ge] + 4;
+    let d = !1;
+    if (c.isFourCC)
+      switch (p = s[le], p) {
+        case v:
+          P = 8, T = 33777;
+          break;
+        case ee:
+          P = 16, T = 33778;
+          break;
+        case te:
+          P = 16, T = 33779;
+          break;
+        case re:
+          d = !0, m = 64;
+          break;
+        case ae:
+          d = !0, m = 128;
+          break;
+        case z: {
+          F += 5 * 4;
+          let x = !1;
+          switch (c.dxgiFormat) {
+            case oe:
+              d = !0, m = 64, x = !0;
+              break;
+            case se:
+              d = !0, m = 128, x = !0;
+              break;
+            case he:
+              c.isRGB = !0, c.isFourCC = !1, m = 32, x = !0;
+              break;
+          }
+          if (x)
+            break;
+        }
+        default:
+          console.error("Unsupported FourCC code:", Fe(p));
+          return;
+      }
+    const g = u._ExtractLongWordOrder(s[Be]), k = u._ExtractLongWordOrder(s[Re]), j = u._ExtractLongWordOrder(s[de]), ie = u._ExtractLongWordOrder(s[Ue]);
+    d && (T = a._getRGBABufferInternalSizedFormat(c.textureType)), w = 1, s[ne] & J && A !== !1 && (w = Math.max(1, s[ce]));
+    const ue = l || 0, I = a.getCaps();
+    for (let x = ue; x < C; x++) {
+      for (i = s[V], y = s[fe], U = 0; U < w; ++U) {
+        if (r === -1 || r === U) {
+          const h = r === -1 ? U : 0;
+          if (!c.isCompressed && c.isFourCC) {
+            f.format = 5, _ = i * y * 4;
+            let B = null;
+            if (a._badOS || a._badDesktopOS || !I.textureHalfFloat && !I.textureFloat)
+              m === 128 ? (B = u._GetFloatAsUIntRGBAArrayBuffer(i, y, o.byteOffset + F, _, o.buffer, h), t && h == 0 && t.push(u._GetFloatRGBAArrayBuffer(i, y, o.byteOffset + F, _, o.buffer, h))) : m === 64 && (B = u._GetHalfFloatAsUIntRGBAArrayBuffer(i, y, o.byteOffset + F, _, o.buffer, h), t && h == 0 && t.push(u._GetHalfFloatAsFloatRGBAArrayBuffer(i, y, o.byteOffset + F, _, o.buffer, h))), f.type = 0;
+            else {
+              const X = I.textureFloat && (e && I.textureFloatLinearFiltering || !e), W = I.textureHalfFloat && (e && I.textureHalfFloatLinearFiltering || !e), N = (m === 128 || m === 64 && !W) && X ? 1 : (m === 64 || m === 128 && !X) && W ? 2 : 0;
+              let M, O = null;
+              switch (m) {
+                case 128: {
+                  switch (N) {
+                    case 1:
+                      M = u._GetFloatRGBAArrayBuffer, O = null;
+                      break;
+                    case 2:
+                      M = u._GetFloatAsHalfFloatRGBAArrayBuffer, O = u._GetFloatRGBAArrayBuffer;
+                      break;
+                    case 0:
+                      M = u._GetFloatAsUIntRGBAArrayBuffer, O = u._GetFloatRGBAArrayBuffer;
+                      break;
+                  }
+                  break;
+                }
+                default: {
+                  switch (N) {
+                    case 1:
+                      M = u._GetHalfFloatAsFloatRGBAArrayBuffer, O = null;
+                      break;
+                    case 2:
+                      M = u._GetHalfFloatRGBAArrayBuffer, O = u._GetHalfFloatAsFloatRGBAArrayBuffer;
+                      break;
+                    case 0:
+                      M = u._GetHalfFloatAsUIntRGBAArrayBuffer, O = u._GetHalfFloatAsFloatRGBAArrayBuffer;
+                      break;
+                  }
+                  break;
+                }
+              }
+              f.type = N, B = M(i, y, o.byteOffset + F, _, o.buffer, h), t && h == 0 && t.push(O ? O(i, y, o.byteOffset + F, _, o.buffer, h) : B);
+            }
+            B && a._uploadDataToTextureDirectly(f, B, x, h);
+          } else if (c.isRGB)
+            f.type = 0, m === 24 ? (f.format = 4, _ = i * y * 3, b = u._GetRGBArrayBuffer(i, y, o.byteOffset + F, _, o.buffer, g, k, j), a._uploadDataToTextureDirectly(f, b, x, h)) : (f.format = 5, _ = i * y * 4, b = u._GetRGBAArrayBuffer(i, y, o.byteOffset + F, _, o.buffer, g, k, j, ie), a._uploadDataToTextureDirectly(f, b, x, h));
+          else if (c.isLuminance) {
+            const B = a._getUnpackAlignement(), X = i;
+            _ = Math.floor((i + B - 1) / B) * B * (y - 1) + X, b = u._GetLuminanceArrayBuffer(i, y, o.byteOffset + F, _, o.buffer), f.format = 1, f.type = 0, a._uploadDataToTextureDirectly(f, b, x, h);
+          } else
+            _ = Math.max(4, i) / 4 * Math.max(4, y) / 4 * P, b = new Uint8Array(o.buffer, o.byteOffset + F, _), f.type = 0, a._uploadCompressedDataToTextureDirectly(f, T, i, y, b, x, h);
+        }
+        F += m ? i * y * (m / 8) : _, i *= 0.5, y *= 0.5, i = Math.max(1, i), y = Math.max(1, y);
+      }
+      if (l !== void 0)
+        break;
+    }
+    t && t.length > 0 ? c.sphericalPolynomial = ye.ConvertCubeMapToSphericalPolynomial({
+      size: s[V],
+      right: t[0],
+      left: t[1],
+      up: t[2],
+      down: t[3],
+      front: t[4],
+      back: t[5],
+      format: 5,
+      type: 1,
+      gammaSpace: !1
+    }) : c.sphericalPolynomial = void 0;
+  }
+}
+u.StoreLODInAlphaChannel = !1;
+Ce.prototype.createPrefilteredCubeTexture = function(G, a, f, o, c = null, A = null, C, r = null, l = !0) {
+  const e = (t) => {
+    if (!t) {
+      c && c(null);
+      return;
+    }
+    const n = t.texture;
+    if (l ? t.info.sphericalPolynomial && (n._sphericalPolynomial = t.info.sphericalPolynomial) : n._sphericalPolynomial = new Ae(), n._source = q.CubePrefiltered, this.getCaps().textureLOD) {
+      c && c(n);
+      return;
+    }
+    const s = 3, p = this._gl, i = t.width;
+    if (!i)
+      return;
+    const y = [];
+    for (let _ = 0; _ < s; _++) {
+      const b = 1 - _ / (s - 1), w = o, U = R.Log2(i) * f + o, T = w + (U - w) * b, P = Math.round(Math.min(Math.max(T, 0), U)), m = new pe(this, q.Temp);
+      if (m.type = n.type, m.format = n.format, m.width = Math.pow(2, Math.max(R.Log2(i) - P, 0)), m.height = m.width, m.isCube = !0, m._cachedWrapU = 0, m._cachedWrapV = 0, this._bindTextureDirectly(p.TEXTURE_CUBE_MAP, m, !0), m.samplingMode = 2, p.texParameteri(p.TEXTURE_CUBE_MAP, p.TEXTURE_MAG_FILTER, p.LINEAR), p.texParameteri(p.TEXTURE_CUBE_MAP, p.TEXTURE_MIN_FILTER, p.LINEAR), p.texParameteri(p.TEXTURE_CUBE_MAP, p.TEXTURE_WRAP_S, p.CLAMP_TO_EDGE), p.texParameteri(p.TEXTURE_CUBE_MAP, p.TEXTURE_WRAP_T, p.CLAMP_TO_EDGE), t.isDDS) {
+        const g = t.info, k = t.data;
+        this._unpackFlipY(g.isCompressed), u.UploadDDSLevels(this, m, k, g, !0, 6, P);
+      } else
+        H.Warn("DDS is the only prefiltered cube map supported so far.");
+      this._bindTextureDirectly(p.TEXTURE_CUBE_MAP, null);
+      const d = new me(a);
+      d._isCube = !0, d._texture = m, m.isReady = !0, y.push(d);
+    }
+    n._lodTextureHigh = y[2], n._lodTextureMid = y[1], n._lodTextureLow = y[0], c && c(n);
+  };
+  return this.createCubeTexture(G, a, null, !1, e, A, C, r, l, f, o);
+};
+export {
+  u as DDSTools
+};