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

package/dist/lib/productCamera.esm.js

@@ -0,0 +1,113 @@
+import { ArcRotateCamera as d } from "../node_modules/@babylonjs/core/Cameras/arcRotateCamera.esm.js";
+import { Vector3 as h } from "../node_modules/@babylonjs/core/Maths/math.vector.esm.js";
+class l extends d {
+  constructor(t, e, r, n, a, s, i, u) {
+    super(
+      t,
+      e,
+      r,
+      n,
+      a,
+      s,
+      u
+    ), this.lastFocus = new h(0, 0, 0), this.panDenominator = 1, this.minZ = 0.01, this.setRadius(this.radius), this.enableFramingBehavior(), this.wheelDeltaPercentage = 0.01, this.pinchDeltaPercentage = 5e-3, this.useNaturalPinchZoom = !0, i.camera.autoOrientation && (this.alpha += Math.PI), i && (i.camera.limits.min.beta && (this.lowerBetaLimit = i.camera.limits.min.beta), i.camera.limits.max.beta && (this.upperBetaLimit = i.camera.limits.max.beta), i.camera.limits.min.alpha && (this.lowerAlphaLimit = i.camera.limits.min.alpha), i.camera.limits.max.alpha && (this.upperAlphaLimit = i.camera.limits.max.alpha), i.camera.limits.min.radius && (this.lowerRadiusLimit = i.camera.limits.min.radius), i.camera.limits.max.radius && (this.upperRadiusLimit = i.camera.limits.max.radius), i.camera.autoRotation.enabled && this.enableAutoRotationBehavior(
+      i.camera.autoRotation.idleTimeMs
+    ));
+  }
+  /**
+   * Returns the framing behavior of this camera.
+   */
+  getFramingBehavior() {
+    return this.getBehaviorByName("Framing");
+  }
+  /**
+   * Returns the auto rotation behavior of this camera, this may
+   * not always be available.
+   */
+  getAutoRotationBehavior() {
+    const t = this.getBehaviorByName("AutoRotation");
+    if (t)
+      return t;
+  }
+  /**
+   * Activates framing on this camera causing the camera to focus on
+   * the scene and bound itself in a sensible fashion to the scene content.
+   */
+  enableFramingBehavior() {
+    this.useFramingBehavior = !0;
+    const t = this.getFramingBehavior();
+    t.attach(this), t.framingTime = 0, t.elevationReturnTime = -1, t.zoomStopsAnimation = !1, this.lowerRadiusLimit = null;
+    const e = m(this._scene);
+    return t.zoomOnBoundingInfo(e.min, e.max), this.wheelPrecision = 100 / this.radius, this.lowerRadiusLimit === null && (this.lowerRadiusLimit = 0.1), this.lastFocus.copyFrom(this.target), t;
+  }
+  /**
+   * Animates the camera back to the initial target when it has drifted to another position.
+   * @param onAnimationComplete A callback when the camera has finished animating.
+   * @param time The time in milliseconds the animation should take.
+   */
+  rerunFramingBehavior(t, e) {
+    const r = this.getFramingBehavior();
+    r.framingTime = e || 800;
+    const n = () => {
+      t && t();
+    }, a = m(this._scene), s = a.max.subtract(a.min), i = a.min.add(s.scale(0.5));
+    this.setRadius(s.length() * 1.5), this.wheelPrecision = 100 / this.radius, this.panningInertia = 0, this.panningOriginTarget.copyFrom(i), this.panDenominator = s.length(), r.zoomOnBoundingInfo(
+      a.min,
+      a.max,
+      void 0,
+      n
+    ), r.framingTime = 0;
+  }
+  /**
+   * Activates the auto rotation behavior causing the camera to rotate slowly around
+   * it's target.
+   * @param idleTime The number of milliseconds before the camera starts rotating after the user last interacted.
+   */
+  enableAutoRotationBehavior(t = 5e3) {
+    this.useAutoRotationBehavior = !0;
+    const e = this.getAutoRotationBehavior();
+    e && (e.idleRotationWaitTime = t);
+  }
+  /**
+   * Stops the auto rotation functionality immediately.
+   */
+  disableAutoRotationBehavior() {
+    this.useAutoRotationBehavior = !1;
+  }
+  setRadius(t) {
+    this.radius = t, this.maxZ = this.radius * 1e3, this.lowerRadiusLimit = this.radius * 0.01, this.upperRadiusLimit = 1.5 * this.radius, this.wheelPrecision = 100 / this.radius, this.pinchPrecision = 300 / this.radius;
+  }
+  /**
+   * A static function used to instantiate a single product camera instance on a scene. This camera will assume
+   * the active camera role on the scene and any existing active camera will be disposed.
+   * @param scene The scene to attach the camera to.
+   * @param configuration A configuration object to define the cameras limitations.
+   * @param assignActive If true the camera will be assigned as the active camera on the scene.
+   */
+  static create(t, e, r) {
+    const n = m(t), a = n.max.subtract(n.min), s = n.min.add(a.scale(0.5)), i = new l(
+      "ProductCamera",
+      -(Math.PI / 2),
+      Math.PI / 2,
+      a.length() * 1.5,
+      s,
+      t,
+      e
+    );
+    return i.panningInertia = 0, i.panningOriginTarget.copyFrom(s), i.panDenominator = a.length(), i.onAfterCheckInputsObservable.add(() => {
+      i.panningSensibility = 1e3 / i.panDenominator;
+    }), r && (t.activeCamera = i), i;
+  }
+}
+function m(o) {
+  if (o.meshes.length === 0)
+    return {
+      min: new h(-1, -1, -1),
+      max: new h(1, 1, 1)
+    };
+  const t = o.meshes.filter((e) => e.name.toLowerCase().endsWith("_t") || e.name.toLowerCase().includes("_t_"));
+  return o.getWorldExtends((e) => e.isVisible && e.isEnabled() && (t.length === 0 || t.includes(e)));
+}
+export {
+  l as ProductCamera
+};

