@spiffcommerce/preview 5.5.8-alpha.2 → 5.5.8-alpha.3

package/dist/index.esm.js

@@ -0,0 +1,1739 @@
+import { ArcRotateCamera as fe } from "@babylonjs/core/Cameras/arcRotateCamera";
+import { Engine as be } from "@babylonjs/core/Engines/engine";
+import { NullEngine as Ce } from "@babylonjs/core/Engines/nullEngine";
+import { HighlightLayer as ye } from "@babylonjs/core/Layers/highlightLayer";
+import { SceneLoader as S } from "@babylonjs/core/Loading/sceneLoader";
+import { CubeTexture as ne } from "@babylonjs/core/Materials/Textures/cubeTexture";
+import { Color4 as b, Color3 as w } from "@babylonjs/core/Maths/math.color";
+import { Vector3 as p, Quaternion as y, Vector2 as se, Matrix as re } from "@babylonjs/core/Maths/math.vector";
+import { DracoCompression as Me } from "@babylonjs/core/Meshes/Compression/dracoCompression";
+import { Observable as C } from "@babylonjs/core/Misc/observable";
+import { Tools as Ae } from "@babylonjs/core/Misc/tools";
+import { Scene as Pe } from "@babylonjs/core/scene";
+import { GLTF2 as xe } from "@babylonjs/loaders/glTF";
+import { GLTFLoaderAnimationStartMode as Re } from "@babylonjs/loaders/glTF/glTFFileLoader";
+import { PBRMaterial as B } from "@babylonjs/core/Materials/PBR/pbrMaterial";
+import { MirrorTexture as Ee } from "@babylonjs/core/Materials/Textures/mirrorTexture";
+import { Color3 as Te, Vector3 as ae, Plane as Oe } from "@babylonjs/core/Maths/math";
+import { ReflectionProbe as Le } from "@babylonjs/core/Probes/reflectionProbe";
+import { GlowLayer as Ie } from "@babylonjs/core/Layers/glowLayer";
+import { ActionManager as R } from "@babylonjs/core/Actions/actionManager";
+import { ExecuteCodeAction as oe } from "@babylonjs/core/Actions/directActions";
+import { Mesh as Fe } from "@babylonjs/core/Meshes/mesh";
+import { TransformNode as Se } from "@babylonjs/core/Meshes/transformNode";
+import { DynamicTexture as Be } from "@babylonjs/core/Materials/Textures/dynamicTexture";
+import { Texture as De } from "@babylonjs/core/Materials/Textures/texture";
+import { Animation as v } from "@babylonjs/core/Animations/animation";
+import { QuadraticEase as ke, EasingFunction as ze } from "@babylonjs/core/Animations/easing";
+import { AssetsManager as Ve } from "@babylonjs/core/Misc/assetsManager";
+import { ColorCurves as le } from "@babylonjs/core/Materials/colorCurves";
+import { ImageProcessingConfiguration as P } from "@babylonjs/core/Materials/imageProcessingConfiguration";
+import { DefaultRenderingPipeline as qe } from "@babylonjs/core/PostProcesses/RenderPipeline";
+import { DepthOfFieldEffectBlurLevel as E } from "@babylonjs/core/PostProcesses/depthOfFieldEffect";
+import "@babylonjs/core/Rendering/depthRendererSceneComponent";
+import "@babylonjs/core/Engines/Extensions/engine.views";
+import "@babylonjs/core/Meshes/instancedMesh";
+import "@babylonjs/core/Materials/Textures/Loaders/ddsTextureLoader";
+import "@babylonjs/core/Materials/Textures/Loaders/envTextureLoader";
+import "@babylonjs/core/Materials/Textures/Loaders/ktxTextureLoader";
+import "@babylonjs/core/Animations/animatable";
+import "@babylonjs/core/Misc/screenshotTools";
+import "@babylonjs/core/Rendering/boundingBoxRenderer";
+import "@babylonjs/loaders/glTF/2.0/Extensions";
+var I = /* @__PURE__ */ ((n) => (n[n.Orbit = 0] = "Orbit", n[n.Pan = 1] = "Pan", n))(I || {}), F = /* @__PURE__ */ ((n) => (n.None = "None", n.RemoveWhenSelected = "RemoveWhenSelected", n.ApplyWhenSelected = "ApplyWhenSelected", n))(F || {});
+const he = /* @__PURE__ */ new Map();
+async function D(n, e, t) {
+  const i = he.get(n);
+  if (i)
+    return i;
+  {
+    const r = S.LoadAssetContainerAsync(
+      n,
+      void 0,
+      e,
+      t
+    );
+    return he.set(n, r), r;
+  }
+}
+S.OnPluginActivatedObservable.add((n) => {
+  n.name === "gltf" && (n.animationStartMode = Re.NONE);
+});
+class ce {
+  constructor(e) {
+    this.getSceneClearColor = () => {
+      var i, r, s, o;
+      const t = (i = this.customOptions) != null && i.transparentBackground || (r = this.customOptions) != null && r.backgroundImage ? 0 : 1;
+      if (this.customOptions && ((s = this.customOptions) != null && s.transparentBackground) || (o = this.customOptions) != null && o.backgroundImage)
+        return new b(0, 0, 0, t).toLinearSpace();
+      if (this.customOptions && this.customOptions.backgroundColor) {
+        const a = w.FromHexString(
+          this.customOptions.backgroundColor
+        );
+        return new b(
+          a.r,
+          a.g,
+          a.b,
+          t
+        ).toLinearSpace();
+      }
+      return new b(0.98, 0.98, 0.98, t).toLinearSpace();
+    }, this.highlightColorFromConfig = () => this.customOptions && this.customOptions.highlightColor ? this.hexToColor4(this.customOptions.highlightColor) : new b(0.98, 0.98, 0.98, 1).toLinearSpace(), this.hexToColor4 = (t, i = 1) => {
+      const r = w.FromHexString(t);
+      return new b(
+        r.r,
+        r.g,
+        r.b,
+        i
+      ).toLinearSpace();
+    }, this.customOptions = e;
+  }
+  createCanvas() {
+    var e;
+    return (e = this.customOptions) != null && e.createCanvas ? this.customOptions.createCanvas() : document.createElement("canvas");
+  }
+  get options() {
+    return this.customOptions;
+  }
+  /**
+   * Configuration related to the scene
+   */
+  get scene() {
+    var e, t, i, r, s;
+    return {
+      clearColor: this.getSceneClearColor(),
+      transparentBackground: ((e = this.customOptions) == null ? void 0 : e.transparentBackground) || ((t = this.customOptions) == null ? void 0 : t.backgroundImage),
+      environment: {
+        file: ((i = this.customOptions) == null ? void 0 : i.environmentFile) ?? "assets/model-viewer/default.env",
+        intensity: ((r = this.customOptions) == null ? void 0 : r.environmentIntensity) ?? 1,
+        rotationY: (((s = this.customOptions) == null ? void 0 : s.environmentRotationY) ?? 0) * (Math.PI / 180)
+        // Convert to radians
+      }
+    };
+  }
+  /**
+   * Configuration related to the camera used to view and interact with the scene.
+   */
+  get camera() {
+    var e, t, i, r, s, o, a, l, c, h, u, m, g;
+    return {
+      autoOrientation: ((e = this.customOptions) == null ? void 0 : e.disableAutomaticOrientation) ?? !0,
+      autoRotation: {
+        enabled: ((t = this.customOptions) == null ? void 0 : t.autoRotation) ?? !1,
+        idleTimeMs: ((i = this.customOptions) == null ? void 0 : i.idleTimeBeforeRotation) ?? 5e3
+      },
+      limits: {
+        min: {
+          alpha: (r = this.customOptions) != null && r.lowerAlphaLimitDeg ? ((s = this.customOptions) == null ? void 0 : s.lowerAlphaLimitDeg) * Math.PI / 180 : void 0,
+          beta: (o = this.customOptions) != null && o.lowerBetaLimitDeg ? ((a = this.customOptions) == null ? void 0 : a.lowerBetaLimitDeg) * Math.PI / 180 : void 0,
+          radius: (l = this.customOptions) == null ? void 0 : l.minZoomOverride
+        },
+        max: {
+          alpha: (c = this.customOptions) != null && c.upperAlphaLimitDeg ? ((h = this.customOptions) == null ? void 0 : h.upperAlphaLimitDeg) * Math.PI / 180 : void 0,
+          beta: (u = this.customOptions) != null && u.upperBetaLimitDeg ? ((m = this.customOptions) == null ? void 0 : m.upperBetaLimitDeg) * Math.PI / 180 : void 0,
+          radius: (g = this.customOptions) == null ? void 0 : g.maxZoomOverride
+        }
+      }
+    };
+  }
+  /**
+   * Configuration related to the highlighting system. Highlights are used to add
+   * a visual cue to the user that something is moused over in the preview.
+   */
+  get highlights() {
+    var e;
+    return {
+      enabled: ((e = this.customOptions) == null ? void 0 : e.highlightOnMaterialHover) ?? !1,
+      color: this.highlightColorFromConfig()
+    };
+  }
+  get lighting() {
+    var e, t, i, r;
+    return {
+      exposure: ((t = (e = this.customOptions) == null ? void 0 : e.lighting) == null ? void 0 : t.exposure) ?? 0.9,
+      contrast: ((r = (i = this.customOptions) == null ? void 0 : i.lighting) == null ? void 0 : r.contrast) ?? 1.6
+    };
+  }
+  get emissiveGlowIntensity() {
+    var e;
+    return ((e = this.customOptions) == null ? void 0 : e.emissiveGlowIntensity) ?? 0.5;
+  }
+}
+class A {
+  /**
+   * Returns the resolution expected for generated textures.
+   */
+  static getDynamicTextureResolution() {
+    return this.getIsMobile() || !A.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 / window.devicePixelRatio <= 480;
+    } catch {
+      return !1;
+    }
+  }
+}
+const Ne = 128, d = {
+  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
+  }
+};
+class Ge {
+  constructor(e) {
+    this.name = "glbPostProcessor", this.enabled = !0, this.loader = e;
+  }
+  onReady() {
+    this.applyReflections(this.loader.babylonScene);
+  }
+  /**
+   * Any custom properties set in blender on transform nodes will appear here. We can
+   * write the properties into the object metadata for retrieval at runtime.
+   */
+  loadNodeAsync(e, t, i) {
+    return this.loader.loadNodeAsync(
+      e,
+      t,
+      function(r) {
+        t.extras && Object.keys(t.extras).forEach((s) => {
+          const o = t.extras[s];
+          r.metadata[s] = o;
+        }), i(r);
+      }
+    );
+  }
+  /**
+   * Material properties can be set at load time as we don't depend
+   * on the entire scene graph being loaded (for reflection render lists).
+   * The need for these properties may go over time as the relevant exporters/importers are updated.
+   */
+  async loadMaterialPropertiesAsync(e, t, i) {
+    await this.loader.loadMaterialPropertiesAsync(
+      e,
+      t,
+      i
+    ), this.enableMaterialExtrasIfRequired(t, i), i.needDepthPrePass = !0;
+  }
+  dispose() {
+  }
+  /**
+   * With a given material descriptor and babylon material instance, looks for any
+   * metadata defined on the descriptor and applies to the babylon material.
+   * @param material A material descriptor
+   * @param babylonMaterial An instance of a material representation in babylon.
+   */
+  enableMaterialExtrasIfRequired(e, t) {
+    if (!(!e.extras || !(t instanceof B))) {
+      if (e.extras.sheen) {
+        const i = t;
+        i.sheen.isEnabled = !0, i.sheen.intensity = e.extras.sheen;
+      }
+      if (e.extras.translucency) {
+        const i = t;
+        i.subSurface.isTranslucencyEnabled = !0, i.subSurface.translucencyIntensity = e.extras.translucency, e.extras.translucencyR && e.extras.translucencyG && e.extras.translucencyB && (i.subSurface.tintColor = new Te(
+          e.extras.translucencyR,
+          e.extras.translucencyG,
+          e.extras.translucencyB
+        ));
+      }
+      if (e.extras.refractionIOR) {
+        const i = t;
+        i.subSurface.isRefractionEnabled = !0, i.subSurface.volumeIndexOfRefraction = e.extras.refractionIOR;
+      }
+      if (e.extras.useDepthPrePass) {
+        const i = t;
+        i.needDepthPrePass = !0, i.forceIrradianceInFragment = !0;
+      }
+      if (e.extras.useParallax) {
+        const i = t;
+        i.useParallax = !0, i.useParallaxOcclusion = !0, i.parallaxScaleBias = e.extras.useParallax;
+      }
+    }
+  }
+  /**
+   * Called with a loaded scene. Will finish initialization
+   * of any reflective properties within the scene.
+   * @param scene The scene to parse.
+   */
+  applyReflections(e) {
+    function t(s) {
+      const o = [];
+      return s.transformNodes.forEach((a) => {
+        a.metadata && a.metadata.reflective && o.push(...a.getChildMeshes());
+      }), s.meshes.forEach((a) => {
+        a.metadata && a.metadata.reflective && !o.includes(a) && o.push(a);
+      }), o;
+    }
+    function i(s, o = 1) {
+      const a = s.material;
+      if (!a)
+        return;
+      const l = new Ee(
+        "mirror",
+        A.getMirrorTextureResolution(),
+        e,
+        !0
+      );
+      l.renderList = t(e);
+      const c = s.getVerticesData("normal");
+      if (!c)
+        throw new Error(
+          "Mirror attribute specified on: " + s.name + "But no normals exist to generate a mirror from!"
+        );
+      s.computeWorldMatrix(!0);
+      const h = s.getWorldMatrix(), u = ae.TransformNormal(
+        new ae(c[0], c[1], c[2]),
+        h
+      ).normalize(), m = Oe.FromPositionAndNormal(
+        s.position,
+        u.scale(-1)
+      );
+      l.mirrorPlane = m, l.level = o, a.reflectionTexture = l;
+    }
+    function r(s) {
+      const o = s.material, a = new Le(
+        "probe-" + o.name,
+        Ne,
+        e
+      );
+      a.attachToMesh(s), a.renderList && a.renderList.push(...t(e)), o.reflectionTexture = a.cubeTexture;
+    }
+    e.meshes.forEach((s) => {
+      const o = s.metadata;
+      o && (o.mirrorTexture && i(s, o.mirrorTexture), o.reflectionProbe && r(s));
+    });
+  }
+}
+class _e {
+  constructor(e, t) {
+    this.scene = e, this.intensity = t, this.meshCount = 0;
+  }
+  setIntensity(e) {
+    this.intensity = e, this.glowLayer && (this.glowLayer.intensity = e);
+  }
+  includeMeshes(e) {
+    if (e) {
+      this.glowLayer || (this.glowLayer = new Ie("glow", this.scene), this.glowLayer.intensity = this.intensity);
+      for (const t of e)
+        this.glowLayer.hasMesh(t) || (this.glowLayer.addIncludedOnlyMesh(t), this.meshCount++);
+    }
+  }
+  removeMeshes(e) {
+    if (!(!this.glowLayer || !e)) {
+      for (const t of e)
+        this.glowLayer.hasMesh(t) && (this.glowLayer.removeIncludedOnlyMesh(t), this.meshCount--);
+      this.meshCount === 0 && (this.glowLayer.dispose(), this.glowLayer = void 0);
+    }
+  }
+}
+function He(n, e, t, i, r = "") {
+  t.forEach((s) => {
+    const o = s.getID(), a = s.getName(), l = A.getDynamicTextureResolution();
+    n.filter((h) => h.name === r + a).forEach((h) => {
+      const u = i.get(o), m = !1;
+      if (u)
+        de(h, u), u.update(m);
+      else {
+        const g = Ke(
+          a,
+          e,
+          l.width,
+          l.height
+        );
+        i.set(o, g), s.setStaticContext(
+          g.getContext()
+        ), de(h, g), g.onLoadObservable.addOnce(() => {
+          g.update(m);
+        });
+      }
+    });
+  });
+}
+function Ke(n, e, t, i) {
+  const r = new Be(
+    n,
+    { width: t, height: i },
+    e,
+    A.shouldMipMap(),
+    De.TRILINEAR_SAMPLINGMODE,
+    be.TEXTUREFORMAT_RGBA
+  ), s = r.getContext();
+  return s && (s.fillStyle = "#f5f5f5", s.fillRect(0, 0, t, i), r.update()), r;
+}
+function de(n, e) {
+  if (n instanceof B) {
+    const t = n, i = t.albedoTexture;
+    i ? (e.wrapU = i.wrapU, e.wrapV = i.wrapV) : (e.wrapU = 1, e.wrapV = 1), t.albedoTexture = e;
+  } else {
+    const t = n, i = t.diffuseTexture;
+    i && (e.wrapU = i.wrapU, e.wrapV = i.wrapV), t.diffuseTexture = e;
+  }
+}
+function Ue() {
+  const n = () => Math.floor((1 + Math.random()) * 65536).toString(16).substring(1);
+  return n() + n() + "-" + n() + "-" + n() + "-" + n() + "-" + n() + n() + n();
+}
+const M = 60, ue = 1;
+function me(n) {
+  return n.targetedAnimations.map((t) => t.animation.framePerSecond).reduce((t, i) => t + i, 0) / n.targetedAnimations.length || 0;
+}
+function ve(n, e, t, i, r, s) {
+  const o = r ? n.filter((h) => h.name === r) : n;
+  if (o.length === 0) {
+    console.warn(`No animations found for name: ${r}`);
+    return;
+  }
+  let a = 0;
+  const l = () => {
+    a++, a === o.length && s && s();
+  }, c = (h, u, m, g, f) => {
+    h.stop(), h.start(u, m, g, f), s && (u == !1 || u === void 0 && !h.loopAnimation ? h.onAnimationGroupEndObservable.addOnce(() => {
+      l();
+    }) : h.onAnimationLoopObservable.addOnce(() => {
+      l();
+    }));
+  };
+  if (i !== void 0 && t !== void 0 && i === t) {
+    o.forEach((h) => {
+      const u = me(h), m = i * u;
+      c(h, !1, ue, m, m);
+    });
+    return;
+  }
+  o.forEach((h) => {
+    const u = me(h), m = i !== void 0 ? i * u : void 0, g = t !== void 0 ? t * u : void 0;
+    c(h, e, ue, m, g);
+  });
+}
+function We(n, e, t) {
+  return new Promise((i) => {
+    n.stopAnimation(e), e.animations = [], Math.abs(e.alpha) > 2 * Math.PI && (e.alpha = Ye(e.alpha, 0, 2 * Math.PI));
+    const r = [], s = t.target, o = 0, a = s ? 1 : 0;
+    if (t.target && Object.keys(t.target).length > 0 && r.push(
+      x(
+        "cameraTargetLerp",
+        "target",
+        new p().copyFrom(e.target),
+        new p(
+          t.target.x,
+          t.target.y,
+          t.target.z
+        ),
+        v.ANIMATIONTYPE_VECTOR3,
+        o
+      )
+    ), r.push(
+      x(
+        "cameraAlphaLerp",
+        "alpha",
+        e.alpha,
+        ge(t.lonDeg),
+        v.ANIMATIONTYPE_FLOAT,
+        a
+      )
+    ), r.push(
+      x(
+        "cameraBetaLerp",
+        "beta",
+        e.beta,
+        ge(t.latDeg),
+        v.ANIMATIONTYPE_FLOAT,
+        a
+      )
+    ), t.radius !== void 0) {
+      const h = Math.max(0.01, t.radius);
+      r.push(
+        x(
+          "cameraRadiusLerp",
+          "radius",
+          e.radius,
+          h,
+          v.ANIMATIONTYPE_FLOAT,
+          a
+        )
+      );
+    }
+    e.animations.push(...r);
+    const c = e.useAutoRotationBehavior;
+    e.disableAutoRotationBehavior(), n.beginAnimation(
+      e,
+      0,
+      s ? M * 2 : M,
+      !1,
+      1,
+      () => {
+        e.animations = [], c && e.enableAutoRotationBehavior(), i();
+      }
+    );
+  });
+}
+function ge(n) {
+  return n * Math.PI / 180;
+}
+function x(n, e, t, i, r, s = 0, o = v.ANIMATIONLOOPMODE_CONSTANT) {
+  const a = new ke();
+  a.setEasingMode(ze.EASINGMODE_EASEINOUT);
+  const l = new v(
+    n,
+    e,
+    M,
+    r,
+    o
+  ), c = [];
+  return s > 0 && c.push({ frame: 0, value: t }), c.push({ frame: M * s, value: t }), c.push({
+    frame: M * (s + 1),
+    value: i
+  }), l.setKeys(c), l.setEasingFunction(a), l;
+}
+function Ye(n, e, t) {
+  return n < e ? n = t - (e - n) % (t - e) : n = e + (n - e) % (t - e);
+}
+function Qe(n, e, t) {
+  n.forEach((i) => {
+    t && i.name !== t || i.goToFrame(e);
+  });
+}
+const Ze = {
+  albedoTexture: "albedoMap",
+  bumpTexture: "normalMap",
+  ambientTexture: "ambientMap",
+  emissiveTexture: "emissionMap",
+  opacityTexture: "alphaMap",
+  metallicTexture: "metallicMap",
+  refractionTexture: "refractionMap",
+  reflectionTexture: "reflectionMap"
+};
+function $e(n, e, t, i) {
+  [
+    "albedoTexture",
+    "bumpTexture",
+    "ambientTexture",
+    "emissiveTexture",
+    "opacityTexture",
+    "metallicTexture",
+    "refractionTexture",
+    "reflectionTexture"
+  ].forEach((s) => {
+    je(
+      s,
+      n,
+      e,
+      t,
+      i
+    );
+  }), et(n, e);
+}
+function je(n, e, t, i, r) {
+  const s = Ze[n];
+  if (!s)
+    throw new Error("Unexpected texture name encountered.");
+  const o = e[s], a = o == null ? void 0 : o.fileLink;
+  a ? n === "reflectionTexture" ? a.endsWith(".env") || a.endsWith(".dds") ? i.addCubeTextureTask(
+    n,
+    a,
+    void 0,
+    !1,
+    void 0,
+    !0
+  ) : a.endsWith(".hdr") ? i.addHDRCubeTextureTask(
+    n,
+    a,
+    128,
+    !1,
+    !0,
+    !1
+  ) : i.addTextureTask(n, a, !1, !1) : i.addTextureTask(n, a, !1, !1) : r && t[n] && (t[n] && t[n].dispose(), t[n] = null, Xe(n, t));
+}
+function Xe(n, e) {
+  n === "opacityTexture" && (e.useAlphaFromAlbedoTexture = !0), n === "metallicTexture" && (e.useRoughnessFromMetallicTextureAlpha = !1, e.useRoughnessFromMetallicTextureGreen = !1, e.useMetallnessFromMetallicTextureBlue = !1), n === "refractionTexture" && (e.subSurface.isRefractionEnabled = !1, e.subSurface.refractionIntensity = 1), n === "reflectionTexture" && (e.environmentIntensity = 1), n === "emissiveTexture" && (e.emissiveIntensity = 0, e.emissiveColor = new w(0, 0, 0), e.reflectionTexture);
+}
+function Je(n, e, t, i) {
+  if (!e) {
+    console.error("Failed to apply texture to material: material is null.");
+    return;
+  }
+  n === "opacityTexture" && (e.useAlphaFromAlbedoTexture = !1), n === "metallicTexture" && (e.useRoughnessFromMetallicTextureAlpha = !1, e.useRoughnessFromMetallicTextureGreen = !0, e.useMetallnessFromMetallicTextureBlue = !0), n === "refractionTexture" && (e.subSurface.isRefractionEnabled = !0, e.subSurface.refractionIntensity = t.refractionIntensity || 1), n === "reflectionTexture" && (e.environmentIntensity = t.reflectionIntensity || 1, i.isCube && (i.rotationY = t.reflectionRotation ? t.reflectionRotation * Math.PI / 180 : 0)), e[n] = i, n === "emissiveTexture" && (e.emissiveColor = new w(1, 1, 1), e.emissiveIntensity = 1);
+}
+function et(n, e) {
+  n.clearCoat && (n.clearCoat === F.RemoveWhenSelected ? (e.clearCoat.isEnabled = !1, e.clearCoat.indexOfRefraction = 1.5) : n.clearCoat === F.ApplyWhenSelected && (e.clearCoat.isEnabled = !0, e.clearCoat.indexOfRefraction = n.clearCoatIOR || e.clearCoat.indexOfRefraction));
+}
+class tt {
+  constructor(e, t, i) {
+    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 = i;
+  }
+  /**
+   * 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, i, r) {
+    return new Promise((s) => {
+      const o = this.materialVariantMap.get(e);
+      this.materialVariantMap.set(e, {
+        ...o,
+        ...t
+      });
+      const a = this.renameClonedAsset(e), l = this.scene.materials.filter(
+        (h) => h.name === a
+      );
+      if (l.length === 0) {
+        s();
+        return;
+      }
+      const c = new Ve(this.scene);
+      c.useDefaultLoadingScreen = !1, l.forEach(
+        (h) => $e(
+          t,
+          h,
+          c,
+          r
+        )
+      ), c.onProgress = (h, u, m) => {
+        i && i(h / u * 100, 100, m.name);
+      }, c.onFinish = (h) => {
+        h.forEach((u) => {
+          const m = u;
+          i && i(100, 100, u.name), this.scene.materials.filter(
+            (f) => f.name === a
+          ).forEach(
+            (f) => Je(
+              u.name,
+              f,
+              t,
+              m.texture
+            )
+          );
+        }), s();
+      }, c.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.
+   * @param lastPlayedAnimation The last played animation, this is used to ensure the animation is played on the new model.
+   * @param getCurrentFrame A function that returns the current frame of the animation.
+   * @param getAnimationIsPlaying A function that returns whether the animation is currently playing.
+   */
+  async applyModel(e, t, i, r, s, o, a) {
+    var u;
+    if (i && t && !this.keysThatRemovedBaseModel.includes(e) && this.keysThatRemovedBaseModel.push(e), !i)
+      return this.keysThatRemovedBaseModel.includes(e) && this.keysThatRemovedBaseModel.length === 1 && await this.setBaseModelEnabled(!0), (u = this.loadedContainerForKey.get(e)) == null || u.dispose(), this.loadedContainerForKey.delete(e), this.loadedMaterialsForKey.delete(e), this.keysThatRemovedBaseModel = this.keysThatRemovedBaseModel.filter(
+        (m) => m !== e
+      ), Promise.resolve(void 0);
+    const c = (await D(i, this.scene, r)).instantiateModelsToScene(
+      this.renameClonedAsset,
+      !0
+    );
+    if (this.loadedContainerForKey.has(e) && (this.loadedContainerForKey.get(e).dispose(), this.loadedContainerForKey.delete(e), this.loadedMaterialsForKey.delete(e)), s) {
+      const m = o && o(), g = s.name ? this.renameClonedAsset(s.name) : void 0;
+      if (ve(
+        c.animationGroups,
+        s.loop,
+        s.to,
+        s.from,
+        g
+      ), m != null) {
+        const f = a && a() || !0;
+        Qe(
+          c.animationGroups,
+          m + (f ? 2 : 0),
+          g
+        );
+      }
+    }
+    t && await this.setBaseModelEnabled(!1), this.loadedContainerForKey.set(e, c), this.loadedMaterialsForKey.set(e, we(c));
+    const h = [];
+    return this.materialVariantMap.forEach(async (m, g) => {
+      h.push(this.applyMaterial(g, m));
+    }), await Promise.all(h), c;
+  }
+  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((i) => {
+        e.includes(i) || e.push(i);
+      });
+    }), e;
+  }
+  getAnimationGroups() {
+    const e = [];
+    return this.loadedContainerForKey.forEach((t) => {
+      e.push(...t.animationGroups);
+    }), e;
+  }
+}
+function we(n) {
+  const e = [];
+  return n.rootNodes.forEach((t) => {
+    t.getChildMeshes().forEach((i) => {
+      i.material && !e.includes(i.material) && e.push(i.material), i.subMeshes && i.subMeshes.forEach((r) => {
+        const s = r.getMaterial(!1);
+        s && !e.includes(s) && e.push(s);
+      });
+    });
+  }), e;
+}
+function pe(n, e = "") {
+  return n.map((t) => ({
+    name: t.name.substring(e.length),
+    loop: t.loopAnimation,
+    to: t.to,
+    from: t.from
+  }));
+}
+class it {
+  constructor(e) {
+    this.metadata = /* @__PURE__ */ new Map(), this.materialSelectedObservable = new C(), this.materialDeselectedObservable = new C(), this.materialVariantObservable = new C(), this.modelVariantObservable = new C(), this.materialReadyToLoadCallbacks = /* @__PURE__ */ new Map(), this.modelReadyToLoadCallbacks = /* @__PURE__ */ new Map(), this.dynamicTextures = /* @__PURE__ */ new Map(), this.queuedMaterialChanges = /* @__PURE__ */ new Map(), this.materialChangesInProgress = [], this.queuedModelChanges = /* @__PURE__ */ new Map(), this.modelChangesInProgress = [], this.isExecutingAnimation = !1, this.animations = [], this.initialized = !1, this.materials = [];
+    const {
+      enablePicking: t,
+      modelDetails: i,
+      previewService: r,
+      progressHandler: s,
+      scene: o
+    } = e;
+    this.enablePicking = t, this.contextService = i.contextService, this.id = Ue(), this.previewService = r, this.scene = o, this.variantManager = new tt(
+      o,
+      this.renameClonedAsset.bind(this),
+      this.setBaseModelEnabled.bind(this)
+    ), this.transformRoot = new Se("root", this.scene);
+    const a = async () => {
+      if (!i.model)
+        throw new Error(
+          "Model container constructed with no URL. This is currently unsupported."
+        );
+      return this.assetContainer = await D(
+        i.model,
+        o,
+        s
+      ), await this.instantiate(), this;
+    };
+    this.importPromise = a();
+  }
+  //#region Interface implementation
+  async applyMaterialVariant(e, t, i, r) {
+    if (!this.initialized) {
+      if (this.materialReadyToLoadCallbacks.has(e)) {
+        const o = this.materialReadyToLoadCallbacks.get(e);
+        o == null || o.set(
+          t,
+          this.applyMaterialVariant.bind(
+            this,
+            e,
+            t,
+            i,
+            r
+          )
+        );
+      } else {
+        this.materialReadyToLoadCallbacks.set(
+          e,
+          /* @__PURE__ */ new Map()
+        );
+        const o = this.materialReadyToLoadCallbacks.get(e);
+        o == null || o.set(
+          t,
+          this.applyMaterialVariant.bind(
+            this,
+            e,
+            t,
+            i,
+            r
+          )
+        );
+      }
+      return;
+    }
+    const s = async () => {
+      await this.variantManager.applyMaterial(
+        e,
+        i,
+        (o, a, l) => {
+          this.materialVariantObservable.notifyObservers({
+            remainingCount: o,
+            totalCount: a,
+            taskName: l
+          });
+        },
+        r
+      );
+    };
+    if (this.materialChangesInProgress.includes(e)) {
+      if (this.queuedMaterialChanges.has(e)) {
+        const o = this.queuedMaterialChanges.get(e);
+        o == null || o.set(t, s);
+      } else {
+        this.queuedMaterialChanges.set(
+          e,
+          /* @__PURE__ */ new Map()
+        );
+        const o = this.queuedMaterialChanges.get(e);
+        o == null || o.set(t, s);
+      }
+      return;
+    }
+    if (this.materialChangesInProgress.push(e), await s(), this.queuedMaterialChanges.has(e)) {
+      const o = this.queuedMaterialChanges.get(e);
+      if (!o)
+        throw new Error("Target material is undefined");
+      o.forEach(async (a) => {
+        await a();
+      }), this.queuedMaterialChanges.delete(e);
+    }
+    this.materialChangesInProgress.splice(
+      this.materialChangesInProgress.indexOf(e),
+      1
+    ), this.configureGlowLayer();
+  }
+  async applyModelVariant(e, t, i) {
+    if (!this.initialized) {
+      this.modelReadyToLoadCallbacks.set(
+        e,
+        this.applyModelVariant.bind(
+          this,
+          e,
+          t,
+          i
+        )
+      );
+      return;
+    }
+    const r = () => this.variantManager.applyModel(
+      e,
+      i,
+      t == null ? void 0 : t.model,
+      (a) => {
+        this.modelVariantObservable.notifyObservers({
+          ...a,
+          key: e
+        });
+      },
+      this.lastPlayedAnimation,
+      this.getCurrentAnimationFrame.bind(this),
+      this.getAnimationIsPlaying.bind(this)
+    );
+    if (this.modelChangesInProgress.includes(e)) {
+      this.queuedModelChanges.set(e, r);
+      return;
+    }
+    const o = await (async () => {
+      this.modelChangesInProgress.push(e);
+      let a = await r();
+      if (this.queuedModelChanges.has(e)) {
+        const l = this.queuedModelChanges.get(e);
+        if (!l)
+          throw new Error("Queued change resolved undefined");
+        a = await l(), this.queuedModelChanges.delete(e);
+      }
+      return this.modelChangesInProgress.splice(
+        this.modelChangesInProgress.indexOf(e),
+        1
+      ), a;
+    })();
+    this.contextService || (this.contextService = t == null ? void 0 : t.contextService), o ? this.configureModelInstance(o) : this.configureGlowLayer();
+  }
+  dispose() {
+    var e;
+    this.destroyInstance(), this.variantManager.dispose(), this.dynamicTextures.forEach((t) => t == null ? void 0 : t.dispose()), this.dynamicTextures.clear(), this.materials.forEach((t) => t && (t == null ? void 0 : t.dispose())), this.materials = [], (e = this.transformRoot) == null || e.dispose(), this.transformRoot = void 0, this.previewService.modelUnloaded(this);
+  }
+  executeAnimation(e) {
+    if (!this.initialized)
+      return this.queuedModelAnimation = e, Promise.resolve();
+    let t = () => {
+    };
+    const i = async () => {
+      this.lastPlayedAnimation = e, this.isExecutingAnimation = !0, await new Promise((r) => {
+        var o;
+        const s = [
+          ...((o = this.modelInstance) == null ? void 0 : o.animationGroups) || [],
+          ...this.variantManager.getAnimationGroups()
+        ];
+        ve(
+          s,
+          e.loop,
+          e.to,
+          e.from,
+          e.name ? this.renameClonedAsset(e.name) : void 0,
+          r
+        );
+      }), this.isExecutingAnimation = !1, this.queuedAnimationFunction && this.queuedAnimationFunction(), this.queuedAnimationFunction = void 0, t();
+    };
+    return this.isExecutingAnimation ? (this.queuedAnimationFunction = i, new Promise((r) => {
+      t = r;
+    })) : i();
+  }
+  getAnimations(e) {
+    return [
+      ...this.animations,
+      ...e ? pe(
+        this.variantManager.getAnimationGroups(),
+        this.renameClonedAsset("")
+      ) : []
+    ];
+  }
+  getId() {
+    return this.id;
+  }
+  listMaterials() {
+    var t;
+    const e = (t = this.scene) == null ? void 0 : t.materials.filter(
+      (i) => i.name.startsWith(this.id)
+    );
+    return e ? e.map((i) => ({
+      id: i.id,
+      name: this.stripIdFromName(i.name)
+    })) : [];
+  }
+  registerMaterialSelectedCallback(e) {
+    this.materialSelectedObservable.add(e);
+  }
+  unregisterMaterialSelectedCallback(e) {
+    this.materialSelectedObservable.removeCallback(e);
+  }
+  registerMaterialDeselectedCallback(e) {
+    this.materialDeselectedObservable.add(e);
+  }
+  unregisterMaterialDeselectedCallback(e) {
+    this.materialDeselectedObservable.removeCallback(e);
+  }
+  get position() {
+    if (!this.transformRoot)
+      throw new Error("ModelContainer disposed prior to requesting position!");
+    return this.transformRoot.position;
+  }
+  set position(e) {
+    if (!this.transformRoot)
+      throw new Error("ModelContainer disposed prior to setting position!");
+    this.transformRoot.position = new p(e.x, e.y, e.z);
+  }
+  get rotation() {
+    var e;
+    if (!((e = this.transformRoot) != null && e.rotationQuaternion))
+      throw new Error("ModelContainer disposed prior to requesting rotation!");
+    return this.transformRoot.rotationQuaternion.toEulerAngles();
+  }
+  set rotation(e) {
+    if (!this.transformRoot)
+      throw new Error("ModelContainer disposed prior to setting rotation!");
+    this.transformRoot.rotationQuaternion = y.FromEulerAngles(
+      e.x,
+      e.y,
+      e.z
+    );
+  }
+  get scale() {
+    if (!this.transformRoot)
+      throw new Error("ModelContainer disposed prior to requesting scale!");
+    return this.transformRoot.scaling;
+  }
+  set scale(e) {
+    if (!this.transformRoot)
+      throw new Error("ModelContainer disposed prior to setting scale!");
+    this.transformRoot.scaling = new p(e.x, e.y, e.z);
+  }
+  //#endregion
+  //#region Custom implementation functions
+  attachPickingHandler(e) {
+    e.rootNodes.forEach((t) => {
+      t.getChildMeshes(!1).forEach((i) => {
+        i.name === "targetcube_t" || i.name === "backgroundShell" || (i.actionManager || (i.actionManager = new R(this.scene)), i.actionManager.registerAction(
+          new oe(R.OnPointerOverTrigger, (r) => {
+            r.meshUnderPointer && i.material && this.materialSelectedObservable.notifyObservers({
+              id: i.material.id,
+              name: this.stripIdFromName(i.material.name)
+            });
+          })
+        ), i.actionManager.registerAction(
+          new oe(R.OnPointerOutTrigger, () => {
+            i.material && this.materialDeselectedObservable.notifyObservers({
+              id: i.material.id,
+              name: this.stripIdFromName(i.material.name)
+            });
+          })
+        ));
+      });
+    });
+  }
+  /**
+   * Returns a promise which resolves when the model has been initialized.
+   */
+  getInitializationPromise() {
+    return this.importPromise;
+  }
+  /**
+   * Returns true if the model has been initialized.
+   */
+  getIsInitialized() {
+    return this.initialized;
+  }
+  getQueuedMaterialVariantCount() {
+    return this.materialReadyToLoadCallbacks.size;
+  }
+  getQueuedModelVariantCount() {
+    return this.modelReadyToLoadCallbacks.size;
+  }
+  configureGlowLayer() {
+    const e = (i) => i instanceof B && i.emissiveTexture !== null;
+    this.materials.some(e) || this.variantManager.getAllMaterials().some(e) ? this.previewService.getGlowLayerManager().includeMeshes(this.getAllMeshes()) : this.previewService.getGlowLayerManager().removeMeshes(this.getAllMeshes());
+  }
+  configureModelInstance(e) {
+    var s;
+    if (!this.transformRoot)
+      throw new Error(
+        "Transform disposed! This should never happen unless there is a race condition present!"
+      );
+    const t = this.transformRoot.position, i = this.transformRoot.rotationQuaternion, r = this.transformRoot.scaling;
+    this.transformRoot.position = p.Zero(), this.transformRoot.rotationQuaternion = y.Identity(), this.transformRoot.scaling = p.One();
+    for (const o of e.rootNodes) {
+      o.parent = this.transformRoot;
+      for (const a of o.getChildMeshes(!1))
+        a.alwaysSelectAsActiveMesh = !0;
+    }
+    this.transformRoot.position = t, this.transformRoot.rotationQuaternion = i, this.transformRoot.scaling = r, this.canvasPanels = ((s = this.contextService) == null ? void 0 : s.getAll()) || /* @__PURE__ */ new Map(), He(
+      this.materials.concat(this.variantManager.getAllMaterials()),
+      this.scene,
+      this.canvasPanels,
+      this.dynamicTextures,
+      `${this.id}_`
+    ), this.enablePicking && this.attachPickingHandler(e), this.configureGlowLayer();
+  }
+  /**
+   * Destroys the model instance.
+   */
+  destroyInstance() {
+    var e;
+    (e = this.modelInstance) == null || e.dispose(), this.modelInstance = void 0;
+  }
+  getAllMeshes() {
+    var e;
+    return (e = this.modelInstance) == null ? void 0 : e.rootNodes.map(
+      (t) => t.getChildMeshes(!1).filter((i) => i instanceof Fe)
+    ).flat();
+  }
+  async instantiate() {
+    if (!this.assetContainer)
+      throw new Error(
+        "Attempted to instantiate ModelContainer without an AssetContainer"
+      );
+    this.modelInstance = this.assetContainer.instantiateModelsToScene(
+      this.renameClonedAsset.bind(this),
+      !0
+    ), this.materials = we(this.modelInstance), this.configureModelInstance(this.modelInstance), this.animations = pe(
+      this.modelInstance.animationGroups,
+      this.renameClonedAsset("")
+    ), this.initialized = !0, await this.processQueuedEvents();
+  }
+  renameClonedAsset(e) {
+    return `${this.id}_${e}`;
+  }
+  async setBaseModelEnabled(e) {
+    e && !this.modelInstance ? await this.instantiate() : !e && this.modelInstance && this.destroyInstance();
+  }
+  updateDynamicTextures() {
+    var e;
+    (e = this.canvasPanels) == null || e.forEach(
+      (t, i) => {
+        const r = this.dynamicTextures.get(i);
+        r && t.getStaticContextDirty() && r.isReady() && (r.update(!1), t.setStaticContextDirty(!1));
+      }
+    );
+  }
+  //#region Listeners
+  registerMaterialVariantListener(e) {
+    this.materialVariantObservable.add(e);
+  }
+  unregisterMaterialVariantListener(e) {
+    this.materialVariantObservable.removeCallback(e);
+  }
+  registerModelVariantListener(e) {
+    this.modelVariantObservable.add(e);
+  }
+  unregisterModelVariantListener(e) {
+    this.modelVariantObservable.removeCallback(e);
+  }
+  //#endregion
+  getCurrentAnimationFrame() {
+    var t;
+    const e = [
+      ...((t = this.modelInstance) == null ? void 0 : t.animationGroups) || [],
+      ...this.variantManager.getAnimationGroups()
+    ];
+    for (const i of e)
+      if (i.animatables.length > 0 && i.animatables[0].masterFrame !== void 0 && i.animatables[0].masterFrame !== null)
+        return i.animatables[0].masterFrame;
+    return 0;
+  }
+  getAnimationIsPlaying() {
+    var t;
+    const e = [
+      ...((t = this.modelInstance) == null ? void 0 : t.animationGroups) || [],
+      ...this.variantManager.getAnimationGroups()
+    ];
+    for (const i of e)
+      if (i.isPlaying)
+        return !0;
+    return !1;
+  }
+  stripIdFromName(e) {
+    return e.substring(this.id.length + 1);
+  }
+  async processQueuedEvents() {
+    await Promise.all(
+      Array.from(this.materialReadyToLoadCallbacks.values()).flatMap(
+        (e) => Array.from(e.values()).map((t) => t())
+      )
+    ), this.materialReadyToLoadCallbacks.clear(), await Promise.all(
+      Array.from(this.modelReadyToLoadCallbacks.values()).map(
+        (e) => e()
+      )
+    ), this.modelReadyToLoadCallbacks.clear(), this.scene.onAfterRenderObservable.addOnce(() => {
+      this.queuedModelAnimation && (this.executeAnimation(this.queuedModelAnimation), this.queuedModelAnimation = void 0);
+    });
+  }
+  //#endregion
+}
+class k extends fe {
+  constructor(e, t, i, r, s, o, a, l) {
+    super(
+      e,
+      t,
+      i,
+      r,
+      s,
+      o,
+      l
+    ), this.lastFocus = new p(0, 0, 0), this._isRunningFramingBehavior = !1, this.panDenominator = 1, this.panEnabled = !0, this.minZ = 0.01, this.updateRadiusBounds(this.radius), this.enableFramingBehavior(), this.wheelDeltaPercentage = 0.01, this.pinchDeltaPercentage = 5e-3, this.useNaturalPinchZoom = !0, a.camera.autoOrientation && (this.alpha += Math.PI), a && (a.camera.limits.min.beta && (this.lowerBetaLimit = a.camera.limits.min.beta), a.camera.limits.max.beta && (this.upperBetaLimit = a.camera.limits.max.beta), a.camera.limits.min.alpha && (this.lowerAlphaLimit = a.camera.limits.min.alpha), a.camera.limits.max.alpha && (this.upperAlphaLimit = a.camera.limits.max.alpha), a.camera.limits.min.radius && (this.lowerRadiusLimit = a.camera.limits.min.radius), a.camera.limits.max.radius && (this.upperRadiusLimit = a.camera.limits.max.radius), a.camera.autoRotation.enabled && this.enableAutoRotationBehavior(
+      a.camera.autoRotation.idleTimeMs
+    ));
+  }
+  updateConfiguration(e) {
+    e && (this.lowerBetaLimit = e.camera.limits.min.beta ?? null, this.upperBetaLimit = e.camera.limits.max.beta ?? null, this.lowerAlphaLimit = e.camera.limits.min.alpha ?? null, this.upperAlphaLimit = e.camera.limits.max.alpha ?? null, e.camera.autoRotation.enabled ? this.enableAutoRotationBehavior(
+      e.camera.autoRotation.idleTimeMs
+    ) : this.disableAutoRotationBehavior());
+  }
+  get isRunningFramingBehavior() {
+    return this._isRunningFramingBehavior;
+  }
+  set isRunningFramingBehavior(e) {
+    this._isRunningFramingBehavior = e, !e && this.framingBehaviourCallback && (this.framingBehaviourCallback(), this.framingBehaviourCallback = void 0);
+  }
+  setPanEnabled(e) {
+    this.panEnabled = e, this.panningSensibility = 1e3 / this.panDenominator, this.panningAxis = e ? new p(1, 1, 0) : new p(0, 0, 0);
+  }
+  /**
+   * 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 e = this.getBehaviorByName("AutoRotation");
+    if (e)
+      return e;
+  }
+  /**
+   * 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 e = this.getFramingBehavior();
+    e.attach(this), e.framingTime = 0, e.elevationReturnTime = -1, e.zoomStopsAnimation = !1, this.lowerRadiusLimit = null;
+    const t = T(this._scene);
+    return e.zoomOnBoundingInfo(t.min, t.max), this.wheelPrecision = 100 / this.radius, this.lowerRadiusLimit === null && (this.lowerRadiusLimit = 0.1), this.lastFocus.copyFrom(this.target), e;
+  }
+  /**
+   * 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(e, t) {
+    this._isRunningFramingBehavior = !0, this.framingBehaviourCallback = e;
+    const i = this.getFramingBehavior();
+    i.framingTime = t || 800;
+    const r = () => {
+      this.isRunningFramingBehavior = !1;
+    }, s = T(this._scene), o = s.max.subtract(s.min), a = s.min.add(o.scale(0.5));
+    this.updateRadiusBounds(o.length() * 1.5), this.wheelPrecision = 100 / this.radius, this.panningInertia = 0, this.panningOriginTarget.copyFrom(a), this.panDenominator = o.length(), this.lastFocus.copyFrom(a), i.zoomOnBoundingInfo(
+      s.min,
+      s.max,
+      void 0,
+      r
+    ), i.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(e = 5e3) {
+    this.useAutoRotationBehavior = !0;
+    const t = this.getAutoRotationBehavior();
+    t && (t.idleRotationWaitTime = e);
+  }
+  /**
+   * Stops the auto rotation functionality immediately.
+   */
+  disableAutoRotationBehavior() {
+    this.useAutoRotationBehavior = !1;
+  }
+  updateRadiusBounds(e) {
+    this.maxZ = e * 1e3, this.lowerRadiusLimit = e * 0.01, this.upperRadiusLimit = 1.5 * e, this.wheelPrecision = 100 / e, this.pinchPrecision = 300 / e;
+  }
+  /**
+   * 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.
+   * @param disablePan If true the camera will not allow panning.
+   */
+  static create(e, t, i) {
+    var l;
+    const r = T(e), s = r.max.subtract(r.min), o = r.min.add(s.scale(0.5)), a = new k(
+      "ProductCamera",
+      -(Math.PI / 2),
+      Math.PI / 2,
+      s.length() * 1.5,
+      o,
+      e,
+      t
+    );
+    return a.setPanEnabled(
+      ((l = t.options) == null ? void 0 : l.noPan) !== void 0 ? !t.options.noPan : !0
+    ), a.panningInertia = 0, a.panningOriginTarget.copyFrom(o), a.panDenominator = s.length(), a.onAfterCheckInputsObservable.addOnce(() => {
+      a.setPanEnabled(a.panEnabled);
+    }), i && (e.activeCamera = a), a;
+  }
+}
+function T(n) {
+  if (n.meshes.length === 0)
+    return {
+      min: new p(-1, -1, -1),
+      max: new p(1, 1, 1)
+    };
+  const e = n.meshes.filter((t) => t.name.toLowerCase().endsWith("_t") || t.name.toLowerCase().includes("_t_"));
+  return n.getWorldExtends((t) => t.isVisible && t.isEnabled() && (e.length === 0 || e.includes(t)));
+}
+class nt {
+  constructor(e, t = !1, i = void 0) {
+    this.renderingPipeline = new qe(
+      "default",
+      t,
+      e,
+      i ? [i] : void 0,
+      !1
+      // Disable automatic build
+    ), this.renderingPipeline.isSupported && (this.renderingPipeline.prepare(), this.setConfiguration(d));
+  }
+  dispose() {
+    this.renderingPipeline.dispose();
+  }
+  getConfiguration() {
+    return this.currentConfiguration;
+  }
+  setConfiguration(e) {
+    var t, i, r, s, o, a, l, c, h, u, m, g, f, z, V, q, N, G, _, H, K, U, W, Y, Q, Z, $, j, X, J, ee, te, ie;
+    if (this.renderingPipeline.isSupported) {
+      if (this.renderingPipeline.samples = ((t = e.antiAliasing) == null ? void 0 : t.samples) ?? d.antiAliasing.samples, this.renderingPipeline.fxaaEnabled = ((i = e.antiAliasing) == null ? void 0 : i.fxaaEnabled) ?? d.antiAliasing.fxaaEnabled, this.renderingPipeline.bloomEnabled = ((r = e.bloom) == null ? void 0 : r.enabled) ?? d.bloom.enabled, this.renderingPipeline.bloomKernel = ((s = e.bloom) == null ? void 0 : s.kernel) ?? d.bloom.kernel, this.renderingPipeline.bloomScale = ((o = e.bloom) == null ? void 0 : o.scale) ?? d.bloom.scale, this.renderingPipeline.bloomThreshold = ((a = e.bloom) == null ? void 0 : a.threshold) ?? d.bloom.threshold, this.renderingPipeline.bloomWeight = ((l = e.bloom) == null ? void 0 : l.weight) ?? d.bloom.weight, this.renderingPipeline.chromaticAberrationEnabled = ((c = e.chromaticAberration) == null ? void 0 : c.enabled) ?? d.chromaticAberration.enabled, this.renderingPipeline.chromaticAberration.aberrationAmount = ((h = e.chromaticAberration) == null ? void 0 : h.aberrationAmount) ?? d.chromaticAberration.aberrationAmount, this.renderingPipeline.chromaticAberration.radialIntensity = ((u = e.chromaticAberration) == null ? void 0 : u.radialIntensity) ?? d.chromaticAberration.radialIntensity, this.renderingPipeline.chromaticAberration.direction = (m = e.chromaticAberration) != null && m.direction ? new se(
+        e.chromaticAberration.direction.x,
+        e.chromaticAberration.direction.y
+      ) : new se(
+        d.chromaticAberration.direction.x,
+        d.chromaticAberration.direction.y
+      ), this.renderingPipeline.imageProcessing.colorCurvesEnabled = ((g = e.colorCurves) == null ? void 0 : g.enabled) ?? d.colorCurves.enabled, this.renderingPipeline.imageProcessing.colorCurves = e.colorCurves ? this.updateColorCurve(e.colorCurves) : new le(), this.renderingPipeline.depthOfFieldEnabled = ((f = e.depthOfField) == null ? void 0 : f.enabled) ?? d.depthOfField.enabled, e.depthOfField)
+        switch (e.depthOfField.blurLevel ?? d.depthOfField.blurLevel) {
+          case "Low":
+            this.renderingPipeline.depthOfFieldBlurLevel = E.Low;
+            break;
+          case "Medium":
+            this.renderingPipeline.depthOfFieldBlurLevel = E.Medium;
+            break;
+          case "High":
+            this.renderingPipeline.depthOfFieldBlurLevel = E.High;
+            break;
+        }
+      if (this.renderingPipeline.depthOfField.focalLength = ((z = e.depthOfField) == null ? void 0 : z.focalLength) ?? d.depthOfField.focalLength, this.renderingPipeline.depthOfField.fStop = ((V = e.depthOfField) == null ? void 0 : V.fStop) ?? d.depthOfField.fStop, this.renderingPipeline.depthOfField.focusDistance = ((q = e.depthOfField) == null ? void 0 : q.focusDistance) ?? d.depthOfField.focusDistance, this.renderingPipeline.depthOfField.lensSize = ((N = e.depthOfField) == null ? void 0 : N.lensSize) ?? d.depthOfField.lensSize, this.renderingPipeline.grainEnabled = ((G = e.grain) == null ? void 0 : G.enabled) ?? d.grain.enabled, this.renderingPipeline.grain.animated = ((_ = e.grain) == null ? void 0 : _.animated) ?? d.grain.animated, this.renderingPipeline.grain.intensity = ((H = e.grain) == null ? void 0 : H.intensity) ?? d.grain.intensity, this.renderingPipeline.imageProcessing.contrast = ((K = e.misc) == null ? void 0 : K.contrast) ?? d.misc.contrast, this.renderingPipeline.imageProcessing.exposure = ((U = e.misc) == null ? void 0 : U.exposure) ?? d.misc.exposure, this.renderingPipeline.imageProcessing.toneMappingEnabled = ((W = e.misc) == null ? void 0 : W.toneMappingEnabled) ?? d.misc.toneMappingEnabled, this.renderingPipeline.imageProcessing.toneMappingEnabled)
+        switch (e.misc.toneMappingType ?? d.misc.toneMappingType) {
+          case "Standard":
+            this.renderingPipeline.imageProcessing.toneMappingType = P.TONEMAPPING_STANDARD;
+            break;
+          case "ACES":
+            this.renderingPipeline.imageProcessing.toneMappingType = P.TONEMAPPING_ACES;
+            break;
+        }
+      if (this.renderingPipeline.sharpenEnabled = ((Y = e.sharpen) == null ? void 0 : Y.enabled) ?? d.sharpen.enabled, this.renderingPipeline.sharpen.colorAmount = ((Q = e.sharpen) == null ? void 0 : Q.colorAmount) ?? d.sharpen.colorAmount, this.renderingPipeline.sharpen.edgeAmount = ((Z = e.sharpen) == null ? void 0 : Z.edgeAmount) ?? d.sharpen.edgeAmount, this.renderingPipeline.imageProcessing.vignetteEnabled = (($ = e.vignette) == null ? void 0 : $.enabled) ?? d.vignette.enabled, (j = e.vignette) != null && j.center ? (this.renderingPipeline.imageProcessing.vignetteCenterX = e.vignette.center.x, this.renderingPipeline.imageProcessing.vignetteCenterY = e.vignette.center.y) : (this.renderingPipeline.imageProcessing.vignetteCenterX = d.vignette.center.x, this.renderingPipeline.imageProcessing.vignetteCenterY = d.vignette.center.y), e.vignette)
+        switch (((X = e.vignette) == null ? void 0 : X.blendMode) ?? d.vignette.blendMode) {
+          case "Multiply":
+            this.renderingPipeline.imageProcessing.vignetteBlendMode = P.VIGNETTEMODE_MULTIPLY;
+            break;
+          case "Opaque":
+            this.renderingPipeline.imageProcessing.vignetteBlendMode = P.VIGNETTEMODE_OPAQUE;
+            break;
+        }
+      (J = e.vignette) != null && J.colorRgba ? this.renderingPipeline.imageProcessing.vignetteColor = new b(
+        e.vignette.colorRgba.r,
+        e.vignette.colorRgba.g,
+        e.vignette.colorRgba.b,
+        e.vignette.colorRgba.a
+      ) : (ee = e.vignette) != null && ee.colorHex ? this.renderingPipeline.imageProcessing.vignetteColor = b.FromHexString(e.vignette.colorHex) : this.renderingPipeline.imageProcessing.vignetteColor = new b(
+        d.vignette.colorRgba.r,
+        d.vignette.colorRgba.g,
+        d.vignette.colorRgba.b,
+        d.vignette.colorRgba.a
+      ), this.renderingPipeline.imageProcessing.vignetteStretch = ((te = e.vignette) == null ? void 0 : te.stretch) ?? d.vignette.stretch, this.renderingPipeline.imageProcessing.vignetteWeight = ((ie = e.vignette) == null ? void 0 : ie.weight) ?? d.vignette.weight, this.renderingPipeline.prepare(), this.currentConfiguration = e;
+    }
+  }
+  updateColorCurve(e) {
+    const t = new le();
+    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;
+  }
+}
+xe.GLTFLoader.RegisterExtension("glbPostProcessor", function(n) {
+  return new Ge(n);
+});
+S.OnPluginActivatedObservable.add((n) => {
+  if (n.name === "gltf") {
+    const e = n;
+    e.transparencyAsCoverage = !0;
+  }
+});
+function O(n) {
+  return new p(n.x, n.y, n.z);
+}
+function L(n) {
+  return { x: n.x, y: n.y, z: n.z };
+}
+class Wt {
+  constructor(e) {
+    var l;
+    this.focusLostNotified = !1, this.focusLostObservable = new C(), this.modelLoadEventCallbacks = [], this.modelContainers = /* @__PURE__ */ new Map(), this.plugins = [], this.initComplete = !1, this.isAnimatingCamera = !1, this.renderLoop = () => {
+      if (!this.engine.views)
+        return;
+      this.modelContainers.forEach((h) => {
+        h.updateDynamicTextures();
+      }), this.scene.autoClear = !0, this.scene.autoClearDepthAndStencil = !0, this.scene.render(), this.camera.isRunningFramingBehavior && this.camera.getFramingBehavior().isUserIsMoving && (this.camera.isRunningFramingBehavior = !1);
+      const c = Math.max((this.camera.lowerRadiusLimit ?? 1) * 0.01, 1e-3);
+      !this.camera.isRunningFramingBehavior && !this.camera.target.equalsWithEpsilon(this.camera.lastFocus, c) && !this.focusLostNotified && (this.focusLostObservable.notifyObservers(void 0), this.focusLostNotified = !0), this.screenshotPrepareResolve && (this.screenshotPrepareResolve(), this.screenshotPrepareResolve = void 0);
+    }, this.configuration = new ce(e);
+    const i = (() => {
+      if (!(e != null && e.noRender))
+        return this.configuration.createCanvas();
+    })(), r = "1.5.6";
+    Me.Configuration = {
+      decoder: {
+        wasmUrl: `https://www.gstatic.com/draco/versioned/decoders/${r}/draco_wasm_wrapper_gltf.js`,
+        wasmBinaryUrl: `https://www.gstatic.com/draco/versioned/decoders/${r}/draco_decoder_gltf.wasm`,
+        fallbackUrl: `https://www.gstatic.com/draco/versioned/decoders/${r}/draco_decoder_gltf.js`
+      }
+    }, i && (i.getContext("webgl2") || i.getContext("webgl"));
+    const s = console.log;
+    console.log = () => {
+    };
+    const o = i ? new be(i, !0, {
+      adaptToDeviceRatio: !0,
+      limitDeviceRatio: 2,
+      premultipliedAlpha: !1,
+      preserveDrawingBuffer: !!(e != null && e.backgroundImage),
+      audioEngine: !1,
+      stencil: this.configuration.highlights.enabled,
+      forceSRGBBufferSupportState: !0
+    }) : new Ce();
+    console.log = s, o.hideLoadingUI(), window.addEventListener("resize", this.fireResizeEvent.bind(this)), this.engine = o, this.scene = new Pe(o), this.camera = k.create(this.scene, this.configuration), this.scene.activeCamera = this.camera, this.renderingPipeline = new nt(
+      this.scene,
+      !1,
+      this.camera
+    ), this.scene.clearColor = this.configuration.scene.clearColor;
+    const a = ne.CreateFromPrefilteredData(
+      this.configuration.scene.environment.file,
+      this.scene
+    );
+    a.rotationY = this.configuration.scene.environment.rotationY, this.scene.environmentTexture = a, this.scene.environmentIntensity = this.configuration.scene.environment.intensity, (l = this.configuration.options) != null && l.renderingPipelineConfiguration ? this.renderingPipeline.setConfiguration(
+      this.configuration.options.renderingPipelineConfiguration
+    ) : (this.scene.imageProcessingConfiguration.exposure = this.configuration.lighting.exposure, this.scene.imageProcessingConfiguration.contrast = this.configuration.lighting.contrast), this.glowLayerManager = new _e(
+      this.scene,
+      this.configuration.emissiveGlowIntensity
+    ), this.scene.autoClear = !0, this.scene.autoClearDepthAndStencil = !0, this.initPromise = new Promise((c) => {
+      this.scene.onReadyObservable.addOnce(() => {
+        this.initComplete = !0, c();
+      });
+    }), this.engine.runRenderLoop(this.renderLoop);
+  }
+  getInitializationPromise() {
+    return this.initPromise;
+  }
+  getInitializationComplete() {
+    return this.initComplete;
+  }
+  getEngineContext() {
+    return {
+      engine: this.engine,
+      scene: this.scene,
+      camera: this.camera
+    };
+  }
+  registerFocusLostListener(e) {
+    this.focusLostObservable.add(e);
+  }
+  unregisterFocusLostListener(e) {
+    this.focusLostObservable.removeCallback(e);
+  }
+  registerModelLoadEventListener(e) {
+    this.modelLoadEventCallbacks.push(e);
+  }
+  unregisterModelLoadEventListener(e) {
+    const t = this.modelLoadEventCallbacks.indexOf(e);
+    t > -1 && this.modelLoadEventCallbacks.splice(t, 1);
+  }
+  registerView(e) {
+    const t = e.height, i = e.width;
+    this.engine.registerView(e, void 0, !0), e.setAttribute("height", t.toString()), e.setAttribute("width", i.toString()), this.orbitEnabled() || this.setCameraState(I.Pan), this.reattachControls(e);
+  }
+  getNumViewports() {
+    var e;
+    return ((e = this.engine.views) == null ? void 0 : e.length) || 0;
+  }
+  unregisterView(e) {
+    this.engine.unRegisterView(e);
+  }
+  shutdown() {
+    this.plugins.forEach((e) => e.dispose(!0)), this.renderingPipeline.dispose(), this.engine && this.engine.dispose(), window.removeEventListener("resize", this.fireResizeEvent);
+  }
+  executeCameraAnimation(e) {
+    if (!this.camera || this.scene.activeCamera !== this.camera || this.getAllModels().length === 0 || !this.getAllModels().some((r) => r.getIsInitialized()))
+      return this.queuedCameraAnimation = e, Promise.resolve();
+    let t = () => {
+    };
+    const i = async () => {
+      this.isAnimatingCamera = !0, await We(
+        this.scene,
+        this.scene.activeCamera,
+        e
+      ), this.isAnimatingCamera = !1, this.queuedAnimationFunction && this.queuedAnimationFunction(), this.queuedAnimationFunction = void 0, t();
+    };
+    return this.isAnimatingCamera ? (this.queuedAnimationFunction = i, new Promise((r) => {
+      t = r;
+    })) : i();
+  }
+  getCameraPose() {
+    if (this.scene && this.camera)
+      return {
+        lonDeg: Math.round(this.camera.alpha * 180 / Math.PI),
+        latDeg: Math.round(this.camera.beta * 180 / Math.PI),
+        radius: Math.round((this.camera.radius + Number.EPSILON) * 1e4) / 1e4,
+        target: {
+          x: this.camera.target.x,
+          y: this.camera.target.y,
+          z: this.camera.target.z
+        }
+      };
+  }
+  setCameraPose(e) {
+    this.scene && this.camera && (this.camera.target = new p(
+      e.target.x,
+      e.target.y,
+      e.target.z
+    ), this.camera.radius = e.radius, this.camera.alpha = e.latDeg, this.camera.beta = e.lonDeg);
+  }
+  setCameraState(e) {
+    var t, i;
+    if (!((t = this.engine) != null && t.views) || !((i = this.engine) != null && i.views[0]))
+      throw new Error(
+        "No views attached, camera state requires a view to attach controls onto."
+      );
+    e === I.Orbit ? this.reattachControls(this.engine.views[0].target, 2) : this.reattachControls(this.engine.views[0].target, 0);
+  }
+  animateToLastCameraFocus() {
+    let e = () => {
+    };
+    const t = async () => {
+      this.isAnimatingCamera = !0, await new Promise((i) => {
+        this.focusLostNotified = !1;
+        const r = () => {
+          const s = this.configuration;
+          this.camera.rerunFramingBehavior(() => {
+            s.camera.limits.min.radius && (this.camera.lowerRadiusLimit = s.camera.limits.min.radius), s.camera.limits.max.radius && (this.camera.upperRadiusLimit = s.camera.limits.max.radius), i();
+          });
+        };
+        this.scene.onAfterRenderObservable.addOnce(r);
+      }), this.isAnimatingCamera = !1, this.queuedAnimationFunction && this.queuedAnimationFunction(), this.queuedAnimationFunction = void 0, e();
+    };
+    return this.isAnimatingCamera ? (this.queuedAnimationFunction = t, new Promise((i) => {
+      e = i;
+    })) : t();
+  }
+  setAutoRotation(e) {
+    !this.configuration.camera.autoRotation.enabled || !this.camera || (e ? this.camera.enableAutoRotationBehavior(
+      this.configuration.camera.autoRotation.idleTimeMs
+    ) : this.camera.disableAutoRotationBehavior());
+  }
+  getCurrentConfiguration() {
+    return this.configuration.options;
+  }
+  async renderSceneScreenshot(e, t) {
+    if (!this.camera)
+      throw new Error("Missing product camera, cannot render screenshot!");
+    const i = new fe(
+      "screenshotCamera",
+      0,
+      0,
+      0,
+      p.Zero(),
+      this.scene
+    );
+    try {
+      const r = t.latDeg * Math.PI / 180, s = t.lonDeg * Math.PI / 180;
+      i.target = t.target ? new p(t.target.x, t.target.y, t.target.z) : p.Zero(), i.alpha = s, i.beta = r, i.radius = t.radius || this.camera.radius, i.minZ = 0.01, this.scene.render();
+      const o = await Ae.CreateScreenshotUsingRenderTargetAsync(
+        this.engine,
+        i,
+        e,
+        "image/png",
+        2,
+        !0
+      );
+      return i.dispose(), o;
+    } catch {
+      throw i.isDisposed() || i.dispose(), new Error("Failed to render screenshot");
+    }
+  }
+  orbitEnabled() {
+    const e = this.configuration;
+    if (!e)
+      return !0;
+    const t = e.camera.limits.min.alpha, i = e.camera.limits.max.alpha, r = e.camera.limits.min.beta, s = e.camera.limits.max.beta;
+    if (t === void 0 || i === void 0 || r === void 0 || s === void 0)
+      return !0;
+    const o = [t, i], a = [r, s], l = o.every((h) => h === t), c = a.every((h) => h === r);
+    return !l && !c;
+  }
+  fireResizeEvent() {
+    this.getNumViewports() > 0 && this.engine.resize();
+  }
+  setHighlights(e, t) {
+    var r;
+    e.length === 0 && ((r = this.highlightLayer) == null || r.dispose(), this.highlightLayer = void 0), this.highlightLayer || (this.highlightLayer = new ye("highlights", this.scene, {
+      isStroke: !0,
+      blurVerticalSize: 0.85,
+      blurHorizontalSize: 0.85
+    }), this.highlightLayer.innerGlow = !0, this.highlightLayer.outerGlow = !1), this.highlightLayer.removeAllMeshes();
+    const i = t ? new w(t[0], t[1], t[2]).toLinearSpace() : void 0;
+    e.forEach((s) => {
+      const o = this.scene.materials.find(
+        (a) => a.name === s.name && a.id === s.id
+      );
+      o && o.getBindedMeshes().forEach(
+        (a) => {
+          var l;
+          return (l = this.highlightLayer) == null ? void 0 : l.addMesh(
+            a,
+            i || w.FromHexString("#fcba03")
+          );
+        }
+      );
+    });
+  }
+  setRenderingPipelineConfiguration(e) {
+    this.renderingPipeline && this.renderingPipeline.setConfiguration(e);
+  }
+  loadModel(e, t) {
+    const i = new it({
+      enablePicking: this.configuration.highlights.enabled,
+      modelDetails: e,
+      scene: this.scene,
+      previewService: this,
+      progressHandler: t
+    });
+    return i.getInitializationPromise().then(() => {
+      this.modelContainers.size <= 1 && this.camera.rerunFramingBehavior(() => {
+        this.scene.onAfterRenderObservable.addOnce(() => {
+          this.queuedCameraAnimation && (this.executeCameraAnimation(this.queuedCameraAnimation), this.queuedCameraAnimation = void 0);
+        });
+      }, 1);
+    }), this.configuration.highlights.enabled && (i.registerMaterialSelectedCallback((r) => {
+      this.setHighlights([r]);
+    }), i.registerMaterialDeselectedCallback(() => {
+      this.setHighlights([]);
+    })), this.modelContainers.set(i.getId(), i), this.triggerModelLoadEvent({
+      eventType: "load",
+      modelContainer: i
+    }), i;
+  }
+  async preloadModel(e) {
+    await D(e, this.scene);
+  }
+  getAllModels() {
+    return Array.from(this.modelContainers.values());
+  }
+  getModelById(e) {
+    return this.modelContainers.get(e);
+  }
+  registerPlugin(e) {
+    this.plugins.push(e), e.initialize(this, {
+      camera: this.camera,
+      engine: this.engine,
+      scene: this.scene
+    });
+  }
+  unregisterPlugin(e) {
+    const t = this.plugins.indexOf(e);
+    t > -1 && this.plugins.splice(t, 1).forEach((r) => r.dispose(!1));
+  }
+  getGlowLayerManager() {
+    return this.glowLayerManager;
+  }
+  modelUnloaded(e) {
+    this.modelContainers.delete(e.getId()), this.triggerModelLoadEvent({
+      eventType: "unload",
+      modelContainer: e
+    });
+  }
+  triggerModelLoadEvent(e) {
+    this.modelLoadEventCallbacks.forEach((t) => t(e));
+  }
+  /**
+   * Flips a transform around the origin.
+   */
+  flipTransform(e, t, i) {
+    const r = re.Compose(
+      O(i || { x: 1, y: 1, z: 1 }),
+      y.FromEulerVector(
+        O(t || { x: 0, y: 0, z: 0 })
+      ),
+      O(e || { x: 0, y: 0, z: 0 })
+    ), s = re.RotationAxis(p.Up(), Math.PI), o = r.multiply(s), a = p.Zero(), l = y.Identity(), c = p.Zero();
+    return o.decompose(c, l, a), l.multiplyInPlace(y.FromEulerAngles(0, Math.PI, 0)), {
+      position: L(a),
+      rotation: L(l.toEulerAngles()),
+      scale: L(c)
+    };
+  }
+  updatePreviewOptions(e) {
+    var r, s;
+    const t = new ce(e);
+    this.configuration.highlights.enabled !== t.highlights.enabled && this.engine.setStencilBuffer(t.highlights.enabled), this.scene.clearColor = t.scene.clearColor;
+    let i = this.scene.environmentTexture;
+    this.configuration.scene.environment.file !== t.scene.environment.file && (i = ne.CreateFromPrefilteredData(
+      t.scene.environment.file,
+      this.scene
+    ), i.rotationY = this.configuration.scene.environment.rotationY, this.scene.environmentTexture = i), i.rotationY = t.scene.environment.rotationY, this.scene.environmentIntensity = t.scene.environment.intensity, (r = t.options) != null && r.renderingPipelineConfiguration ? this.renderingPipeline.setConfiguration(
+      t.options.renderingPipelineConfiguration
+    ) : (this.scene.imageProcessingConfiguration.exposure = t.lighting.exposure, this.scene.imageProcessingConfiguration.contrast = t.lighting.contrast), this.glowLayerManager.setIntensity(t.emissiveGlowIntensity), this.camera.updateConfiguration(t), this.camera.setPanEnabled(
+      ((s = t.options) == null ? void 0 : s.noPan) !== void 0 ? !t.options.noPan : !0
+    ), this.scene.autoClear = !0, this.scene.autoClearDepthAndStencil = !0, this.configuration = t;
+  }
+  /**
+   * Given a valid canvas element, will remove any existing input controls
+   * and re-attach them to the given canvas. The pan mouse button can be set
+   * to either 0 (left mouse) or 2 (right mouse).
+   */
+  reattachControls(e, t = 2) {
+    if (this.scene.detachControl(), this.engine.inputElement = e, this.camera) {
+      this.camera.attachControl(!0, !1, t);
+      const i = this.camera.inputs.attached.pointers;
+      i.multiTouchPanning = !1;
+    }
+    this.scene.attachControl(!0, !0, !0);
+  }
+}
+export {
+  F as MaterialEffectMode,
+  I as ProductCameraRig,
+  Ne as REFLECTION_PROBE_RESOLUTION,
+  A as RenderingConfiguration,
+  Wt as SpiffCommerce3DPreviewService,
+  d as renderingPipelineDefaults
+};