u-space 0.0.28 → 0.0.30

package/dist/Viewer-Cs_y7IiH.js

@@ -0,0 +1,1256 @@
+import { Raycaster as U, Vector2 as O, Sphere as x, Mesh as G, InstancedMesh as Q, SkinnedMesh as K, Box3 as D, RenderPipeline as Y, DataTexture as X, RGBAFormat as J, FloatType as k, UnsignedByteType as M, PerspectiveCamera as v, Spherical as d, Matrix4 as Z, Quaternion as ee, Vector4 as te, Vector3 as C, MathUtils as se, PMREMGenerator as ie, OrthographicCamera as b, TimestampQuery as T, Cache as ne, EventDispatcher as re, Timer as ae, WebGPURenderer as oe, PCFShadowMap as he, AgXToneMapping as le, Scene as de, Color as N, Fog as ce, FogExp2 as pe } from "three/webgpu";
+import { MeshBVH as ue } from "three-mesh-bvh";
+import { nodeObject as p, convertToTexture as _, Fn as R, uv as j, ivec2 as me, floor as fe, screenCoordinate as ve, textureLoad as ge, float as Te, pass as I, vec4 as y, diffuseColor as B, materialMetalness as ye, packNormalToRGB as we, normalView as F, materialRoughness as Pe, mrt as Se, output as Ce, sample as z, unpackRGBToNormal as be, vec2 as xe, add as Re, blendColor as Ee, emissive as Me, velocity as Ne } from "three/tsl";
+import { bloom as Oe } from "three/addons/tsl/display/BloomNode.js";
+import { traa as Ie } from "three/addons/tsl/display/TRAANode.js";
+import De from "three/addons/tsl/display/SSGINode.js";
+import _e from "three/addons/tsl/display/RecurrentDenoiseNode.js";
+import je from "three/addons/tsl/display/SSRNode.js";
+import ke from "three/addons/tsl/display/TemporalReprojectNode.js";
+import H from "camera-controls";
+import { RoomEnvironment as Be } from "three/addons/environments/RoomEnvironment.js";
+import { ViewHelper as Fe } from "three/addons/helpers/ViewHelper.js";
+import { CSS2DRenderer as ze, CSS2DObject as Ae } from "three/addons/renderers/CSS2DRenderer.js";
+import { CSS3DRenderer as Le, CSS3DSprite as Ue, CSS3DObject as Ge } from "three/addons/renderers/CSS3DRenderer.js";
+class He {
+  /** The type of event (e.g., 'click', 'pointerdown'). */
+  type;
+  /** The original 3D object that triggered the event. */
+  target;
+  /** The current 3D object during the bubbling phase. */
+  currentTarget;
+  /** The intersection data from raycasting, or null if not applicable. */
+  intersect;
+  /** The original DOM event, or undefined if not applicable. */
+  originalEvent;
+  _propagationStopped = !1;
+  constructor(e) {
+    this.type = e.type, this.target = e.target, this.currentTarget = e.target, this.intersect = e.intersect, this.originalEvent = e.originalEvent;
+  }
+  /**
+   * Stops the event from bubbling up the parent chain.
+   */
+  stopPropagation() {
+    this._propagationStopped = !0;
+  }
+  /**
+   * Returns true if `stopPropagation()` has been called.
+   */
+  get propagationStopped() {
+    return this._propagationStopped;
+  }
+}
+class Ve {
+  domElement;
+  scene;
+  camera;
+  raycaster = new U();
+  pointer = new O();
+  hoveredObject = null;
+  pointerDownTime = 0;
+  pointerDownPos = new O();
+  clickTimer = null;
+  longPressThreshold = 500;
+  moveThreshold = 0.01;
+  /**
+   * The objects to check for intersections. default to all children of the scene (including nested).
+   */
+  targetObjects;
+  /**
+   * Whether to enable pointer move events (pointermove, pointerenter, pointerleave).
+   * Disabled by default for performance optimization.
+   */
+  pointerMoveEventsEnabled = !1;
+  /**
+   * Whether interaction is enabled globally.
+   */
+  _enabled = !0;
+  /**
+   * Objects excluded from raycasting (via addIgnore or setInteractable(false)).
+   */
+  _excludeSet = /* @__PURE__ */ new Set();
+  constructor(e, t, s) {
+    this.domElement = e, this.scene = t, this.camera = s, this.raycaster.params.Points.threshold = 0.1, this.raycaster.params.Line.threshold = 0.1, this.raycaster.firstHitOnly = !0, this.targetObjects = this.scene.children, this._bindEvents();
+  }
+  /**
+   * Updates the camera reference (useful when switching cameras).
+   */
+  setCamera(e) {
+    this.camera = e;
+  }
+  /**
+   * Enable all interactions.
+   */
+  enable() {
+    this._enabled = !0;
+  }
+  /**
+   * Disable all interactions.
+   */
+  disable() {
+    this._enabled = !1;
+  }
+  /**
+   * Set whether a specific object is interactable.
+   * When set to false, the object and its children are excluded from raycasting.
+   */
+  setInteractable(e, t) {
+    t ? this._excludeSet.delete(e) : this._excludeSet.add(e);
+  }
+  /**
+   * Add an object to the exclude list (will not receive any events).
+   * Alias for `setInteractable(object, false)`.
+   */
+  addIgnore(e) {
+    this._excludeSet.add(e);
+  }
+  /**
+   * Remove an object from the exclude list.
+   * Alias for `setInteractable(object, true)`.
+   */
+  removeIgnore(e) {
+    this._excludeSet.delete(e);
+  }
+  _bindEvents() {
+    this.domElement.addEventListener("click", this._onClick), this.domElement.addEventListener("dblclick", this._onDblClick), this.domElement.addEventListener("contextmenu", this._onContextMenu), this.domElement.addEventListener("pointerdown", this._onPointerDown), this.domElement.addEventListener("pointerup", this._onPointerUp), this.domElement.addEventListener("pointermove", this._onPointerMove);
+  }
+  _updatePointer(e) {
+    const t = this.domElement.getBoundingClientRect();
+    this.pointer.x = (e.clientX - t.left) / t.width * 2 - 1, this.pointer.y = -((e.clientY - t.top) / t.height) * 2 + 1;
+  }
+  _getIntersects() {
+    this.raycaster.setFromCamera(this.pointer, this.camera);
+    const e = this.raycaster.intersectObjects(this.targetObjects, !0);
+    return this._excludeSet.size > 0 ? e.filter((t) => {
+      let s = t.object;
+      for (; s; ) {
+        if (this._excludeSet.has(s))
+          return !1;
+        s = s.parent;
+      }
+      return !0;
+    }) : e;
+  }
+  /**
+   * Dispatches an event to the target object and bubbles up the parent chain.
+   */
+  _dispatchToTarget(e, t, s, i) {
+    const r = new He({
+      type: e,
+      target: t,
+      intersect: s,
+      originalEvent: i
+    });
+    let a = t;
+    for (; a && !r.propagationStopped; )
+      r.currentTarget = a, a.dispatchEvent({ type: e, event: r }), a = a.parent;
+  }
+  /**
+   * Handles a DOM event by raycasting and dispatching to the first intersected object.
+   */
+  _handleEvent(e, t) {
+    if (!this._enabled) return;
+    this._updatePointer(t);
+    const s = this._getIntersects();
+    if (s.length === 0) return;
+    const i = s[0];
+    this._dispatchToTarget(e, i.object, i, t);
+  }
+  _onClick = (e) => {
+    const t = Date.now() - this.pointerDownTime, s = this.pointer.distanceTo(this.pointerDownPos);
+    if (!(t > this.longPressThreshold || s > this.moveThreshold)) {
+      if (this.clickTimer) {
+        clearTimeout(this.clickTimer), this.clickTimer = null;
+        return;
+      }
+      this.clickTimer = setTimeout(() => {
+        this._handleEvent("click", e), this.clickTimer = null;
+      }, 200);
+    }
+  };
+  _onDblClick = (e) => {
+    this.clickTimer && (clearTimeout(this.clickTimer), this.clickTimer = null), this._handleEvent("dblclick", e);
+  };
+  _onContextMenu = (e) => {
+    e.preventDefault();
+  };
+  _onPointerDown = (e) => {
+    this.pointerDownTime = Date.now(), this._updatePointer(e), this.pointerDownPos.copy(this.pointer), this._handleEvent("pointerdown", e);
+  };
+  _onPointerUp = (e) => {
+    if (this._updatePointer(e), e.button === 2) {
+      const t = Date.now() - this.pointerDownTime, s = this.pointer.distanceTo(this.pointerDownPos);
+      t <= this.longPressThreshold && s <= this.moveThreshold && this._handleEvent("rightclick", e);
+    }
+    this._handleEvent("pointerup", e);
+  };
+  _onPointerMove = (e) => {
+    if (!this._enabled || !this.pointerMoveEventsEnabled) return;
+    this._updatePointer(e);
+    const t = this._getIntersects(), s = t.length > 0 ? t[0].object : null, i = t.length > 0 ? t[0] : null;
+    this.hoveredObject !== s && (this.hoveredObject && this._dispatchToTarget("pointerleave", this.hoveredObject, null, e), this.hoveredObject = s, s && i && this._dispatchToTarget("pointerenter", s, i, e)), s && i && this._dispatchToTarget("pointermove", s, i, e);
+  };
+  /**
+   * Cleans up event listeners.
+   */
+  dispose() {
+    this.domElement.removeEventListener("click", this._onClick), this.domElement.removeEventListener("dblclick", this._onDblClick), this.domElement.removeEventListener("contextmenu", this._onContextMenu), this.domElement.removeEventListener("pointerdown", this._onPointerDown), this.domElement.removeEventListener("pointerup", this._onPointerUp), this.domElement.removeEventListener("pointermove", this._onPointerMove), this.clickTimer && (clearTimeout(this.clickTimer), this.clickTimer = null), this.hoveredObject = null, this._excludeSet.clear();
+  }
+}
+const We = 1e4, w = /* @__PURE__ */ new WeakMap(), A = new x();
+function qe(n) {
+  const e = n.getAttribute("position");
+  if (!e) return 0;
+  const t = n.index?.count ?? e.count, s = Math.min(t - n.drawRange.start, n.drawRange.count);
+  return Math.max(0, Math.floor(s / 3));
+}
+function $e(n) {
+  if (w.has(n))
+    return w.get(n) ?? null;
+  if (qe(n) < We)
+    return w.set(n, null), null;
+  let e = null;
+  try {
+    e = new ue(n, {
+      indirect: !0,
+      verbose: !1
+    });
+  } catch {
+  }
+  return w.set(n, e), e;
+}
+function Qe(n, e) {
+  const { geometry: t } = n;
+  return t.boundingSphere === null && t.computeBoundingSphere(), t.boundingSphere ? (A.copy(t.boundingSphere).applyMatrix4(n.matrixWorld), e.ray.intersectsSphere(A)) : !0;
+}
+function Ke(n) {
+  return !(n instanceof Q) && !(n instanceof K) && !n.morphTargetInfluences && n.raycast === G.prototype.raycast && !n.userData.raycastAcceleration;
+}
+function jt(n) {
+  return n.traverse((e) => {
+    if (!(e instanceof G) || !Ke(e)) return;
+    const t = e, s = t.raycast.bind(t);
+    let i;
+    t.userData.raycastAcceleration = "lazy", t.raycast = (r, a) => {
+      Qe(t, r) && (i === void 0 && (i = $e(t.geometry), t.userData.raycastAcceleration = i ? "three-mesh-bvh" : "default"), i ? i.raycastObject3D(t, r, a) : s(r, a));
+    };
+  }), n;
+}
+function P(n, e) {
+  const t = n;
+  if (t.setInstanceVisible) {
+    t.setInstanceVisible(e);
+    return;
+  }
+  n.visible = e, t.markInstanceRenderDirty?.();
+}
+class Ye {
+  idMap = /* @__PURE__ */ new Map();
+  nameMap = /* @__PURE__ */ new Map();
+  typeMap = /* @__PURE__ */ new Map();
+  objectIds = /* @__PURE__ */ new Map();
+  allObjects = /* @__PURE__ */ new Set();
+  /**
+   * Add an object with a custom id.
+   * One object can have multiple ids.
+   */
+  add(e, t) {
+    if (this.idMap.has(e)) {
+      console.warn(`ObjectManager: Object with id ${e} already exists.`);
+      return;
+    }
+    this.idMap.set(e, t), this.allObjects.add(t), this.objectIds.has(t) || this.objectIds.set(t, /* @__PURE__ */ new Set()), this.objectIds.get(t).add(e), t.name && (this.nameMap.has(t.name) || this.nameMap.set(t.name, /* @__PURE__ */ new Set()), this.nameMap.get(t.name).add(t)), t.type && (this.typeMap.has(t.type) || this.typeMap.set(t.type, /* @__PURE__ */ new Set()), this.typeMap.get(t.type).add(t));
+  }
+  /**
+   * Get an object by its custom id.
+   */
+  getById(e) {
+    return this.idMap.get(e);
+  }
+  /**
+   * Get all objects with a given name.
+   */
+  getByName(e) {
+    return this.nameMap.get(e) || /* @__PURE__ */ new Set();
+  }
+  /**
+   * Get all objects with a given type.
+   */
+  getByType(e) {
+    return this.typeMap.get(e) || /* @__PURE__ */ new Set();
+  }
+  /**
+   * Get all ids associated with an object.
+   */
+  getObjectIds(e) {
+    return this.objectIds.get(e) || /* @__PURE__ */ new Set();
+  }
+  /**
+   * Remove an object and all its associated ids.
+   */
+  remove(e) {
+    const t = this.objectIds.get(e);
+    if (t) {
+      for (const s of t)
+        this.idMap.delete(s);
+      this.objectIds.delete(e);
+    }
+    if (e.name && this.nameMap.has(e.name)) {
+      const s = this.nameMap.get(e.name);
+      s.delete(e), s.size === 0 && this.nameMap.delete(e.name);
+    }
+    if (e.type && this.typeMap.has(e.type)) {
+      const s = this.typeMap.get(e.type);
+      s.delete(e), s.size === 0 && this.typeMap.delete(e.type);
+    }
+    this.allObjects.delete(e);
+  }
+  /**
+   * Remove an object by its id.
+   */
+  removeById(e) {
+    const t = this.idMap.get(e);
+    t && this.remove(t);
+  }
+  /**
+   * Remove all objects with a given name.
+   */
+  removeByName(e) {
+    const t = this.getByName(e);
+    for (const s of t)
+      this.remove(s);
+  }
+  /**
+   * Remove all objects with a given type.
+   */
+  removeByType(e) {
+    const t = this.getByType(e);
+    for (const s of t)
+      this.remove(s);
+  }
+  /**
+   * Clear all cached objects.
+   */
+  clear() {
+    this.idMap.clear(), this.nameMap.clear(), this.typeMap.clear(), this.objectIds.clear(), this.allObjects.clear();
+  }
+  /**
+   * Get all cached objects as a Set.
+   */
+  getAll() {
+    return this.allObjects;
+  }
+  /**
+   * Get the number of unique cached objects.
+   */
+  get size() {
+    return this.allObjects.size;
+  }
+  /**
+   * Show an object by id.
+   */
+  show(e) {
+    const t = this.idMap.get(e);
+    t && P(t, !0);
+  }
+  /**
+   * Hide an object by id.
+   */
+  hide(e) {
+    const t = this.idMap.get(e);
+    t && P(t, !1);
+  }
+  /**
+   * Show only the specified objects, hide all others.
+   */
+  isolate(e) {
+    const t = new Set(e);
+    for (const s of this.allObjects) {
+      const i = this.objectIds.get(s) ?? /* @__PURE__ */ new Set();
+      P(s, [...i].some((r) => t.has(r)));
+    }
+  }
+  /**
+   * Set the opacity of an object's materials.
+   */
+  setOpacity(e, t) {
+    const s = this.idMap.get(e);
+    if (!s) return;
+    const i = s;
+    if (i.setInstanceOpacity) {
+      i.setInstanceOpacity(t);
+      return;
+    }
+    s.traverse((r) => {
+      if (!r.isMesh) return;
+      const a = r.material;
+      if (!a) return;
+      const o = Array.isArray(a) ? a : [a];
+      for (const c of o)
+        c.transparent = t < 1, c.opacity = t, c.needsUpdate = !0;
+    });
+  }
+  /**
+   * Get the bounding box of an object by id, or all objects if no id provided.
+   */
+  getBoundingBox(e) {
+    const t = new D();
+    if (e) {
+      const s = this.idMap.get(e);
+      s && t.setFromObject(s);
+    } else
+      for (const s of this.allObjects)
+        t.expandByObject(s);
+    return t;
+  }
+  /**
+   * Iterate over all managed objects.
+   */
+  forEach(e) {
+    for (const t of this.allObjects) {
+      const s = this.objectIds.get(t) || /* @__PURE__ */ new Set();
+      e(t, s);
+    }
+  }
+  /**
+   * Filter objects by a predicate.
+   */
+  filter(e) {
+    const t = [];
+    for (const s of this.allObjects)
+      e(s) && t.push(s);
+    return t;
+  }
+  /**
+   * Show all managed objects.
+   */
+  showAll() {
+    for (const e of this.allObjects)
+      P(e, !0);
+  }
+}
+function Xe(n) {
+  if (typeof n != "object" || n === null || !("_material" in n))
+    throw new Error(
+      "ReversedDepthSSGINode: Three.js no longer exposes _material."
+    );
+  const e = n._material;
+  if (typeof e != "object" || e === null || !("colorNode" in e) || !("needsUpdate" in e))
+    throw new Error(
+      "ReversedDepthSSGINode: Three.js _material is incompatible."
+    );
+  return e;
+}
+class Je extends De {
+  setup(e) {
+    const t = super.setup(e);
+    if (!e.renderer.reversedDepthBuffer) return t;
+    const s = Xe(this), i = s.colorNode;
+    if (i === null)
+      throw new Error(
+        "ReversedDepthSSGINode: Three.js did not build its color node."
+      );
+    return s.colorNode = R(() => (this.depthNode.sample(j()).r.lessThanEqual(0).discard(), i))().context(e.getSharedContext()), s.needsUpdate = !0, t;
+  }
+}
+const Ze = (n, e, t, s) => p(
+  new Je(
+    _(n),
+    p(e),
+    p(t),
+    s
+  )
+);
+function V(n, e, t) {
+  if (typeof n != "object" || n === null || !(e in n))
+    throw new Error(`${t}: Three.js no longer exposes ${e}.`);
+  const s = n[e];
+  if (typeof s != "object" || s === null || !("fragmentNode" in s) || !("needsUpdate" in s))
+    throw new Error(`${t}: Three.js ${e} is incompatible.`);
+  return s;
+}
+function W(n, e) {
+  if (n.fragmentNode === null)
+    throw new Error(`${e}: Three.js did not build its fragment node.`);
+  return n.fragmentNode;
+}
+function et(n) {
+  return "getTextureNode" in n && typeof n.getTextureNode == "function";
+}
+class tt extends je {
+  setup(e) {
+    const t = super.setup(e);
+    if (!e.renderer.reversedDepthBuffer) return t;
+    const s = this;
+    if (typeof s._ssrFn != "function" || typeof s._buildSSRMaterial != "function")
+      throw new Error(
+        "ReversedDepthSSRNode: Three.js SSR internals are incompatible."
+      );
+    const i = s._ssrFn;
+    return s._ssrFn = R(() => (this.depthNode.sample(j()).r.lessThanEqual(0).discard(), i())), s._buildSSRMaterial(), t;
+  }
+}
+class st extends ke {
+  setup(e) {
+    const t = super.setup(e);
+    if (!e.renderer.reversedDepthBuffer) return t;
+    const s = V(
+      this,
+      "_resolveMaterial",
+      "ReversedDepthTemporalReprojectNode"
+    ), i = W(
+      s,
+      "ReversedDepthTemporalReprojectNode"
+    );
+    return s.fragmentNode = R(() => {
+      const r = me(fe(ve.xy.sub(0.5)));
+      return ge(this.depthNode, r).r.lessThanEqual(0).discard(), i;
+    })().context(e.getSharedContext()), s.needsUpdate = !0, t;
+  }
+}
+class it extends _e {
+  setup(e) {
+    const t = super.setup(e);
+    if (!e.renderer.reversedDepthBuffer) return t;
+    const s = V(
+      this,
+      "_material",
+      "ReversedDepthRecurrentDenoiseNode"
+    ), i = W(
+      s,
+      "ReversedDepthRecurrentDenoiseNode"
+    );
+    return s.fragmentNode = R(() => ((this.depthNode ? this.depthNode.sample(j()).x : Te(0.5)).lessThanEqual(0).discard(), i))().context(e.getSharedContext()), s.needsUpdate = !0, t;
+  }
+}
+const nt = (n, e, t, s = {}) => p(
+  new tt(
+    p(n),
+    p(e),
+    p(t),
+    s
+  )
+), rt = (n, e, t, s, i, r = {}) => p(
+  new st(
+    _(n),
+    p(e),
+    p(t),
+    p(s),
+    i,
+    r
+  )
+), at = (n, e, t = {}) => {
+  const s = et(n) ? n.getTextureNode() : _(n);
+  return p(
+    new it(s, e, t)
+  );
+};
+class ot extends Y {
+  scene;
+  camera;
+  scenePass;
+  needsUpdateOutputNode;
+  #r;
+  #s;
+  #a = !1;
+  #l = { strength: 1, radius: 0, threshold: 0 };
+  #o = null;
+  #h = !1;
+  #d = {
+    sliceCount: 1,
+    stepCount: 12,
+    aoIntensity: 1,
+    giIntensity: 10,
+    radius: 12,
+    thickness: 1
+  };
+  #g = null;
+  #i = !1;
+  #c = {
+    resolutionScale: 1,
+    quality: 0.25,
+    mirrorBias: 0.5,
+    maxDistance: 0.4,
+    intensity: 1,
+    thickness: 0.1,
+    maxLuminance: 35,
+    stepExponent: 3,
+    binaryRefine: !1,
+    screenEdgeFade: 0.2,
+    screenEdgeFadeBlack: !0,
+    temporal: {
+      maxFrames: 16,
+      clampIntensity: 0.25,
+      flickerSuppression: 1,
+      hitPointReprojection: !0
+    },
+    denoise: {
+      lumaPhi: 0.75,
+      depthPhi: 20,
+      normalPhi: 0.3,
+      roughnessPhi: 100,
+      radius: 1.5,
+      alphaPhi: 5,
+      strength: 0.725,
+      adapt: 0.5,
+      smoothDisocclusions: !0,
+      flickerSuppression: 1,
+      adaptiveTrust: 1
+    }
+  };
+  #e = null;
+  #p = null;
+  #t = null;
+  #T = new X(
+    new Float32Array([0, 0, 0, 1]),
+    1,
+    1,
+    J,
+    k
+  );
+  #m = !1;
+  #f = null;
+  #y = null;
+  #v;
+  #u;
+  #w = !1;
+  #P = !0;
+  constructor(...e) {
+    const [t, s, i] = e;
+    super(t), this.scene = s, this.camera = i, this.scenePass = I(s, i), this.needsUpdateOutputNode = !0, this.#r = /* @__PURE__ */ new Set(), this.#s = [], this.#v = /* @__PURE__ */ new Set(), this.#u = /* @__PURE__ */ new Map(), this.#T.needsUpdate = !0, this.#C();
+  }
+  /** @deprecated Use `scenePass` instead */
+  get currentOutputNode() {
+    return this.scenePass;
+  }
+  addOverlayPass(e) {
+    this.#r.add(e), this.needsUpdateOutputNode = !0;
+  }
+  removeOverlayPass(e) {
+    this.#r.delete(e), this.needsUpdateOutputNode = !0;
+  }
+  setCamera(e) {
+    this.camera = e, this.#n();
+  }
+  /** @deprecated Use `setOutputComposer` instead */
+  setCurrentOutputNode(e) {
+    this.setOutputComposer(() => e);
+  }
+  /** @deprecated Use `setOutputComposer(null)` instead */
+  resetCurrentOutputNode() {
+    this.setOutputComposer(null);
+  }
+  setOutputComposer(e) {
+    this.#y = e, this.needsUpdateOutputNode = !0;
+  }
+  addOutputEffect(e) {
+    return this.#v.add(e), this.needsUpdateOutputNode = !0, this;
+  }
+  removeOutputEffect(e) {
+    return this.#v.delete(e), this.needsUpdateOutputNode = !0, this;
+  }
+  addMRTChannel(e, t) {
+    return this.#u.get(e) === t ? this : (this.#u.set(e, t), this.#n(), this);
+  }
+  removeMRTChannel(e) {
+    return this.#u.delete(e) && this.#n(), this;
+  }
+  enableBloom(e) {
+    e && Object.assign(this.#l, e), this.#a = !0, this.#n();
+  }
+  disableBloom() {
+    this.#a = !1, this.#o = null, this.#n();
+  }
+  updateBloom(e) {
+    Object.assign(this.#l, e), this.#a && (this.needsUpdateOutputNode = !0);
+  }
+  enableSSGI(e) {
+    e && Object.assign(this.#d, e), this.#h = !0, this.#n();
+  }
+  disableSSGI() {
+    this.#h = !1, this.#g = null, this.#n();
+  }
+  updateSSGI(e) {
+    if (Object.assign(this.#d, e), this.#g) {
+      const t = this.#g;
+      e.sliceCount !== void 0 && (t.sliceCount.value = e.sliceCount), e.stepCount !== void 0 && (t.stepCount.value = e.stepCount), e.aoIntensity !== void 0 && (t.aoIntensity.value = e.aoIntensity), e.giIntensity !== void 0 && (t.giIntensity.value = e.giIntensity), e.radius !== void 0 && (t.radius.value = e.radius), e.thickness !== void 0 && (t.thickness.value = e.thickness);
+    }
+  }
+  enableSSR(e) {
+    e && this.#S(e), this.#i = !0, this.#n();
+  }
+  disableSSR() {
+    this.#i = !1, this.#e = null, this.#p = null, this.#t = null, this.#n();
+  }
+  updateSSR(e) {
+    if (this.#S(e), this.#e) {
+      const t = this.#c;
+      this.#e.resolutionScale = t.resolutionScale, this.#e.quality.value = t.quality, this.#e.mirrorBias.value = t.mirrorBias, this.#e.maxDistance.value = t.maxDistance, this.#e.intensity.value = t.intensity, this.#e.thickness.value = t.thickness, this.#e.maxLuminance.value = t.maxLuminance, this.#e.stepExponent = t.stepExponent, this.#e.binaryRefine = t.binaryRefine, this.#e.screenEdgeFade.value = t.screenEdgeFade, this.#e.screenEdgeFadeBlack = t.screenEdgeFadeBlack;
+    }
+    if (this.#p) {
+      const t = this.#c.temporal;
+      this.#p.maxFrames.value = t.maxFrames, this.#p.clampIntensity.value = t.clampIntensity, this.#p.flickerSuppression.value = t.flickerSuppression, this.#p.hitPointReprojection.value = t.hitPointReprojection;
+    }
+    if (this.#t) {
+      const t = this.#c.denoise;
+      this.#t.lumaPhi.value = t.lumaPhi, this.#t.depthPhi.value = t.depthPhi, this.#t.normalPhi.value = t.normalPhi, this.#t.roughnessPhi.value = t.roughnessPhi, this.#t.radius.value = t.radius, this.#t.alphaPhi.value = t.alphaPhi, this.#t.strength.value = t.strength, this.#t.adapt.value = t.adapt, this.#t.smoothDisocclusions.value = t.smoothDisocclusions, this.#t.flickerSuppression.value = t.flickerSuppression, this.#t.adaptiveTrust.value = t.adaptiveTrust;
+    }
+  }
+  enableTRAA() {
+    this.#m = !0, this.#n();
+  }
+  disableTRAA() {
+    this.#m = !1, this.#f = null, this.#n();
+  }
+  #S(e) {
+    const { temporal: t, denoise: s, ...i } = e;
+    Object.assign(this.#c, i), t && Object.assign(this.#c.temporal, t), s && Object.assign(this.#c.denoise, s);
+  }
+  #n() {
+    const e = this.scenePass;
+    this.scenePass = I(this.scene, this.camera), this.#C(), this.needsUpdateOutputNode = !0, e.dispose();
+  }
+  #C() {
+    if (this.#a || this.#h || this.#i || this.#m || this.#u.size > 0) {
+      const t = { output: Ce };
+      this.#u.forEach((s, i) => {
+        i !== "output" && (t[i] = s);
+      }), this.#a && (t.emissive = Me), this.#h && (t.normal = F, this.#i || (t.ssgiDiffuse = B)), this.#i && (t.ssrDiffuse = y(B.rgb, ye), t.ssrNormal = y(we(F).rgb, Pe)), (this.#m || this.#i) && (t.velocity = Ne), this.scenePass.setMRT(Se(t)), this.#h && !this.#i && (this.scenePass.getTexture("ssgiDiffuse").type = M), this.#i && (this.scenePass.getTexture("ssrDiffuse").type = M, this.scenePass.getTexture("ssrNormal").type = M);
+    }
+  }
+  #b() {
+    for (const e of this.#s)
+      e.dispose();
+    this.#s = [];
+  }
+  #x() {
+    let e = this.scenePass.getTextureNode();
+    if (this.#h)
+      if (!(this.camera instanceof v))
+        console.warn("RenderPipeline: SSGI requires a PerspectiveCamera, skipping.");
+      else {
+        const t = this.scenePass.getTextureNode(), s = this.scenePass.getTextureNode("depth"), i = this.scenePass.getTextureNode("normal"), r = this.scenePass.getTextureNode(
+          this.#i ? "ssrDiffuse" : "ssgiDiffuse"
+        ), a = Ze(
+          t,
+          s,
+          i,
+          this.camera
+        );
+        a.sliceCount.value = this.#d.sliceCount, a.stepCount.value = this.#d.stepCount, a.aoIntensity.value = this.#d.aoIntensity, a.giIntensity.value = this.#d.giIntensity, a.radius.value = this.#d.radius, a.thickness.value = this.#d.thickness, this.#g = a;
+        const o = a.getAONode(), c = a.getGINode();
+        e = y(
+          e.rgb.mul(o.r).add(r.rgb.mul(c.rgb)),
+          e.a
+        ), this.#s.push(a);
+      }
+    if (this.#i)
+      if (!(this.camera instanceof v))
+        console.warn("RenderPipeline: SSR requires a PerspectiveCamera, skipping.");
+      else {
+        const t = this.#c, s = this.scenePass.getTextureNode(), i = this.scenePass.getTextureNode("depth"), r = this.scenePass.getTextureNode("velocity"), a = this.scenePass.getTextureNode("ssrNormal"), o = this.scenePass.getTextureNode("ssrDiffuse"), c = z((g) => be(a.sample(g).rgb)), E = z(
+          (g) => xe(o.sample(g).a, a.sample(g).a)
+        ), h = nt(
+          s,
+          i,
+          c,
+          {
+            stochastic: !0,
+            diffuseNode: o,
+            metalnessNode: o.a,
+            roughnessNode: a.a,
+            environmentNode: this.#T,
+            binaryRefine: t.binaryRefine,
+            camera: this.camera
+          }
+        );
+        h.resolutionScale = t.resolutionScale, h.quality.value = t.quality, h.mirrorBias.value = t.mirrorBias, h.maxDistance.value = t.maxDistance, h.intensity.value = t.intensity, h.thickness.value = t.thickness, h.maxLuminance.value = t.maxLuminance, h.stepExponent = t.stepExponent, h.screenEdgeFade.value = t.screenEdgeFade, h.screenEdgeFadeBlack = t.screenEdgeFadeBlack;
+        const m = t.temporal;
+        this.renderer.reversedDepthBuffer && (i.value.type = k);
+        const f = rt(
+          h,
+          i,
+          a,
+          r,
+          this.camera,
+          {
+            mode: "specular",
+            accumulate: !1,
+            hitPointReprojection: m.hitPointReprojection
+          }
+        ), $ = f;
+        $._historyRenderTarget.depthTexture.type = i.value.type, f.maxFrames.value = m.maxFrames, f.clampIntensity.value = m.clampIntensity, f.flickerSuppression.value = m.flickerSuppression;
+        const u = t.denoise, l = at(
+          f,
+          this.camera,
+          {
+            depth: i,
+            normal: a,
+            raw: h,
+            metalRoughness: E,
+            mode: "specular",
+            accumulate: !0
+          }
+        );
+        l.alphaSource = "raylength", l.lumaPhi.value = u.lumaPhi, l.depthPhi.value = u.depthPhi, l.normalPhi.value = u.normalPhi, l.roughnessPhi.value = u.roughnessPhi, l.radius.value = u.radius, l.alphaPhi.value = u.alphaPhi, l.strength.value = u.strength, l.adapt.value = u.adapt, l.smoothDisocclusions.value = u.smoothDisocclusions, l.flickerSuppression.value = u.flickerSuppression, l.adaptiveTrust.value = u.adaptiveTrust, h.setHistory(l, r), f.setHistoryTexture(l), this.#e = h, this.#p = f, this.#t = l, this.#s.push(h, f, l), e = y(e.rgb.add(l.rgb), 1);
+      }
+    if (this.#a) {
+      const t = this.scenePass.getTextureNode("emissive");
+      this.#o = Oe(
+        t,
+        this.#l.strength,
+        this.#l.radius,
+        this.#l.threshold
+      ), e = Re(e, this.#o), this.#s.push(this.#o);
+    }
+    return e;
+  }
+  #R(e) {
+    e ? (this.#w || (this.#P = this.outputColorTransform), this.outputColorTransform = !1) : this.#w && (this.outputColorTransform = this.#P), this.#w = e;
+  }
+  #E() {
+    this.#b();
+    let e, t = !1, s = !1;
+    const i = this.#y !== null;
+    if (i ? e = this.#y(this.scenePass) : this.#a || this.#h || this.#i ? e = this.#x() : e = this.#v.size > 0 ? this.scenePass.getTextureNode() : this.scenePass, i || this.#v.forEach((r) => {
+      t ||= r.includesTemporalAntialias === !0, s ||= r.includesOutputTransform === !0, e = r(this.scenePass, e);
+    }), this.#R(s), this.#m && !t) {
+      const r = this.scenePass.getTextureNode("depth"), a = this.scenePass.getTextureNode("velocity");
+      this.#f = Ie(e, r, a, this.camera), this.#s.push(this.#f), e = this.#f;
+    } else
+      this.#f = null;
+    this.#r.size > 0 && this.#r.forEach((r) => {
+      const a = Ee(e, r);
+      this.#s.push(a), e = a;
+    }), this.outputNode = e, this.needsUpdate = !0;
+  }
+  render() {
+    this.needsUpdateOutputNode && (this.#E(), this.needsUpdateOutputNode = !1), super.render();
+  }
+  dispose() {
+    this.#b(), this.#T.dispose(), this.scenePass.dispose(), super.dispose();
+  }
+}
+const ht = {
+  Vector2: O,
+  Vector3: C,
+  Vector4: te,
+  Quaternion: ee,
+  Matrix4: Z,
+  Spherical: d,
+  Box3: D,
+  Sphere: x,
+  Raycaster: U
+};
+H.install({ THREE: ht });
+class lt extends H {
+  constructor(...e) {
+    super(...e), this.minDistance = 0.2, this.smoothTime = 0.2, this.dollySpeed = 0.2;
+  }
+  /**
+   * Set absolute angle for azimuth to avoid spinning
+   */
+  absoluteRotations() {
+    this.azimuthAngle = ct(this.azimuthAngle, 0);
+  }
+  async flyToBox(e, t = {}) {
+    if (e.isEmpty())
+      return console.warn("CameraControls.flyToBox: The provided Box3 is empty."), !1;
+    this.absoluteRotations();
+    const { viewpoint: s = "frontTop", enableTransition: i = !0, padding: r = 0.1, cover: a = !1 } = t;
+    if (s !== "current") {
+      const o = s.toUpperCase(), c = L[o] ?? L.FRONTTOP, E = c.theta, h = c.phi;
+      if (await this.rotateTo(E, h, i), dt.has(o))
+        await this.fitToBox(e, i, {
+          paddingLeft: r,
+          paddingRight: r,
+          paddingTop: r,
+          paddingBottom: r,
+          cover: a
+        });
+      else {
+        const m = new x();
+        e.getBoundingSphere(m), m.radius += r, await this.fitToSphere(m, i);
+      }
+    } else {
+      const o = new x();
+      e.getBoundingSphere(o), o.radius += r, await this.fitToSphere(o, i);
+    }
+    return !0;
+  }
+  async flyToObject(e, t = {}) {
+    const s = new D().setFromObject(e);
+    return this.flyToBox(s, t);
+  }
+  /**
+   * Fly camera to a specific position and look-at target.
+   */
+  async flyTo(e, t, s = {}) {
+    const { enableTransition: i = !0 } = s;
+    return this.absoluteRotations(), this.setLookAt(e.x, e.y, e.z, t.x, t.y, t.z, i);
+  }
+  /**
+   * Get the current camera viewpoint data (position, target, zoom).
+   */
+  getCameraViewpoint() {
+    const e = new C(), t = new C();
+    return this.getPosition(e), this.getTarget(t), {
+      position: { x: e.x, y: e.y, z: e.z },
+      target: { x: t.x, y: t.y, z: t.z },
+      zoom: this.camera.zoom
+    };
+  }
+  /**
+   * Lock camera controls (disable all user interaction).
+   */
+  lock() {
+    this.enabled = !1;
+  }
+  /**
+   * Unlock camera controls (re-enable user interaction).
+   */
+  unlock() {
+    this.enabled = !0;
+  }
+  /**
+   * Switch between 2D top-down and 3D perspective views.
+   */
+  async setViewMode(e, t = !0) {
+    if (e === "2d") {
+      const s = new C();
+      this.getTarget(s), await this.rotateTo(0, 0, t), this.minPolarAngle = 0, this.maxPolarAngle = 0;
+    } else
+      this.minPolarAngle = 0, this.maxPolarAngle = Math.PI, await this.rotateTo(0, Math.PI / 4, t);
+  }
+  async setCameraViewpoint(e, t = !0) {
+    const { position: s, target: i, zoom: r = this.camera.zoom } = e;
+    return Promise.all([
+      this.zoomTo(r, t),
+      this.setLookAt(s.x, s.y, s.z, i.x, i.y, i.z, t)
+    ]);
+  }
+}
+const L = {
+  LEFT: new d(0, Math.PI / 2, -Math.PI / 2),
+  RIGHT: new d(0, Math.PI / 2, Math.PI / 2),
+  FRONT: new d(0, Math.PI / 2, 0),
+  BACK: new d(0, Math.PI / 2, Math.PI),
+  TOP: new d(0, 0, 0),
+  BOTTOM: new d(0, Math.PI, 0),
+  FRONTTOP: new d(0, Math.PI / 4, 0),
+  BACKTOP: new d(0, Math.PI / 4, Math.PI),
+  LEFTTOP: new d(0, Math.PI / 4, -Math.PI / 2),
+  RIGHTTOP: new d(0, Math.PI / 4, Math.PI / 2),
+  LEFTFRONTTOP: new d(0, Math.PI / 4, -Math.PI / 4),
+  RIGHTFRONTTOP: new d(0, Math.PI / 4, Math.PI / 4),
+  LEFTBACKTOP: new d(0, Math.PI / 4, -Math.PI / 4 * 3),
+  RIGHTBACKTOP: new d(0, Math.PI / 4, Math.PI / 4 * 3)
+}, dt = /* @__PURE__ */ new Set(["LEFT", "RIGHT", "FRONT", "BACK", "TOP", "BOTTOM"]);
+function ct(n, e) {
+  const t = n - e;
+  return se.euclideanModulo(t + Math.PI, Math.PI * 2) - Math.PI;
+}
+class pt {
+  environment = new Be();
+  renderer;
+  pmremGenerator;
+  envMap = null;
+  constructor(e) {
+    this.renderer = e, this.pmremGenerator = new ie(e);
+  }
+  update() {
+    this.envMap || (this.envMap = this.pmremGenerator.fromScene(this.environment).texture);
+  }
+  dispose() {
+    this.pmremGenerator.dispose(), this.envMap?.dispose();
+  }
+}
+const S = 128;
+class ut extends Fe {
+  viewer;
+  overlayPass;
+  constructor(e) {
+    super(e.camera, e.el), this.viewer = e;
+    const t = new b(-2, 2, 2, -2, 0, 4);
+    t.position.set(0, 0, 2), this.overlayPass = I(this, t), this.setLabels("x", "y", "z");
+  }
+  _update = () => {
+    this.quaternion.copy(this.viewer.camera.quaternion).invert();
+    const e = this.location;
+    let t, s;
+    e.left !== null ? t = e.left : t = this.viewer.el.offsetWidth - S - e.right, e.top !== null ? s = e.top : s = this.viewer.el.offsetHeight - S - e.bottom, this.overlayPass.setViewport(t, s, S, S);
+  };
+  enable() {
+    return this.viewer.renderPipeline.addOverlayPass(this.overlayPass), this.viewer.addEventListener("beforeRender", this._update), this.viewer.invalidate(), this;
+  }
+  disable() {
+    return this.viewer.renderPipeline.removeOverlayPass(this.overlayPass), this.viewer.removeEventListener("beforeRender", this._update), this.viewer.invalidate(), this;
+  }
+}
+const q = "position:absolute;top:0;left:0;width:100%;height:100%;pointer-events:none;overflow:hidden;", mt = q + "z-index:0;", ft = q + "z-index:1;";
+class vt {
+  el;
+  css2dRenderer = null;
+  css3dRenderer = null;
+  constructor(e) {
+    this.el = e, getComputedStyle(e).position === "static" && (e.style.position = "relative");
+  }
+  initCSS2DRenderer() {
+    const e = new ze();
+    return e.setSize(this.el.clientWidth, this.el.clientHeight), e.domElement.style.cssText = ft, this.el.appendChild(e.domElement), this.css2dRenderer = e, e;
+  }
+  initCSS3DRenderer() {
+    const e = new Le();
+    return e.setSize(this.el.clientWidth, this.el.clientHeight), e.domElement.style.cssText = mt, this.el.appendChild(e.domElement), this.css3dRenderer = e, e;
+  }
+  createCSS2DObject(e) {
+    return this.css2dRenderer || this.initCSS2DRenderer(), new Ae(e);
+  }
+  createCSS25DObject(e) {
+    return this.css3dRenderer || this.initCSS3DRenderer(), new Ue(e);
+  }
+  createCSS3DObject(e) {
+    return this.css3dRenderer || this.initCSS3DRenderer(), new Ge(e);
+  }
+  render(e, t) {
+    this.css2dRenderer && this.css2dRenderer.render(e, t), this.css3dRenderer && this.css3dRenderer.render(e, t);
+  }
+  resize(e, t) {
+    this.css2dRenderer && this.css2dRenderer.setSize(e, t), this.css3dRenderer && this.css3dRenderer.setSize(e, t);
+  }
+  dispose() {
+    this.css2dRenderer && (this.el.removeChild(this.css2dRenderer.domElement), this.css2dRenderer = null), this.css3dRenderer && (this.el.removeChild(this.css3dRenderer.domElement), this.css3dRenderer = null);
+  }
+}
+const gt = "timestamp-query";
+class Tt {
+  el;
+  renderer;
+  container;
+  drawCallsText;
+  frameCallsText;
+  trianglesText;
+  pointsText;
+  linesText;
+  timestampText;
+  _enabled = !1;
+  #r = !1;
+  constructor(e, t) {
+    this.el = e, this.renderer = t;
+    const s = document.createElement("div");
+    s.style.position = "absolute", s.style.left = "12px", s.style.bottom = "12px", s.style.fontSize = "12px", s.style.color = "#fff", s.style.pointerEvents = "none", this.container = s;
+    function i(a, o = !0) {
+      const c = document.createElement("span");
+      return o && (c.style.marginLeft = "6px"), c.innerText = a, c;
+    }
+    function r() {
+      return document.createElement("br");
+    }
+    this.drawCallsText = i("0"), this.frameCallsText = i("0"), this.trianglesText = i("0"), this.linesText = i("0"), this.pointsText = i("0"), this.timestampText = i("0"), this.container.appendChild(i("draw calls", !1)), this.container.appendChild(this.drawCallsText), this.container.appendChild(r()), this.container.appendChild(i("frame calls", !1)), this.container.appendChild(this.frameCallsText), this.container.appendChild(r()), this.container.appendChild(i("triangles", !1)), this.container.appendChild(this.trianglesText), this.container.appendChild(r()), this.container.appendChild(i("points", !1)), this.container.appendChild(this.pointsText), this.container.appendChild(r()), this.container.appendChild(i("lines", !1)), this.container.appendChild(this.linesText), this.container.appendChild(r()), this.container.appendChild(i("timestamp", !1)), this.container.appendChild(this.timestampText), this.container.appendChild(r());
+  }
+  update() {
+    if (this._enabled) {
+      const { render: e } = this.renderer.info;
+      if (this.drawCallsText.innerText = e.drawCalls.toString(), this.frameCallsText.innerText = e.frameCalls.toString(), this.trianglesText.innerText = e.triangles.toString(), this.pointsText.innerText = e.points.toString(), this.linesText.innerText = e.lines.toString(), !this.#r) {
+        this.timestampText.innerText = "0";
+        return;
+      }
+      this.#o(T.RENDER).then((t) => {
+        this._enabled && (this.timestampText.innerText = t?.toFixed(2) ?? "0");
+      }), this.#o(T.COMPUTE);
+    }
+  }
+  enable() {
+    this._enabled = !0, this.#l(!0), this.el.appendChild(this.container);
+  }
+  disable() {
+    this._enabled = !1, this.#l(!1), this.#h(), this.container.remove();
+  }
+  dispose() {
+    this.disable();
+  }
+  #s() {
+    return this.renderer.backend;
+  }
+  #a() {
+    try {
+      return this.renderer.hasFeature(gt);
+    } catch {
+      return !0;
+    }
+  }
+  #l(e) {
+    const t = this.#s();
+    if (!t) {
+      this.#r = !1;
+      return;
+    }
+    t.trackTimestamp = e && this.#a(), this.#r = t.trackTimestamp === !0;
+  }
+  #o(e) {
+    const t = this.#s()?.timestampQueryPool?.[e];
+    return t?.resolveQueriesAsync ? Promise.resolve(t.resolveQueriesAsync()).catch(() => {
+    }) : Promise.resolve(void 0);
+  }
+  #h() {
+    this.#o(T.RENDER), this.#o(T.COMPUTE);
+  }
+}
+function yt(n, e = 1) {
+  return Number.isFinite(e) ? Math.max(n, Math.max(0, Math.ceil(e))) : n;
+}
+ne.enabled = !0;
+class kt extends re {
+  el;
+  renderer;
+  scene;
+  camera;
+  info;
+  controls;
+  renderPipeline;
+  timer;
+  roomEnvironment;
+  interactionManager;
+  objectManager;
+  viewerHelper;
+  cssRenderer;
+  frameCount = 1;
+  frameloop = "demand";
+  constructor({ el: e, rendererOptions: t, pixelRatio: s }) {
+    super(), this.el = e, this.renderer = this._initRenderer(t, s), this.scene = this.createScene(), this.camera = this.createPerspectiveCamera(), this.info = new Tt(this.el, this.renderer), this.controls = new lt(this.camera, this.renderer.domElement), this.renderPipeline = new ot(this.renderer, this.scene, this.camera), this.timer = new ae(), this.roomEnvironment = new pt(this.renderer), this.interactionManager = new Ve(this.renderer.domElement, this.scene, this.camera), this.objectManager = new Ye(), this.viewerHelper = new ut(this), this.cssRenderer = new vt(this.el), window.addEventListener("resize", this.onWindowResize);
+  }
+  onWindowResize = () => {
+    const e = this.el.clientWidth, t = this.el.clientHeight;
+    this.camera instanceof v ? (this.camera.aspect = e / t, this.camera.updateProjectionMatrix()) : this.camera instanceof b && (this.camera.left = -e / 2, this.camera.right = e / 2, this.camera.top = t / 2, this.camera.bottom = -t / 2, this.camera.updateProjectionMatrix()), this.renderer.setSize(e, t), this.cssRenderer.resize(e, t), this.invalidate();
+  };
+  async init() {
+    await this.renderer.init(), this.roomEnvironment.update(), this.scene.environment = this.roomEnvironment.envMap;
+  }
+  setCamera(e) {
+    this.camera = e, this.controls.camera = e, this.interactionManager.setCamera(e), this.renderPipeline.setCamera(e), this.onWindowResize(), this.dispatchEvent({ type: "cameraChange", camera: e });
+  }
+  setCameraByType(e) {
+    e === "perspective" && !(this.camera instanceof v) ? this.setCamera(this.createPerspectiveCamera()) : e === "orthographic" && !(this.camera instanceof b) && this.setCamera(this.createOrthographicCamera());
+  }
+  invalidate(e = 1) {
+    this.frameCount = yt(this.frameCount, e);
+  }
+  render(e = 1) {
+    return this.invalidate(e), new Promise((t) => {
+      const s = () => {
+        this.removeEventListener("afterRender", s), t();
+      };
+      this.addEventListener("afterRender", s);
+    });
+  }
+  animate = (e) => {
+    this.timer.update(e);
+    const t = this.timer.getDelta();
+    this.dispatchEvent({ type: "beforeControlsUpdate", time: e, delta: t });
+    let s = this.controls.update(t);
+    this.dispatchEvent({ type: "afterControlsUpdate", time: e, delta: t }), this.frameCount > 0 && (this.frameCount--, s = !0), this.frameloop === "always" && (s = !0), s && (this.dispatchEvent({ type: "beforeRender", time: e, delta: t }), this.renderer.info.reset(), this.renderPipeline.render(), this.cssRenderer.render(this.scene, this.camera), this.info.update(), this.dispatchEvent({ type: "afterRender", time: e, delta: t }));
+  };
+  _initRenderer(e, t = Math.min(window.devicePixelRatio, 1.5)) {
+    const s = new oe({
+      reversedDepthBuffer: !0,
+      antialias: !1,
+      depth: !1,
+      trackTimestamp: !1,
+      ...e
+    });
+    return s.setPixelRatio(t), s.setSize(this.el.clientWidth, this.el.clientHeight), s.shadowMap.enabled = !0, s.shadowMap.type = he, s.toneMapping = le, s.toneMappingExposure = 1, s.info.autoReset = !1, s.setAnimationLoop(this.animate), this.el.appendChild(s.domElement), s;
+  }
+  createScene() {
+    const e = new de();
+    return e.background = new N(0), e;
+  }
+  createPerspectiveCamera() {
+    const e = new v(50, this.el.clientWidth / this.el.clientHeight, 0.1, 1e5);
+    return e.position.setScalar(5), e;
+  }
+  createOrthographicCamera() {
+    const e = new b(
+      -this.el.clientWidth / 2,
+      this.el.clientWidth / 2,
+      this.el.clientHeight / 2,
+      -this.el.clientHeight / 2,
+      0.1,
+      1e5
+    );
+    return e.position.setScalar(5), e;
+  }
+  /**
+   * Manually trigger a resize update.
+   */
+  resize(e, t) {
+    e !== void 0 && t !== void 0 && (this.el.style.width = `${e}px`, this.el.style.height = `${t}px`), this.onWindowResize();
+  }
+  /**
+   * Capture a screenshot of the current render.
+   */
+  async screenshot(e = {}) {
+    const { type: t = "image/png", quality: s = 1 } = e, i = this.el.clientWidth, r = this.el.clientHeight, a = e.width && e.height;
+    a && this.renderer.setSize(e.width, e.height), await this.render();
+    const o = this.renderer.domElement.toDataURL(t, s);
+    return a && (this.renderer.setSize(i, r), this.onWindowResize()), o;
+  }
+  /**
+   * Set the scene background color, texture, or null.
+   */
+  setBackground(e) {
+    e === null ? this.scene.background = null : e instanceof N || typeof e == "number" || typeof e == "string" ? this.scene.background = new N(e) : this.scene.background = e, this.invalidate();
+  }
+  /**
+   * Set the scene environment map for reflections / IBL.
+   */
+  setEnvironment(e) {
+    this.scene.environment = e, this.invalidate();
+  }
+  /**
+   * Enable shadow rendering.
+   */
+  enableShadow() {
+    this.renderer.shadowMap.enabled = !0, this.invalidate();
+  }
+  /**
+   * Disable shadow rendering.
+   */
+  disableShadow() {
+    this.renderer.shadowMap.enabled = !1, this.invalidate();
+  }
+  /**
+   * Enable linear fog.
+   */
+  enableFog(e = {}) {
+    const { color: t = 13421772, near: s = 10, far: i = 100 } = e;
+    this.scene.fog = new ce(t, s, i), this.invalidate();
+  }
+  /**
+   * Enable exponential fog.
+   */
+  enableFogExp2(e = {}) {
+    const { color: t = 13421772, density: s = 0.01 } = e;
+    this.scene.fog = new pe(t, s), this.invalidate();
+  }
+  /**
+   * Disable fog.
+   */
+  disableFog() {
+    this.scene.fog = null, this.invalidate();
+  }
+  dispose() {
+    this.el.removeChild(this.renderer.domElement), window.removeEventListener("resize", this.onWindowResize), this.info.dispose(), this.interactionManager.dispose(), this.roomEnvironment.dispose(), this.cssRenderer.dispose(), this.renderPipeline.dispose(), this.renderer.dispose();
+  }
+}
+export {
+  vt as C,
+  He as I,
+  Ye as O,
+  ot as R,
+  kt as V,
+  lt as a,
+  Ve as b,
+  pt as c,
+  jt as e,
+  $e as g
+};