package/dist/lib/renderConstants.esm.js

@@ -0,0 +1,103 @@
+class e {
+  /**
+   * Returns the resolution expected for generated textures.
+   */
+  static getDynamicTextureResolution() {
+    return this.getIsMobile() || !e.offscreenRenderingSupported() ? {
+      width: 1024,
+      height: 1024
+    } : {
+      width: 2048,
+      height: 2048
+    };
+  }
+  /**
+   * Returns true when textures should generate mip maps
+   */
+  static shouldMipMap() {
+    return !0;
+  }
+  /**
+   * Returns true when multithreaded rendering is supported.
+   */
+  static offscreenRenderingSupported() {
+    return navigator.userAgent.includes("SamsungBrowser") ? !1 : !!window.Worker && !!window.OffscreenCanvas;
+  }
+  /**
+   * Returns the resolution expected for mirror textures.
+   */
+  static getMirrorTextureResolution() {
+    return this.getIsMobile() ? 512 : 1024;
+  }
+  static getIsMobile() {
+    try {
+      return typeof window > "u" || !window.navigator ? !1 : /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(
+        window.navigator.userAgent
+      ) || window.innerWidth <= 480;
+    } catch {
+      return !1;
+    }
+  }
+}
+const n = 128, a = {
+  antiAliasing: {
+    samples: 4,
+    fxaaEnabled: !1
+  },
+  bloom: {
+    enabled: !1,
+    kernel: 64,
+    scale: 0.5,
+    threshold: 0.9,
+    weight: 0.15
+  },
+  chromaticAberration: {
+    enabled: !1,
+    aberrationAmount: 30,
+    direction: { x: 0, y: 0 },
+    radialIntensity: 0
+  },
+  colorCurves: {
+    enabled: !1
+    // Color curves values implicitly set to undefined
+  },
+  depthOfField: {
+    enabled: !1,
+    blurLevel: "Low",
+    focalLength: 50,
+    focusDistance: 2e3,
+    fStop: 1.4,
+    lensSize: 50
+  },
+  grain: {
+    enabled: !1,
+    animated: !1,
+    intensity: 30
+  },
+  misc: {
+    contrast: 1,
+    exposure: 1,
+    toneMappingEnabled: !1,
+    toneMappingType: "Standard"
+  },
+  sharpen: {
+    enabled: !1,
+    colorAmount: 1,
+    edgeAmount: 0.3
+  },
+  vignette: {
+    enabled: !1,
+    blendMode: "Multiply",
+    cameraFov: 0.5,
+    center: { x: 0, y: 0 },
+    colorHex: "#000000ff",
+    colorRgba: { r: 0, g: 0, b: 0, a: 1 },
+    stretch: 0,
+    weight: 1
+  }
+};
+export {
+  n as REFLECTION_PROBE_RESOLUTION,
+  e as RenderingConfiguration,
+  a as renderingPipelineDefaults
+};

