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

package/dist/node_modules/@babylonjs/loaders/glTF/2.0/Extensions/MSFT_audio_emitter.esm.js

@@ -0,0 +1,149 @@
+import { Vector3 as _ } from "../../../../core/Maths/math.vector.esm.js";
+import { Tools as f } from "../../../../core/Misc/tools.esm.js";
+import { AnimationEvent as p } from "../../../../core/Animations/animationEvent.esm.js";
+import { Sound as y } from "../../../../core/Audio/sound.esm.js";
+import { WeightedSound as g } from "../../../../core/Audio/weightedsound.esm.js";
+import { GLTFLoader as h, ArrayItem as d } from "../glTFLoader.esm.js";
+const m = "MSFT_audio_emitter";
+class b {
+  /**
+   * @internal
+   */
+  constructor(s) {
+    this.name = m, this._loader = s, this.enabled = this._loader.isExtensionUsed(m);
+  }
+  /** @internal */
+  dispose() {
+    this._loader = null, this._clips = null, this._emitters = null;
+  }
+  /** @internal */
+  onLoading() {
+    const s = this._loader.gltf.extensions;
+    if (s && s[this.name]) {
+      const e = s[this.name];
+      this._clips = e.clips, this._emitters = e.emitters, d.Assign(this._clips), d.Assign(this._emitters);
+    }
+  }
+  /**
+   * @internal
+   */
+  loadSceneAsync(s, e) {
+    return h.LoadExtensionAsync(s, e, this.name, (o, t) => {
+      const r = new Array();
+      r.push(this._loader.loadSceneAsync(s, e));
+      for (const a of t.emitters) {
+        const n = d.Get(`${o}/emitters`, this._emitters, a);
+        if (n.refDistance != null || n.maxDistance != null || n.rolloffFactor != null || n.distanceModel != null || n.innerAngle != null || n.outerAngle != null)
+          throw new Error(`${o}: Direction or Distance properties are not allowed on emitters attached to a scene`);
+        r.push(this._loadEmitterAsync(`${o}/emitters/${n.index}`, n));
+      }
+      return Promise.all(r).then(() => {
+      });
+    });
+  }
+  /**
+   * @internal
+   */
+  loadNodeAsync(s, e, o) {
+    return h.LoadExtensionAsync(s, e, this.name, (t, r) => {
+      const a = new Array();
+      return this._loader.loadNodeAsync(t, e, (n) => {
+        for (const l of r.emitters) {
+          const i = d.Get(`${t}/emitters`, this._emitters, l);
+          a.push(this._loadEmitterAsync(`${t}/emitters/${i.index}`, i).then(() => {
+            for (const c of i._babylonSounds)
+              c.attachToMesh(n), (i.innerAngle != null || i.outerAngle != null) && (c.setLocalDirectionToMesh(_.Forward()), c.setDirectionalCone(2 * f.ToDegrees(i.innerAngle == null ? Math.PI : i.innerAngle), 2 * f.ToDegrees(i.outerAngle == null ? Math.PI : i.outerAngle), 0));
+          }));
+        }
+        o(n);
+      }).then((n) => Promise.all(a).then(() => n));
+    });
+  }
+  /**
+   * @internal
+   */
+  loadAnimationAsync(s, e) {
+    return h.LoadExtensionAsync(s, e, this.name, (o, t) => this._loader.loadAnimationAsync(s, e).then((r) => {
+      const a = new Array();
+      d.Assign(t.events);
+      for (const n of t.events)
+        a.push(this._loadAnimationEventAsync(`${o}/events/${n.index}`, s, e, n, r));
+      return Promise.all(a).then(() => r);
+    }));
+  }
+  _loadClipAsync(s, e) {
+    if (e._objectURL)
+      return e._objectURL;
+    let o;
+    if (e.uri)
+      o = this._loader.loadUriAsync(s, e, e.uri);
+    else {
+      const t = d.Get(`${s}/bufferView`, this._loader.gltf.bufferViews, e.bufferView);
+      o = this._loader.loadBufferViewAsync(`/bufferViews/${t.index}`, t);
+    }
+    return e._objectURL = o.then((t) => URL.createObjectURL(new Blob([t], { type: e.mimeType }))), e._objectURL;
+  }
+  _loadEmitterAsync(s, e) {
+    if (e._babylonSounds = e._babylonSounds || [], !e._babylonData) {
+      const o = new Array(), t = e.name || `emitter${e.index}`, r = {
+        loop: !1,
+        autoplay: !1,
+        volume: e.volume == null ? 1 : e.volume
+      };
+      for (let n = 0; n < e.clips.length; n++) {
+        const l = `/extensions/${this.name}/clips`, i = d.Get(l, this._clips, e.clips[n].clip);
+        o.push(this._loadClipAsync(`${l}/${e.clips[n].clip}`, i).then((c) => {
+          const u = e._babylonSounds[n] = new y(t, c, this._loader.babylonScene, null, r);
+          u.refDistance = e.refDistance || 1, u.maxDistance = e.maxDistance || 256, u.rolloffFactor = e.rolloffFactor || 1, u.distanceModel = e.distanceModel || "exponential";
+        }));
+      }
+      const a = Promise.all(o).then(() => {
+        const n = e.clips.map((i) => i.weight || 1), l = new g(e.loop || !1, e._babylonSounds, n);
+        e.innerAngle && (l.directionalConeInnerAngle = 2 * f.ToDegrees(e.innerAngle)), e.outerAngle && (l.directionalConeOuterAngle = 2 * f.ToDegrees(e.outerAngle)), e.volume && (l.volume = e.volume), e._babylonData.sound = l;
+      });
+      e._babylonData = {
+        loaded: a
+      };
+    }
+    return e._babylonData.loaded;
+  }
+  _getEventAction(s, e, o, t, r) {
+    switch (o) {
+      case "play":
+        return (a) => {
+          const n = (r || 0) + (a - t);
+          e.play(n);
+        };
+      case "stop":
+        return () => {
+          e.stop();
+        };
+      case "pause":
+        return () => {
+          e.pause();
+        };
+      default:
+        throw new Error(`${s}: Unsupported action ${o}`);
+    }
+  }
+  _loadAnimationEventAsync(s, e, o, t, r) {
+    if (r.targetedAnimations.length == 0)
+      return Promise.resolve();
+    const a = r.targetedAnimations[0], n = t.emitter, l = d.Get(`/extensions/${this.name}/emitters`, this._emitters, n);
+    return this._loadEmitterAsync(s, l).then(() => {
+      const i = l._babylonData.sound;
+      if (i) {
+        const c = new p(t.time, this._getEventAction(s, i, t.action, t.time, t.startOffset));
+        a.animation.addEvent(c), r.onAnimationGroupEndObservable.add(() => {
+          i.stop();
+        }), r.onAnimationGroupPauseObservable.add(() => {
+          i.pause();
+        });
+      }
+    });
+  }
+}
+h.RegisterExtension(m, (A) => new b(A));
+export {
+  b as MSFT_audio_emitter
+};

