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

package/dist/node_modules/@babylonjs/core/assetContainer.esm.js

@@ -0,0 +1,425 @@
+import { AbstractScene as x } from "./abstractScene.esm.js";
+import { Mesh as N } from "./Meshes/mesh.esm.js";
+import { TransformNode as _ } from "./Meshes/transformNode.esm.js";
+import { Logger as E } from "./Misc/logger.esm.js";
+import { EngineStore as C } from "./Engines/engineStore.esm.js";
+import { InstancedMesh as A } from "./Meshes/instancedMesh.esm.js";
+import { Light as b } from "./Lights/light.esm.js";
+import { Camera as O } from "./Cameras/camera.esm.js";
+import { Tools as v } from "./Misc/tools.esm.js";
+class q extends x {
+}
+class w {
+  constructor() {
+    this.rootNodes = [], this.skeletons = [], this.animationGroups = [];
+  }
+  /**
+   * Disposes the instantiated entries from the scene
+   */
+  dispose() {
+    this.rootNodes.slice(0).forEach((e) => {
+      e.dispose();
+    }), this.rootNodes.length = 0, this.skeletons.slice(0).forEach((e) => {
+      e.dispose();
+    }), this.skeletons.length = 0, this.animationGroups.slice(0).forEach((e) => {
+      e.dispose();
+    }), this.animationGroups.length = 0;
+  }
+}
+class W extends x {
+  /**
+   * Instantiates an AssetContainer.
+   * @param scene The scene the AssetContainer belongs to.
+   */
+  constructor(e) {
+    super(), this._wasAddedToScene = !1, e = e || C.LastCreatedScene, e && (this.scene = e, this.sounds = [], this.effectLayers = [], this.layers = [], this.lensFlareSystems = [], this.proceduralTextures = [], this.reflectionProbes = [], e.onDisposeObservable.add(() => {
+      this._wasAddedToScene || this.dispose();
+    }), this._onContextRestoredObserver = e.getEngine().onContextRestoredObservable.add(() => {
+      for (const t of this.geometries)
+        t._rebuild();
+      for (const t of this.meshes)
+        t._rebuild();
+      for (const t of this.particleSystems)
+        t.rebuild();
+      for (const t of this.textures)
+        t._rebuild();
+    }));
+  }
+  /**
+   * Given a list of nodes, return a topological sorting of them.
+   * @param nodes
+   */
+  _topologicalSort(e) {
+    const t = /* @__PURE__ */ new Map();
+    for (const n of e)
+      t.set(n.uniqueId, n);
+    const h = {
+      dependsOn: /* @__PURE__ */ new Map(),
+      dependedBy: /* @__PURE__ */ new Map()
+      // given a node id, what are the ids of the nodes that depend on it
+    };
+    for (const n of e) {
+      const o = n.uniqueId;
+      h.dependsOn.set(o, /* @__PURE__ */ new Set()), h.dependedBy.set(o, /* @__PURE__ */ new Set());
+    }
+    for (const n of e) {
+      const o = n.uniqueId, d = h.dependsOn.get(o);
+      if (n instanceof A) {
+        const u = n.sourceMesh;
+        t.has(u.uniqueId) && (d.add(u.uniqueId), h.dependedBy.get(u.uniqueId).add(o));
+      }
+      const g = h.dependedBy.get(o);
+      for (const u of n.getDescendants()) {
+        const T = u.uniqueId;
+        t.has(T) && (g.add(T), h.dependsOn.get(T).add(o));
+      }
+    }
+    const a = [], l = [];
+    for (const n of e) {
+      const o = n.uniqueId;
+      h.dependsOn.get(o).size === 0 && (l.push(n), t.delete(o));
+    }
+    const m = l;
+    for (; m.length > 0; ) {
+      const n = m.shift();
+      a.push(n);
+      const o = h.dependedBy.get(n.uniqueId);
+      for (const d of Array.from(o.values())) {
+        const g = h.dependsOn.get(d);
+        g.delete(n.uniqueId), g.size === 0 && t.get(d) && (m.push(t.get(d)), t.delete(d));
+      }
+    }
+    return t.size > 0 && (console.error("SceneSerializer._topologicalSort: There were unvisited nodes:"), t.forEach((n) => console.error(n.name))), a;
+  }
+  _addNodeAndDescendantsToList(e, t, h, a) {
+    if (!(!h || a && !a(h) || t.has(h.uniqueId))) {
+      e.push(h), t.add(h.uniqueId);
+      for (const l of h.getDescendants(!0))
+        this._addNodeAndDescendantsToList(e, t, l, a);
+    }
+  }
+  /**
+   * Check if a specific node is contained in this asset container.
+   * @param node
+   */
+  _isNodeInContainer(e) {
+    return e instanceof N && this.meshes.indexOf(e) !== -1 || e instanceof _ && this.transformNodes.indexOf(e) !== -1 || e instanceof b && this.lights.indexOf(e) !== -1 || e instanceof O && this.cameras.indexOf(e) !== -1;
+  }
+  /**
+   * For every node in the scene, check if its parent node is also in the scene.
+   */
+  _isValidHierarchy() {
+    for (const e of this.meshes)
+      if (e.parent && !this._isNodeInContainer(e.parent))
+        return E.Warn(`Node ${e.name} has a parent that is not in the container.`), !1;
+    for (const e of this.transformNodes)
+      if (e.parent && !this._isNodeInContainer(e.parent))
+        return E.Warn(`Node ${e.name} has a parent that is not in the container.`), !1;
+    for (const e of this.lights)
+      if (e.parent && !this._isNodeInContainer(e.parent))
+        return E.Warn(`Node ${e.name} has a parent that is not in the container.`), !1;
+    for (const e of this.cameras)
+      if (e.parent && !this._isNodeInContainer(e.parent))
+        return E.Warn(`Node ${e.name} has a parent that is not in the container.`), !1;
+    return !0;
+  }
+  /**
+   * Instantiate or clone all meshes and add the new ones to the scene.
+   * Skeletons and animation groups will all be cloned
+   * @param nameFunction defines an optional function used to get new names for clones
+   * @param cloneMaterials defines an optional boolean that defines if materials must be cloned as well (false by default)
+   * @param options defines an optional list of options to control how to instantiate / clone models
+   * @param options.doNotInstantiate defines if the model must be instantiated or just cloned
+   * @param options.predicate defines a predicate used to filter whih mesh to instantiate/clone
+   * @returns a list of rootNodes, skeletons and animation groups that were duplicated
+   */
+  instantiateModelsToScene(e, t = !1, h) {
+    this._isValidHierarchy() || v.Warn("SceneSerializer.InstantiateModelsToScene: The Asset Container hierarchy is not valid.");
+    const a = {}, l = {}, m = new w(), n = [], o = [], d = Object.assign({ doNotInstantiate: !0 }, h), g = (s, i) => {
+      if (a[s.uniqueId] = i.uniqueId, l[i.uniqueId] = i, e && (i.name = e(s.name)), i instanceof N) {
+        const r = i;
+        if (r.morphTargetManager) {
+          const f = s.morphTargetManager;
+          r.morphTargetManager = f.clone();
+          for (let c = 0; c < f.numTargets; c++) {
+            const M = f.getTarget(c), p = r.morphTargetManager.getTarget(c);
+            a[M.uniqueId] = p.uniqueId, l[p.uniqueId] = p;
+          }
+        }
+      }
+    }, u = [], T = /* @__PURE__ */ new Set();
+    for (const s of this.transformNodes)
+      s.parent === null && this._addNodeAndDescendantsToList(u, T, s, d.predicate);
+    for (const s of this.meshes)
+      s.parent === null && this._addNodeAndDescendantsToList(u, T, s, d.predicate);
+    const y = this._topologicalSort(u), S = (s, i) => {
+      if (g(s, i), s.parent) {
+        const r = a[s.parent.uniqueId], f = l[r];
+        f ? i.parent = f : i.parent = s.parent;
+      }
+      if (i.position && s.position && i.position.copyFrom(s.position), i.rotationQuaternion && s.rotationQuaternion && i.rotationQuaternion.copyFrom(s.rotationQuaternion), i.rotation && s.rotation && i.rotation.copyFrom(s.rotation), i.scaling && s.scaling && i.scaling.copyFrom(s.scaling), i.material) {
+        const r = i;
+        if (r.material)
+          if (t) {
+            const f = s.material;
+            if (o.indexOf(f) === -1) {
+              let c = f.clone(e ? e(f.name) : "Clone of " + f.name);
+              if (o.push(f), a[f.uniqueId] = c.uniqueId, l[c.uniqueId] = c, f.getClassName() === "MultiMaterial") {
+                const M = f;
+                for (const p of M.subMaterials)
+                  p && (c = p.clone(e ? e(p.name) : "Clone of " + p.name), o.push(p), a[p.uniqueId] = c.uniqueId, l[c.uniqueId] = c);
+                M.subMaterials = M.subMaterials.map((p) => p && l[a[p.uniqueId]]);
+              }
+            }
+            r.getClassName() !== "InstancedMesh" && (r.material = l[a[f.uniqueId]]);
+          } else
+            r.material.getClassName() === "MultiMaterial" ? this.scene.multiMaterials.indexOf(r.material) === -1 && this.scene.addMultiMaterial(r.material) : this.scene.materials.indexOf(r.material) === -1 && this.scene.addMaterial(r.material);
+      }
+      i.parent === null && m.rootNodes.push(i);
+    };
+    return y.forEach((s) => {
+      if (s.getClassName() === "InstancedMesh") {
+        const i = s, r = i.sourceMesh, f = a[r.uniqueId], M = (typeof f == "number" ? l[f] : r).createInstance(i.name);
+        S(i, M);
+      } else {
+        let i = !0;
+        s.getClassName() === "TransformNode" || s.getClassName() === "Node" || s.skeleton || !s.getTotalVertices || s.getTotalVertices() === 0 ? i = !1 : d.doNotInstantiate && (typeof d.doNotInstantiate == "function" ? i = !d.doNotInstantiate(s) : i = !d.doNotInstantiate);
+        const r = i ? s.createInstance(`instance of ${s.name}`) : s.clone(`Clone of ${s.name}`, null, !0);
+        if (!r)
+          throw new Error(`Could not clone or instantiate node on Asset Container ${s.name}`);
+        S(s, r);
+      }
+    }), this.skeletons.forEach((s) => {
+      if (d.predicate && !d.predicate(s))
+        return;
+      const i = s.clone(e ? e(s.name) : "Clone of " + s.name);
+      for (const r of this.meshes)
+        if (r.skeleton === s && !r.isAnInstance) {
+          const f = l[a[r.uniqueId]];
+          if (!f || f.isAnInstance || (f.skeleton = i, n.indexOf(i) !== -1))
+            continue;
+          n.push(i);
+          for (const c of i.bones)
+            c._linkedTransformNode && (c._linkedTransformNode = l[a[c._linkedTransformNode.uniqueId]]);
+        }
+      m.skeletons.push(i);
+    }), this.animationGroups.forEach((s) => {
+      if (d.predicate && !d.predicate(s))
+        return;
+      const i = s.clone(e ? e(s.name) : "Clone of " + s.name, (r) => l[a[r.uniqueId]] || r);
+      m.animationGroups.push(i);
+    }), m;
+  }
+  /**
+   * Adds all the assets from the container to the scene.
+   */
+  addAllToScene() {
+    if (!this._wasAddedToScene) {
+      this._isValidHierarchy() || v.Warn("SceneSerializer.addAllToScene: The Asset Container hierarchy is not valid."), this._wasAddedToScene = !0, this.addToScene(null), this.environmentTexture && (this.scene.environmentTexture = this.environmentTexture);
+      for (const e of this.scene._serializableComponents)
+        e.addFromContainer(this);
+      this.scene.getEngine().onContextRestoredObservable.remove(this._onContextRestoredObserver), this._onContextRestoredObserver = null;
+    }
+  }
+  /**
+   * Adds assets from the container to the scene.
+   * @param predicate defines a predicate used to select which entity will be added (can be null)
+   */
+  addToScene(e = null) {
+    this.cameras.forEach((t) => {
+      e && !e(t) || this.scene.addCamera(t);
+    }), this.lights.forEach((t) => {
+      e && !e(t) || this.scene.addLight(t);
+    }), this.meshes.forEach((t) => {
+      e && !e(t) || this.scene.addMesh(t);
+    }), this.skeletons.forEach((t) => {
+      e && !e(t) || this.scene.addSkeleton(t);
+    }), this.animations.forEach((t) => {
+      e && !e(t) || this.scene.addAnimation(t);
+    }), this.animationGroups.forEach((t) => {
+      e && !e(t) || this.scene.addAnimationGroup(t);
+    }), this.multiMaterials.forEach((t) => {
+      e && !e(t) || this.scene.addMultiMaterial(t);
+    }), this.materials.forEach((t) => {
+      e && !e(t) || this.scene.addMaterial(t);
+    }), this.morphTargetManagers.forEach((t) => {
+      e && !e(t) || this.scene.addMorphTargetManager(t);
+    }), this.geometries.forEach((t) => {
+      e && !e(t) || this.scene.addGeometry(t);
+    }), this.transformNodes.forEach((t) => {
+      e && !e(t) || this.scene.addTransformNode(t);
+    }), this.actionManagers.forEach((t) => {
+      e && !e(t) || this.scene.addActionManager(t);
+    }), this.textures.forEach((t) => {
+      e && !e(t) || this.scene.addTexture(t);
+    }), this.reflectionProbes.forEach((t) => {
+      e && !e(t) || this.scene.addReflectionProbe(t);
+    });
+  }
+  /**
+   * Removes all the assets in the container from the scene
+   */
+  removeAllFromScene() {
+    this._isValidHierarchy() || v.Warn("SceneSerializer.removeAllFromScene: The Asset Container hierarchy is not valid."), this._wasAddedToScene = !1, this.removeFromScene(null), this.environmentTexture === this.scene.environmentTexture && (this.scene.environmentTexture = null);
+    for (const e of this.scene._serializableComponents)
+      e.removeFromContainer(this);
+  }
+  /**
+   * Removes assets in the container from the scene
+   * @param predicate defines a predicate used to select which entity will be added (can be null)
+   */
+  removeFromScene(e = null) {
+    this.cameras.forEach((t) => {
+      e && !e(t) || this.scene.removeCamera(t);
+    }), this.lights.forEach((t) => {
+      e && !e(t) || this.scene.removeLight(t);
+    }), this.meshes.forEach((t) => {
+      e && !e(t) || this.scene.removeMesh(t);
+    }), this.skeletons.forEach((t) => {
+      e && !e(t) || this.scene.removeSkeleton(t);
+    }), this.animations.forEach((t) => {
+      e && !e(t) || this.scene.removeAnimation(t);
+    }), this.animationGroups.forEach((t) => {
+      e && !e(t) || this.scene.removeAnimationGroup(t);
+    }), this.multiMaterials.forEach((t) => {
+      e && !e(t) || this.scene.removeMultiMaterial(t);
+    }), this.materials.forEach((t) => {
+      e && !e(t) || this.scene.removeMaterial(t);
+    }), this.morphTargetManagers.forEach((t) => {
+      e && !e(t) || this.scene.removeMorphTargetManager(t);
+    }), this.geometries.forEach((t) => {
+      e && !e(t) || this.scene.removeGeometry(t);
+    }), this.transformNodes.forEach((t) => {
+      e && !e(t) || this.scene.removeTransformNode(t);
+    }), this.actionManagers.forEach((t) => {
+      e && !e(t) || this.scene.removeActionManager(t);
+    }), this.textures.forEach((t) => {
+      e && !e(t) || this.scene.removeTexture(t);
+    }), this.reflectionProbes.forEach((t) => {
+      e && !e(t) || this.scene.removeReflectionProbe(t);
+    });
+  }
+  /**
+   * Disposes all the assets in the container
+   */
+  dispose() {
+    this.cameras.slice(0).forEach((e) => {
+      e.dispose();
+    }), this.cameras.length = 0, this.lights.slice(0).forEach((e) => {
+      e.dispose();
+    }), this.lights.length = 0, this.meshes.slice(0).forEach((e) => {
+      e.dispose();
+    }), this.meshes.length = 0, this.skeletons.slice(0).forEach((e) => {
+      e.dispose();
+    }), this.skeletons.length = 0, this.animationGroups.slice(0).forEach((e) => {
+      e.dispose();
+    }), this.animationGroups.length = 0, this.multiMaterials.slice(0).forEach((e) => {
+      e.dispose();
+    }), this.multiMaterials.length = 0, this.materials.slice(0).forEach((e) => {
+      e.dispose();
+    }), this.materials.length = 0, this.geometries.slice(0).forEach((e) => {
+      e.dispose();
+    }), this.geometries.length = 0, this.transformNodes.slice(0).forEach((e) => {
+      e.dispose();
+    }), this.transformNodes.length = 0, this.actionManagers.slice(0).forEach((e) => {
+      e.dispose();
+    }), this.actionManagers.length = 0, this.textures.slice(0).forEach((e) => {
+      e.dispose();
+    }), this.textures.length = 0, this.reflectionProbes.slice(0).forEach((e) => {
+      e.dispose();
+    }), this.reflectionProbes.length = 0, this.morphTargetManagers.slice(0).forEach((e) => {
+      e.dispose();
+    }), this.morphTargetManagers.length = 0, this.environmentTexture && (this.environmentTexture.dispose(), this.environmentTexture = null);
+    for (const e of this.scene._serializableComponents)
+      e.removeFromContainer(this, !0);
+    this._onContextRestoredObserver && (this.scene.getEngine().onContextRestoredObservable.remove(this._onContextRestoredObserver), this._onContextRestoredObserver = null);
+  }
+  _moveAssets(e, t, h) {
+    if (!(!e || !t))
+      for (const a of e) {
+        let l = !0;
+        if (h) {
+          for (const m of h)
+            if (a === m) {
+              l = !1;
+              break;
+            }
+        }
+        l && (t.push(a), a._parentContainer = this);
+      }
+  }
+  /**
+   * Removes all the assets contained in the scene and adds them to the container.
+   * @param keepAssets Set of assets to keep in the scene. (default: empty)
+   */
+  moveAllFromScene(e) {
+    this._wasAddedToScene = !1, e === void 0 && (e = new q());
+    for (const t in this)
+      Object.prototype.hasOwnProperty.call(this, t) && (this[t] = this[t] || (t === "_environmentTexture" ? null : []), this._moveAssets(this.scene[t], this[t], e[t]));
+    this.environmentTexture = this.scene.environmentTexture, this.removeAllFromScene();
+  }
+  /**
+   * Adds all meshes in the asset container to a root mesh that can be used to position all the contained meshes. The root mesh is then added to the front of the meshes in the assetContainer.
+   * @returns the root mesh
+   */
+  createRootMesh() {
+    const e = new N("assetContainerRootMesh", this.scene);
+    return this.meshes.forEach((t) => {
+      t.parent || e.addChild(t);
+    }), this.meshes.unshift(e), e;
+  }
+  /**
+   * Merge animations (direct and animation groups) from this asset container into a scene
+   * @param scene is the instance of BABYLON.Scene to append to (default: last created scene)
+   * @param animatables set of animatables to retarget to a node from the scene
+   * @param targetConverter defines a function used to convert animation targets from the asset container to the scene (default: search node by name)
+   * @returns an array of the new AnimationGroup added to the scene (empty array if none)
+   */
+  mergeAnimationsTo(e = C.LastCreatedScene, t, h = null) {
+    if (!e)
+      return E.Error("No scene available to merge animations to"), [];
+    const a = h || ((n) => {
+      let o = null;
+      const d = n.animations.length ? n.animations[0].targetProperty : "", g = n.name.split(".").join("").split("_primitive")[0];
+      switch (d) {
+        case "position":
+        case "rotationQuaternion":
+          o = e.getTransformNodeByName(n.name) || e.getTransformNodeByName(g);
+          break;
+        case "influence":
+          o = e.getMorphTargetByName(n.name) || e.getMorphTargetByName(g);
+          break;
+        default:
+          o = e.getNodeByName(n.name) || e.getNodeByName(g);
+      }
+      return o;
+    });
+    this.getNodes().forEach((n) => {
+      const o = a(n);
+      if (o !== null) {
+        for (const d of n.animations) {
+          const g = o.animations.filter((u) => u.targetProperty === d.targetProperty);
+          for (const u of g) {
+            const T = o.animations.indexOf(u, 0);
+            T > -1 && o.animations.splice(T, 1);
+          }
+        }
+        o.animations = o.animations.concat(n.animations);
+      }
+    });
+    const m = new Array();
+    return this.animationGroups.slice().forEach((n) => {
+      m.push(n.clone(n.name, a)), n.animatables.forEach((o) => {
+        o.stop();
+      });
+    }), t.forEach((n) => {
+      const o = a(n.target);
+      o && (e.beginAnimation(o, n.fromFrame, n.toFrame, n.loopAnimation, n.speedRatio, n.onAnimationEnd ? n.onAnimationEnd : void 0, void 0, !0, void 0, n.onAnimationLoop ? n.onAnimationLoop : void 0), e.stopAnimation(n.target));
+    }), m;
+  }
+}
+export {
+  W as AssetContainer,
+  w as InstantiatedEntries,
+  q as KeepAssets
+};