package/dist/lib/renderingPipeline.esm.js

@@ -0,0 +1,99 @@
+import { ColorCurves as G } from "../node_modules/@babylonjs/core/Materials/colorCurves.esm.js";
+import { ImageProcessingConfiguration as r } from "../node_modules/@babylonjs/core/Materials/imageProcessingConfiguration.esm.js";
+import { Color4 as s } from "../node_modules/@babylonjs/core/Maths/math.color.esm.js";
+import { Vector2 as _ } from "../node_modules/@babylonjs/core/Maths/math.vector.esm.js";
+import { DefaultRenderingPipeline as z } from "../node_modules/@babylonjs/core/PostProcesses/RenderPipeline/Pipelines/defaultRenderingPipeline.esm.js";
+import "../node_modules/@babylonjs/core/Materials/Textures/texture.esm.js";
+import "../node_modules/@babylonjs/core/Misc/logger.esm.js";
+import "../node_modules/@babylonjs/core/Engines/Extensions/engine.dynamicTexture.esm.js";
+import "../node_modules/@babylonjs/core/PostProcesses/postProcess.esm.js";
+import "../node_modules/@babylonjs/core/PostProcesses/RenderPipeline/postProcessRenderPipeline.esm.js";
+import "../node_modules/@babylonjs/core/Misc/tools.esm.js";
+import "../node_modules/@babylonjs/core/PostProcesses/RenderPipeline/postProcessRenderPipelineManagerSceneComponent.esm.js";
+import "../node_modules/@babylonjs/core/Shaders/chromaticAberration.fragment.esm.js";
+import "../node_modules/@babylonjs/core/Shaders/lensHighlights.fragment.esm.js";
+import "../node_modules/@babylonjs/core/Shaders/depthOfField.fragment.esm.js";
+import "../node_modules/@babylonjs/core/PostProcesses/RenderPipeline/Pipelines/ssao2RenderingPipeline.esm.js";
+import "../node_modules/@babylonjs/core/PostProcesses/RenderPipeline/Pipelines/ssaoRenderingPipeline.esm.js";
+import "../node_modules/@babylonjs/core/PostProcesses/RenderPipeline/Pipelines/standardRenderingPipeline.esm.js";
+import "../node_modules/@babylonjs/core/PostProcesses/RenderPipeline/Pipelines/ssrRenderingPipeline.esm.js";
+import { DepthOfFieldEffectBlurLevel as l } from "../node_modules/@babylonjs/core/PostProcesses/depthOfFieldEffect.esm.js";
+import { renderingPipelineDefaults as i } from "./renderConstants.esm.js";
+import "../node_modules/@babylonjs/core/Rendering/depthRendererSceneComponent.esm.js";
+class oe {
+  constructor(e, t = !1, n = void 0) {
+    this.renderingPipeline = new z(
+      "default",
+      t,
+      e,
+      n ? [n] : void 0,
+      !1
+      // Disable automatic build
+    ), this.renderingPipeline.isSupported && (this.renderingPipeline.prepare(), this.setConfiguration(i));
+  }
+  dispose() {
+    this.renderingPipeline.dispose();
+  }
+  getConfiguration() {
+    return this.currentConfiguration;
+  }
+  setConfiguration(e) {
+    var t, n, d, a, h, o, p, g, m, b, P, c, v, E, A, u, w, C, O, y, S, x, F, D, M, H, L, T, R, k, I, N, B;
+    if (this.renderingPipeline.isSupported) {
+      if (this.renderingPipeline.samples = ((t = e.antiAliasing) == null ? void 0 : t.samples) ?? i.antiAliasing.samples, this.renderingPipeline.fxaaEnabled = ((n = e.antiAliasing) == null ? void 0 : n.fxaaEnabled) ?? i.antiAliasing.fxaaEnabled, this.renderingPipeline.bloomEnabled = ((d = e.bloom) == null ? void 0 : d.enabled) ?? i.bloom.enabled, this.renderingPipeline.bloomKernel = ((a = e.bloom) == null ? void 0 : a.kernel) ?? i.bloom.kernel, this.renderingPipeline.bloomScale = ((h = e.bloom) == null ? void 0 : h.scale) ?? i.bloom.scale, this.renderingPipeline.bloomThreshold = ((o = e.bloom) == null ? void 0 : o.threshold) ?? i.bloom.threshold, this.renderingPipeline.bloomWeight = ((p = e.bloom) == null ? void 0 : p.weight) ?? i.bloom.weight, this.renderingPipeline.chromaticAberrationEnabled = ((g = e.chromaticAberration) == null ? void 0 : g.enabled) ?? i.chromaticAberration.enabled, this.renderingPipeline.chromaticAberration.aberrationAmount = ((m = e.chromaticAberration) == null ? void 0 : m.aberrationAmount) ?? i.chromaticAberration.aberrationAmount, this.renderingPipeline.chromaticAberration.radialIntensity = ((b = e.chromaticAberration) == null ? void 0 : b.radialIntensity) ?? i.chromaticAberration.radialIntensity, this.renderingPipeline.chromaticAberration.direction = (P = e.chromaticAberration) != null && P.direction ? new _(
+        e.chromaticAberration.direction.x,
+        e.chromaticAberration.direction.y
+      ) : new _(
+        i.chromaticAberration.direction.x,
+        i.chromaticAberration.direction.y
+      ), this.renderingPipeline.imageProcessing.colorCurvesEnabled = ((c = e.colorCurves) == null ? void 0 : c.enabled) ?? i.colorCurves.enabled, this.renderingPipeline.imageProcessing.colorCurves = e.colorCurves ? this.updateColorCurve(e.colorCurves) : new G(), this.renderingPipeline.depthOfFieldEnabled = ((v = e.depthOfField) == null ? void 0 : v.enabled) ?? i.depthOfField.enabled, e.depthOfField)
+        switch (e.depthOfField.blurLevel ?? i.depthOfField.blurLevel) {
+          case "Low":
+            this.renderingPipeline.depthOfFieldBlurLevel = l.Low;
+            break;
+          case "Medium":
+            this.renderingPipeline.depthOfFieldBlurLevel = l.Medium;
+            break;
+          case "High":
+            this.renderingPipeline.depthOfFieldBlurLevel = l.High;
+            break;
+        }
+      if (this.renderingPipeline.depthOfField.focalLength = ((E = e.depthOfField) == null ? void 0 : E.focalLength) ?? i.depthOfField.focalLength, this.renderingPipeline.depthOfField.fStop = ((A = e.depthOfField) == null ? void 0 : A.fStop) ?? i.depthOfField.fStop, this.renderingPipeline.depthOfField.focusDistance = ((u = e.depthOfField) == null ? void 0 : u.focusDistance) ?? i.depthOfField.focusDistance, this.renderingPipeline.depthOfField.lensSize = ((w = e.depthOfField) == null ? void 0 : w.lensSize) ?? i.depthOfField.lensSize, this.renderingPipeline.grainEnabled = ((C = e.grain) == null ? void 0 : C.enabled) ?? i.grain.enabled, this.renderingPipeline.grain.animated = ((O = e.grain) == null ? void 0 : O.animated) ?? i.grain.animated, this.renderingPipeline.grain.intensity = ((y = e.grain) == null ? void 0 : y.intensity) ?? i.grain.intensity, this.renderingPipeline.imageProcessing.contrast = ((S = e.misc) == null ? void 0 : S.contrast) ?? i.misc.contrast, this.renderingPipeline.imageProcessing.exposure = ((x = e.misc) == null ? void 0 : x.exposure) ?? i.misc.exposure, this.renderingPipeline.imageProcessing.toneMappingEnabled = ((F = e.misc) == null ? void 0 : F.toneMappingEnabled) ?? i.misc.toneMappingEnabled, this.renderingPipeline.imageProcessing.toneMappingEnabled)
+        switch (e.misc.toneMappingType ?? i.misc.toneMappingType) {
+          case "Standard":
+            this.renderingPipeline.imageProcessing.toneMappingType = r.TONEMAPPING_STANDARD;
+            break;
+          case "ACES":
+            this.renderingPipeline.imageProcessing.toneMappingType = r.TONEMAPPING_ACES;
+            break;
+        }
+      if (this.renderingPipeline.sharpenEnabled = ((D = e.sharpen) == null ? void 0 : D.enabled) ?? i.sharpen.enabled, this.renderingPipeline.sharpen.colorAmount = ((M = e.sharpen) == null ? void 0 : M.colorAmount) ?? i.sharpen.colorAmount, this.renderingPipeline.sharpen.edgeAmount = ((H = e.sharpen) == null ? void 0 : H.edgeAmount) ?? i.sharpen.edgeAmount, this.renderingPipeline.imageProcessing.vignetteEnabled = ((L = e.vignette) == null ? void 0 : L.enabled) ?? i.vignette.enabled, (T = e.vignette) != null && T.center ? (this.renderingPipeline.imageProcessing.vignetteCenterX = e.vignette.center.x, this.renderingPipeline.imageProcessing.vignetteCenterY = e.vignette.center.y) : (this.renderingPipeline.imageProcessing.vignetteCenterX = i.vignette.center.x, this.renderingPipeline.imageProcessing.vignetteCenterY = i.vignette.center.y), e.vignette)
+        switch (((R = e.vignette) == null ? void 0 : R.blendMode) ?? i.vignette.blendMode) {
+          case "Multiply":
+            this.renderingPipeline.imageProcessing.vignetteBlendMode = r.VIGNETTEMODE_MULTIPLY;
+            break;
+          case "Opaque":
+            this.renderingPipeline.imageProcessing.vignetteBlendMode = r.VIGNETTEMODE_OPAQUE;
+            break;
+        }
+      (k = e.vignette) != null && k.colorRgba ? this.renderingPipeline.imageProcessing.vignetteColor = new s(
+        e.vignette.colorRgba.r,
+        e.vignette.colorRgba.g,
+        e.vignette.colorRgba.b,
+        e.vignette.colorRgba.a
+      ) : (I = e.vignette) != null && I.colorHex ? this.renderingPipeline.imageProcessing.vignetteColor = s.FromHexString(e.vignette.colorHex) : this.renderingPipeline.imageProcessing.vignetteColor = new s(
+        i.vignette.colorRgba.r,
+        i.vignette.colorRgba.g,
+        i.vignette.colorRgba.b,
+        i.vignette.colorRgba.a
+      ), this.renderingPipeline.imageProcessing.vignetteStretch = ((N = e.vignette) == null ? void 0 : N.stretch) ?? i.vignette.stretch, this.renderingPipeline.imageProcessing.vignetteWeight = ((B = e.vignette) == null ? void 0 : B.weight) ?? i.vignette.weight, this.renderingPipeline.prepare(), this.currentConfiguration = e;
+    }
+  }
+  updateColorCurve(e) {
+    const t = new G();
+    return t.globalDensity = e.globalDensity ?? t.globalDensity, t.globalExposure = e.globalExposure ?? t.globalExposure, t.globalHue = e.globalHue ?? t.globalHue, t.globalSaturation = e.globalSaturation ?? t.globalSaturation, t.highlightsDensity = e.highlightsDensity ?? t.highlightsDensity, t.highlightsExposure = e.highlightsExposure ?? t.highlightsExposure, t.highlightsHue = e.highlightsHue ?? t.highlightsHue, t.highlightsSaturation = e.highlightsSaturation ?? t.highlightsSaturation, t.midtonesDensity = e.midtonesDensity ?? t.midtonesDensity, t.midtonesExposure = e.midtonesExposure ?? t.midtonesExposure, t.midtonesHue = e.midtonesHue ?? t.midtonesHue, t.midtonesSaturation = e.midtonesSaturation ?? t.midtonesSaturation, t.shadowsDensity = e.shadowsDensity ?? t.shadowsDensity, t.shadowsExposure = e.shadowsExposure ?? t.shadowsExposure, t.shadowsHue = e.shadowsHue ?? t.shadowsHue, t.shadowsSaturation = e.shadowsSaturation ?? t.shadowsSaturation, t;
+  }
+}
+export {
+  oe as RenderingPipeline
+};