package/dist/node_modules/@babylonjs/loaders/glTF/2.0/Extensions/MSFT_lod.esm.js

@@ -0,0 +1,170 @@
+import { Observable as c } from "../../../../core/Misc/observable.esm.js";
+import { Deferred as O } from "../../../../core/Misc/deferred.esm.js";
+import { GLTFLoader as D, ArrayItem as g } from "../glTFLoader.esm.js";
+const m = "MSFT_lod";
+class b {
+  /**
+   * @internal
+   */
+  constructor(e) {
+    this.name = m, this.order = 100, this.maxLODsToLoad = 10, this.onNodeLODsLoadedObservable = new c(), this.onMaterialLODsLoadedObservable = new c(), this._bufferLODs = new Array(), this._nodeIndexLOD = null, this._nodeSignalLODs = new Array(), this._nodePromiseLODs = new Array(), this._nodeBufferLODs = new Array(), this._materialIndexLOD = null, this._materialSignalLODs = new Array(), this._materialPromiseLODs = new Array(), this._materialBufferLODs = new Array(), this._loader = e, this.enabled = this._loader.isExtensionUsed(m);
+  }
+  /** @internal */
+  dispose() {
+    this._loader = null, this._nodeIndexLOD = null, this._nodeSignalLODs.length = 0, this._nodePromiseLODs.length = 0, this._nodeBufferLODs.length = 0, this._materialIndexLOD = null, this._materialSignalLODs.length = 0, this._materialPromiseLODs.length = 0, this._materialBufferLODs.length = 0, this.onMaterialLODsLoadedObservable.clear(), this.onNodeLODsLoadedObservable.clear();
+  }
+  /** @internal */
+  onReady() {
+    for (let e = 0; e < this._nodePromiseLODs.length; e++) {
+      const r = Promise.all(this._nodePromiseLODs[e]).then(() => {
+        e !== 0 && (this._loader.endPerformanceCounter(`Node LOD ${e}`), this._loader.log(`Loaded node LOD ${e}`)), this.onNodeLODsLoadedObservable.notifyObservers(e), e !== this._nodePromiseLODs.length - 1 && (this._loader.startPerformanceCounter(`Node LOD ${e + 1}`), this._loadBufferLOD(this._nodeBufferLODs, e + 1), this._nodeSignalLODs[e] && this._nodeSignalLODs[e].resolve());
+      });
+      this._loader._completePromises.push(r);
+    }
+    for (let e = 0; e < this._materialPromiseLODs.length; e++) {
+      const r = Promise.all(this._materialPromiseLODs[e]).then(() => {
+        e !== 0 && (this._loader.endPerformanceCounter(`Material LOD ${e}`), this._loader.log(`Loaded material LOD ${e}`)), this.onMaterialLODsLoadedObservable.notifyObservers(e), e !== this._materialPromiseLODs.length - 1 && (this._loader.startPerformanceCounter(`Material LOD ${e + 1}`), this._loadBufferLOD(this._materialBufferLODs, e + 1), this._materialSignalLODs[e] && this._materialSignalLODs[e].resolve());
+      });
+      this._loader._completePromises.push(r);
+    }
+  }
+  /**
+   * @internal
+   */
+  loadSceneAsync(e, r) {
+    const s = this._loader.loadSceneAsync(e, r);
+    return this._loadBufferLOD(this._bufferLODs, 0), s;
+  }
+  /**
+   * @internal
+   */
+  loadNodeAsync(e, r, s) {
+    return D.LoadExtensionAsync(e, r, this.name, (t, o) => {
+      let a;
+      const d = this._getLODs(t, r, this._loader.gltf.nodes, o.ids);
+      this._loader.logOpen(`${t}`);
+      for (let n = 0; n < d.length; n++) {
+        const l = d[n];
+        n !== 0 && (this._nodeIndexLOD = n, this._nodeSignalLODs[n] = this._nodeSignalLODs[n] || new O());
+        const i = (_) => {
+          s(_), _.setEnabled(!1);
+        }, h = this._loader.loadNodeAsync(`/nodes/${l.index}`, l, i).then((_) => {
+          if (n !== 0) {
+            const L = d[n - 1];
+            L._babylonTransformNode && (this._disposeTransformNode(L._babylonTransformNode), delete L._babylonTransformNode);
+          }
+          return _.setEnabled(!0), _;
+        });
+        this._nodePromiseLODs[n] = this._nodePromiseLODs[n] || [], n === 0 ? a = h : (this._nodeIndexLOD = null, this._nodePromiseLODs[n].push(h));
+      }
+      return this._loader.logClose(), a;
+    });
+  }
+  /**
+   * @internal
+   */
+  _loadMaterialAsync(e, r, s, t, o) {
+    return this._nodeIndexLOD ? null : D.LoadExtensionAsync(e, r, this.name, (a, d) => {
+      let n;
+      const l = this._getLODs(a, r, this._loader.gltf.materials, d.ids);
+      this._loader.logOpen(`${a}`);
+      for (let i = 0; i < l.length; i++) {
+        const h = l[i];
+        i !== 0 && (this._materialIndexLOD = i);
+        const _ = this._loader._loadMaterialAsync(`/materials/${h.index}`, h, s, t, (L) => {
+          i === 0 && o(L);
+        }).then((L) => {
+          if (i !== 0) {
+            o(L);
+            const f = l[i - 1]._data;
+            f[t] && (this._disposeMaterials([f[t].babylonMaterial]), delete f[t]);
+          }
+          return L;
+        });
+        this._materialPromiseLODs[i] = this._materialPromiseLODs[i] || [], i === 0 ? n = _ : (this._materialIndexLOD = null, this._materialPromiseLODs[i].push(_));
+      }
+      return this._loader.logClose(), n;
+    });
+  }
+  /**
+   * @internal
+   */
+  _loadUriAsync(e, r, s) {
+    if (this._nodeIndexLOD !== null) {
+      this._loader.log("deferred");
+      const t = this._nodeIndexLOD - 1;
+      return this._nodeSignalLODs[t] = this._nodeSignalLODs[t] || new O(), this._nodeSignalLODs[this._nodeIndexLOD - 1].promise.then(() => this._loader.loadUriAsync(e, r, s));
+    } else if (this._materialIndexLOD !== null) {
+      this._loader.log("deferred");
+      const t = this._materialIndexLOD - 1;
+      return this._materialSignalLODs[t] = this._materialSignalLODs[t] || new O(), this._materialSignalLODs[t].promise.then(() => this._loader.loadUriAsync(e, r, s));
+    }
+    return null;
+  }
+  /**
+   * @internal
+   */
+  loadBufferAsync(e, r, s, t) {
+    if (this._loader.parent.useRangeRequests && !r.uri) {
+      if (!this._loader.bin)
+        throw new Error(`${e}: Uri is missing or the binary glTF is missing its binary chunk`);
+      const o = (a, d) => {
+        const n = s, l = n + t - 1;
+        let i = a[d];
+        return i ? (i.start = Math.min(i.start, n), i.end = Math.max(i.end, l)) : (i = { start: n, end: l, loaded: new O() }, a[d] = i), i.loaded.promise.then((h) => new Uint8Array(h.buffer, h.byteOffset + s - i.start, t));
+      };
+      return this._loader.log("deferred"), this._nodeIndexLOD !== null ? o(this._nodeBufferLODs, this._nodeIndexLOD) : this._materialIndexLOD !== null ? o(this._materialBufferLODs, this._materialIndexLOD) : o(this._bufferLODs, 0);
+    }
+    return null;
+  }
+  _loadBufferLOD(e, r) {
+    const s = e[r];
+    s && (this._loader.log(`Loading buffer range [${s.start}-${s.end}]`), this._loader.bin.readAsync(s.start, s.end - s.start + 1).then((t) => {
+      s.loaded.resolve(t);
+    }, (t) => {
+      s.loaded.reject(t);
+    }));
+  }
+  /**
+   * Gets an array of LOD properties from lowest to highest.
+   * @param context
+   * @param property
+   * @param array
+   * @param ids
+   */
+  _getLODs(e, r, s, t) {
+    if (this.maxLODsToLoad <= 0)
+      throw new Error("maxLODsToLoad must be greater than zero");
+    const o = new Array();
+    for (let a = t.length - 1; a >= 0; a--)
+      if (o.push(g.Get(`${e}/ids/${t[a]}`, s, t[a])), o.length === this.maxLODsToLoad)
+        return o;
+    return o.push(r), o;
+  }
+  _disposeTransformNode(e) {
+    const r = new Array(), s = e.material;
+    s && r.push(s);
+    for (const o of e.getChildMeshes())
+      o.material && r.push(o.material);
+    e.dispose();
+    const t = r.filter((o) => this._loader.babylonScene.meshes.every((a) => a.material != o));
+    this._disposeMaterials(t);
+  }
+  _disposeMaterials(e) {
+    const r = {};
+    for (const s of e) {
+      for (const t of s.getActiveTextures())
+        r[t.uniqueId] = t;
+      s.dispose();
+    }
+    for (const s in r)
+      for (const t of this._loader.babylonScene.materials)
+        t.hasTexture(r[s]) && delete r[s];
+    for (const s in r)
+      r[s].dispose();
+  }
+}
+D.RegisterExtension(m, (u) => new b(u));
+export {
+  b as MSFT_lod
+};