package/dist/lib/types.esm.js

@@ -0,0 +1,5 @@
+var n = /* @__PURE__ */ ((e) => (e[e.Orbit = 0] = "Orbit", e[e.Pan = 1] = "Pan", e))(n || {}), p = /* @__PURE__ */ ((e) => (e.None = "None", e.RemoveWhenSelected = "RemoveWhenSelected", e.ApplyWhenSelected = "ApplyWhenSelected", e))(p || {});
+export {
+  p as MaterialEffectMode,
+  n as ProductCameraRig
+};

package/dist/lib/variants.esm.js

@@ -0,0 +1,112 @@
+import { AssetsManager as f } from "../node_modules/@babylonjs/core/Misc/assetsManager.esm.js";
+import { getAssetContainer as u } from "./assetCache.esm.js";
+import { calculateMaterialProperties as m, applyDownloadedTexture as y } from "./material.esm.js";
+class g {
+  constructor(e, t, a) {
+    this.materialVariantMap = /* @__PURE__ */ new Map(), this.keysThatRemovedBaseModel = [], this.loadedContainerForKey = /* @__PURE__ */ new Map(), this.loadedMaterialsForKey = /* @__PURE__ */ new Map(), this.scene = e, this.renameClonedAsset = t, this.setBaseModelEnabled = a;
+  }
+  /**
+   * Apply a material variant to a given scene.
+   * @param targetMaterial The name of the material in the scene we should be targeting.
+   * @param material The material variant to apply.
+   * @param onProgress A progress callback function for loading bars and event timing.
+   * @param removeWhenUndefined material application is an additive process, setting this bool to true will
+   * instead remove material textures when they aren't defined. this is useful for material editor applications
+   * where we want to undo changes are remove effects from display.
+   */
+  async applyMaterial(e, t, a, l) {
+    return new Promise((o) => {
+      const d = this.materialVariantMap.get(e);
+      this.materialVariantMap.set(e, {
+        ...d,
+        ...t
+      });
+      const h = this.renameClonedAsset(e), n = this.scene.materials.filter(
+        (s) => s.name === h
+      );
+      if (n.length === 0) {
+        o();
+        return;
+      }
+      const i = new f(this.scene);
+      i.useDefaultLoadingScreen = !1, n.forEach(
+        (s) => m(
+          t,
+          s,
+          i,
+          l
+        )
+      ), i.onProgress = (s, r, c) => {
+        a && a(s / r * 100, 100, c.name);
+      }, i.onFinish = (s) => {
+        s.forEach((r) => {
+          const c = r;
+          a && a(100, 100, r.name), n.forEach(
+            (p) => y(
+              r.name,
+              p,
+              t,
+              c.texture
+            )
+          );
+        }), o();
+      }, i.loadAsync();
+    });
+  }
+  /**
+   * Applies a model variant.
+   * @param key The key to uniquely identify this model variant application.
+   * @param replaceProductModel When true, we should replace the base product model.
+   * @param model The details for the new model, when undefined we should remove the variant associated to the given key.
+   * @param onProgress A load progress callback that can be used for loading bars and event timing.
+   */
+  async applyModel(e, t, a, l) {
+    var n, i;
+    if (a && t && !this.keysThatRemovedBaseModel.includes(e) && this.keysThatRemovedBaseModel.push(e), !a)
+      return this.keysThatRemovedBaseModel.includes(e) && this.setBaseModelEnabled(!0), (n = this.loadedContainerForKey.get(e)) == null || n.dispose(), this.loadedContainerForKey.delete(e), this.loadedMaterialsForKey.delete(e), Promise.resolve(void 0);
+    this.loadedContainerForKey.has(e) && ((i = this.loadedContainerForKey.get(e)) == null || i.dispose(), this.loadedContainerForKey.delete(e), this.loadedMaterialsForKey.delete(e)), t && this.setBaseModelEnabled(!1);
+    const d = (await u(a, this.scene, l)).instantiateModelsToScene(
+      this.renameClonedAsset,
+      !0
+    );
+    this.loadedContainerForKey.set(e, d), this.loadedMaterialsForKey.set(e, F(d));
+    const h = [];
+    return this.materialVariantMap.forEach(async (s, r) => {
+      h.push(this.applyMaterial(r, s));
+    }), await Promise.all(h), d;
+  }
+  dispose() {
+    this.loadedContainerForKey.forEach((e) => e == null ? void 0 : e.dispose()), this.loadedContainerForKey.clear(), this.loadedMaterialsForKey.forEach(
+      (e) => e.forEach((t) => t == null ? void 0 : t.dispose())
+    ), this.loadedMaterialsForKey.clear(), this.materialVariantMap.clear(), this.keysThatRemovedBaseModel = [];
+  }
+  getAllMaterials() {
+    const e = [];
+    return this.loadedMaterialsForKey.forEach((t) => {
+      t.forEach((a) => {
+        e.includes(a) || e.push(a);
+      });
+    }), e;
+  }
+  getAnimationGroups() {
+    const e = [];
+    return this.loadedContainerForKey.forEach((t) => {
+      e.push(...t.animationGroups);
+    }), e;
+  }
+}
+function F(M) {
+  const e = [];
+  return M.rootNodes.forEach((t) => {
+    t.getChildMeshes().forEach((a) => {
+      a.material && !e.includes(a.material) && e.push(a.material), a.subMeshes && a.subMeshes.forEach((l) => {
+        const o = l.getMaterial(!1);
+        o && !e.includes(o) && e.push(o);
+      });
+    });
+  }), e;
+}
+export {
+  g as default,
+  F as getAllMaterialsForInstance
+};

package/dist/node_modules/@babylonjs/core/Actions/abstractActionManager.esm.js

@@ -0,0 +1,41 @@
+class r {
+  constructor() {
+    this.hoverCursor = "", this.actions = new Array(), this.isRecursive = !1;
+  }
+  /**
+   * Does exist one action manager with at least one trigger
+   **/
+  static get HasTriggers() {
+    for (const e in r.Triggers)
+      if (Object.prototype.hasOwnProperty.call(r.Triggers, e))
+        return !0;
+    return !1;
+  }
+  /**
+   * Does exist one action manager with at least one pick trigger
+   **/
+  static get HasPickTriggers() {
+    for (const e in r.Triggers)
+      if (Object.prototype.hasOwnProperty.call(r.Triggers, e)) {
+        const s = parseInt(e);
+        if (s >= 1 && s <= 7)
+          return !0;
+      }
+    return !1;
+  }
+  /**
+   * Does exist one action manager that handles actions of a given trigger
+   * @param trigger defines the trigger to be tested
+   * @returns a boolean indicating whether the trigger is handled by at least one action manager
+   **/
+  static HasSpecificTrigger(e) {
+    for (const s in r.Triggers)
+      if (Object.prototype.hasOwnProperty.call(r.Triggers, s) && parseInt(s) === e)
+        return !0;
+    return !1;
+  }
+}
+r.Triggers = {};
+export {
+  r as AbstractActionManager
+};