package/dist/node_modules/@babylonjs/loaders/glTF/2.0/Extensions/MSFT_minecraftMesh.esm.js

@@ -0,0 +1,29 @@
+import { PBRMaterial as h } from "../../../../core/Materials/PBR/pbrMaterial.esm.js";
+import { GLTFLoader as n } from "../glTFLoader.esm.js";
+const t = "MSFT_minecraftMesh";
+class p {
+  /** @internal */
+  constructor(r) {
+    this.name = t, this._loader = r, this.enabled = this._loader.isExtensionUsed(t);
+  }
+  /** @internal */
+  dispose() {
+    this._loader = null;
+  }
+  /** @internal */
+  loadMaterialPropertiesAsync(r, i, e) {
+    return n.LoadExtraAsync(r, i, this.name, (o, d) => {
+      if (d) {
+        if (!(e instanceof h))
+          throw new Error(`${o}: Material type not supported`);
+        const c = this._loader.loadMaterialPropertiesAsync(r, i, e);
+        return e.needAlphaBlending() && (e.forceDepthWrite = !0, e.separateCullingPass = !0), e.backFaceCulling = e.forceDepthWrite, e.twoSidedLighting = !0, c;
+      }
+      return null;
+    });
+  }
+}
+n.RegisterExtension(t, (s) => new p(s));
+export {
+  p as MSFT_minecraftMesh
+};