package/dist/node_modules/@babylonjs/core/Actions/action.esm.js

@@ -0,0 +1,122 @@
+import { Observable as s } from "../Misc/observable.esm.js";
+import { Vector2 as c, Vector3 as a } from "../Maths/math.vector.esm.js";
+import { Color3 as h, Color4 as _ } from "../Maths/math.color.esm.js";
+import { RegisterClass as f } from "../Misc/typeStore.esm.js";
+class o {
+  /**
+   * Creates a new Action
+   * @param triggerOptions the trigger, with or without parameters, for the action
+   * @param condition an optional determinant of action
+   */
+  constructor(e, i) {
+    this.triggerOptions = e, this.onBeforeExecuteObservable = new s(), e.parameter ? (this.trigger = e.trigger, this._triggerParameter = e.parameter) : e.trigger ? this.trigger = e.trigger : this.trigger = e, this._nextActiveAction = this, this._condition = i;
+  }
+  /**
+   * Internal only
+   * @internal
+   */
+  _prepare() {
+  }
+  /**
+   * Gets the trigger parameter
+   * @returns the trigger parameter
+   */
+  getTriggerParameter() {
+    return this._triggerParameter;
+  }
+  /**
+   * Sets the trigger parameter
+   * @param value defines the new trigger parameter
+   */
+  setTriggerParameter(e) {
+    this._triggerParameter = e;
+  }
+  /**
+   * Internal only - Returns if the current condition allows to run the action
+   * @internal
+   */
+  _evaluateConditionForCurrentFrame() {
+    const e = this._condition;
+    if (!e)
+      return !0;
+    const i = this._actionManager.getScene().getRenderId();
+    return e._evaluationId !== i && (e._evaluationId = i, e._currentResult = e.isValid()), e._currentResult;
+  }
+  /**
+   * Internal only - executes current action event
+   * @internal
+   */
+  _executeCurrent(e) {
+    this._evaluateConditionForCurrentFrame() && (this.onBeforeExecuteObservable.notifyObservers(this), this._nextActiveAction.execute(e), this.skipToNextActiveAction());
+  }
+  /**
+   * Execute placeholder for child classes
+   * @param evt optional action event
+   */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  execute(e) {
+  }
+  /**
+   * Skips to next active action
+   */
+  skipToNextActiveAction() {
+    this._nextActiveAction._child ? (this._nextActiveAction._child._actionManager || (this._nextActiveAction._child._actionManager = this._actionManager), this._nextActiveAction = this._nextActiveAction._child) : this._nextActiveAction = this;
+  }
+  /**
+   * Adds action to chain of actions, may be a DoNothingAction
+   * @param action defines the next action to execute
+   * @returns The action passed in
+   * @see https://www.babylonjs-playground.com/#1T30HR#0
+   */
+  then(e) {
+    return this._child = e, e._actionManager = this._actionManager, e._prepare(), e;
+  }
+  /**
+   * Internal only
+   * @internal
+   */
+  _getProperty(e) {
+    return this._actionManager._getProperty(e);
+  }
+  /**
+   * @internal
+   */
+  _getEffectiveTarget(e, i) {
+    return this._actionManager._getEffectiveTarget(e, i);
+  }
+  /**
+   * Serialize placeholder for child classes
+   * @param parent of child
+   * @returns the serialized object
+   */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  serialize(e) {
+  }
+  /**
+   * Internal only called by serialize
+   * @internal
+   */
+  _serialize(e, i) {
+    const r = {
+      type: 1,
+      children: [],
+      name: e.name,
+      properties: e.properties || []
+    };
+    if (this._child && this._child.serialize(r), this._condition) {
+      const n = this._condition.serialize();
+      return n.children.push(r), i && i.children.push(n), n;
+    }
+    return i && i.children.push(r), r;
+  }
+}
+o._SerializeValueAsString = (t) => typeof t == "number" ? t.toString() : typeof t == "boolean" ? t ? "true" : "false" : t instanceof c ? t.x + ", " + t.y : t instanceof a ? t.x + ", " + t.y + ", " + t.z : t instanceof h ? t.r + ", " + t.g + ", " + t.b : t instanceof _ ? t.r + ", " + t.g + ", " + t.b + ", " + t.a : t;
+o._GetTargetProperty = (t) => ({
+  name: "target",
+  targetType: t._isMesh ? "MeshProperties" : t._isLight ? "LightProperties" : t._isCamera ? "CameraProperties" : t._isMaterial ? "MaterialProperties" : "SceneProperties",
+  value: t._isScene ? "Scene" : t.name
+});
+f("BABYLON.Action", o);
+export {
+  o as Action
+};

package/dist/node_modules/@babylonjs/core/Actions/actionEvent.esm.js

@@ -0,0 +1,59 @@
+class n {
+  /**
+   * Creates a new ActionEvent
+   * @param source The mesh or sprite that triggered the action
+   * @param pointerX The X mouse cursor position at the time of the event
+   * @param pointerY The Y mouse cursor position at the time of the event
+   * @param meshUnderPointer The mesh that is currently pointed at (can be null)
+   * @param sourceEvent the original (browser) event that triggered the ActionEvent
+   * @param additionalData additional data for the event
+   */
+  constructor(e, t, i, r, o, s) {
+    this.source = e, this.pointerX = t, this.pointerY = i, this.meshUnderPointer = r, this.sourceEvent = o, this.additionalData = s;
+  }
+  /**
+   * Helper function to auto-create an ActionEvent from a source mesh.
+   * @param source The source mesh that triggered the event
+   * @param evt The original (browser) event
+   * @param additionalData additional data for the event
+   * @returns the new ActionEvent
+   */
+  static CreateNew(e, t, i) {
+    const r = e.getScene();
+    return new n(e, r.pointerX, r.pointerY, r.meshUnderPointer || e, t, i);
+  }
+  /**
+   * Helper function to auto-create an ActionEvent from a source sprite
+   * @param source The source sprite that triggered the event
+   * @param scene Scene associated with the sprite
+   * @param evt The original (browser) event
+   * @param additionalData additional data for the event
+   * @returns the new ActionEvent
+   */
+  static CreateNewFromSprite(e, t, i, r) {
+    return new n(e, t.pointerX, t.pointerY, t.meshUnderPointer, i, r);
+  }
+  /**
+   * Helper function to auto-create an ActionEvent from a scene. If triggered by a mesh use ActionEvent.CreateNew
+   * @param scene the scene where the event occurred
+   * @param evt The original (browser) event
+   * @returns the new ActionEvent
+   */
+  static CreateNewFromScene(e, t) {
+    return new n(null, e.pointerX, e.pointerY, e.meshUnderPointer, t);
+  }
+  /**
+   * Helper function to auto-create an ActionEvent from a primitive
+   * @param prim defines the target primitive
+   * @param pointerPos defines the pointer position
+   * @param evt The original (browser) event
+   * @param additionalData additional data for the event
+   * @returns the new ActionEvent
+   */
+  static CreateNewFromPrimitive(e, t, i, r) {
+    return new n(e, t.x, t.y, null, i, r);
+  }
+}
+export {
+  n as ActionEvent
+};