package/dist/node_modules/@babylonjs/loaders/glTF/2.0/Extensions/MSFT_sRGBFactors.esm.js

@@ -0,0 +1,29 @@
+import { PBRMaterial as p } from "../../../../core/Materials/PBR/pbrMaterial.esm.js";
+import { GLTFLoader as n } from "../glTFLoader.esm.js";
+const o = "MSFT_sRGBFactors";
+class u {
+  /** @internal */
+  constructor(r) {
+    this.name = o, this._loader = r, this.enabled = this._loader.isExtensionUsed(o);
+  }
+  /** @internal */
+  dispose() {
+    this._loader = null;
+  }
+  /** @internal */
+  loadMaterialPropertiesAsync(r, t, e) {
+    return n.LoadExtraAsync(r, t, this.name, (c, d) => {
+      if (d) {
+        if (!(e instanceof p))
+          throw new Error(`${c}: Material type not supported`);
+        const f = this._loader.loadMaterialPropertiesAsync(r, t, e), i = e.getScene().getEngine().useExactSrgbConversions;
+        return e.albedoTexture || e.albedoColor.toLinearSpaceToRef(e.albedoColor, i), e.reflectivityTexture || e.reflectivityColor.toLinearSpaceToRef(e.reflectivityColor, i), f;
+      }
+      return null;
+    });
+  }
+}
+n.RegisterExtension(o, (s) => new u(s));
+export {
+  u as MSFT_sRGBFactors
+};