@needle-tools/engine 4.7.3-next.65e7878 → 4.7.3-next.b448b7a

package/dist/gltf-progressive-BMJtMiwp.js

@@ -0,0 +1,1204 @@
+var He = Object.defineProperty;
+var Be = (o) => {
+  throw TypeError(o);
+};
+var Qe = (o, e, t) => e in o ? He(o, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : o[e] = t;
+var u = (o, e, t) => Qe(o, typeof e != "symbol" ? e + "" : e, t), Ge = (o, e, t) => e.has(o) || Be("Cannot " + t);
+var L = (o, e, t) => (Ge(o, e, "read from private field"), t ? t.call(o) : e.get(o)), Y = (o, e, t) => e.has(o) ? Be("Cannot add the same private member more than once") : e instanceof WeakSet ? e.add(o) : e.set(o, t), z = (o, e, t, s) => (Ge(o, e, "write to private field"), s ? s.call(o, t) : e.set(o, t), t);
+import { BufferGeometry as ye, Mesh as te, Texture as ne, TextureLoader as je, Matrix4 as $e, Clock as Je, MeshStandardMaterial as Ze, Sphere as et, Box3 as ke, Vector3 as V } from "./three-DrqIzZTH.js";
+import { DRACOLoader as tt, KTX2Loader as st, MeshoptDecoder as rt, GLTFLoader as Ce } from "./three-examples-tvuhV8Ne.js";
+const it = "";
+globalThis.GLTF_PROGRESSIVE_VERSION = it;
+console.debug("[gltf-progressive] version -");
+let q = "https://www.gstatic.com/draco/versioned/decoders/1.5.7/", se = "https://www.gstatic.com/basis-universal/versioned/2021-04-15-ba1c3e4/";
+const nt = q, ot = se, Fe = new URL(q + "draco_decoder.js");
+Fe.searchParams.append("range", "true");
+fetch(Fe, {
+  method: "GET",
+  headers: {
+    Range: "bytes=0-1"
+  }
+}).catch((o) => {
+  console.debug(`Failed to fetch remote Draco decoder from ${q} (offline: ${typeof navigator < "u" ? navigator.onLine : "unknown"})`), q === nt && at("./include/draco/"), se === ot && lt("./include/ktx2/");
+}).finally(() => {
+  Ue();
+});
+function at(o) {
+  q = o, k && k[Pe] != q ? (console.debug("Updating Draco decoder path to " + o), k[Pe] = q, k.setDecoderPath(q), k.preload()) : console.debug("Setting Draco decoder path to " + o);
+}
+function lt(o) {
+  se = o, R && R.transcoderPath != se ? (console.debug("Updating KTX2 transcoder path to " + o), R.setTranscoderPath(se), R.init()) : console.debug("Setting KTX2 transcoder path to " + o);
+}
+const Pe = Symbol("dracoDecoderPath");
+let k, Le, R;
+function Ue() {
+  k || (k = new tt(), k[Pe] = q, k.setDecoderPath(q), k.setDecoderConfig({ type: "js" }), k.preload()), R || (R = new st(), R.setTranscoderPath(se), R.init()), Le || (Le = rt);
+}
+function ze(o) {
+  return Ue(), o ? R.detectSupport(o) : o !== null && console.warn("No renderer provided to detect ktx2 support - loading KTX2 textures might fail"), { dracoLoader: k, ktx2Loader: R, meshoptDecoder: Le };
+}
+function Ne(o) {
+  o.dracoLoader || o.setDRACOLoader(k), o.ktx2Loader || o.setKTX2Loader(R), o.meshoptDecoder || o.setMeshoptDecoder(Le);
+}
+const Te = /* @__PURE__ */ new WeakMap();
+function qe(o, e) {
+  let t = Te.get(o);
+  t ? t = Object.assign(t, e) : t = e, Te.set(o, t);
+}
+const ve = Ce.prototype.load;
+function ut(...o) {
+  const e = Te.get(this);
+  let t = o[0];
+  const s = new URL(t, window.location.href);
+  if (s.hostname.endsWith("needle.tools")) {
+    const r = (e == null ? void 0 : e.progressive) !== void 0 ? e.progressive : !0, i = e != null && e.usecase ? e.usecase : "default";
+    r ? this.requestHeader.Accept = `*/*;progressive=allowed;usecase=${i}` : this.requestHeader.Accept = `*/*;usecase=${i}`, t = s.toString();
+  }
+  return o[0] = t, ve == null ? void 0 : ve.call(this, ...o);
+}
+Ce.prototype.load = ut;
+ue("debugprogressive");
+function ue(o) {
+  if (typeof window > "u") return !1;
+  const t = new URL(window.location.href).searchParams.get(o);
+  return t == null || t === "0" || t === "false" ? !1 : t === "" ? !0 : t;
+}
+function dt(o, e) {
+  if (e === void 0 || e.startsWith("./") || e.startsWith("http") || o === void 0)
+    return e;
+  const t = o.lastIndexOf("/");
+  if (t >= 0) {
+    const s = o.substring(0, t + 1);
+    for (; s.endsWith("/") && e.startsWith("/"); ) e = e.substring(1);
+    return s + e;
+  }
+  return e;
+}
+let oe;
+function ct() {
+  return oe !== void 0 || (oe = /iPhone|iPad|iPod|Android|IEMobile/i.test(navigator.userAgent), ue("debugprogressive") && console.log("[glTF Progressive]: isMobileDevice", oe)), oe;
+}
+function ft() {
+  if (typeof window > "u") return !1;
+  const o = new URL(window.location.href), e = o.hostname === "localhost" || /^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/.test(o.hostname);
+  return o.hostname === "127.0.0.1" || e;
+}
+class ht {
+  constructor(e = 100, t = {}) {
+    u(this, "_running", /* @__PURE__ */ new Map());
+    u(this, "_queue", []);
+    u(this, "debug", !1);
+    u(this, "tick", () => {
+      this.internalUpdate(), setTimeout(this.tick, 10);
+    });
+    this.maxConcurrent = e, this.debug = t.debug ?? !1, window.requestAnimationFrame(this.tick);
+  }
+  /**
+   * Request a slot for a promise with a specific key. This function returns a promise with a `use` method that can be called to add the promise to the queue.
+   */
+  slot(e) {
+    return this.debug && console.debug(`[PromiseQueue]: Requesting slot for key ${e}, running: ${this._running.size}, waiting: ${this._queue.length}`), new Promise((t) => {
+      this._queue.push({ key: e, resolve: t });
+    });
+  }
+  add(e, t) {
+    this._running.has(e) || (this._running.set(e, t), t.finally(() => {
+      this._running.delete(e), this.debug && console.debug(`[PromiseQueue]: Promise for key ${e} finished, running: ${this._running.size}, waiting: ${this._queue.length}`);
+    }), this.debug && console.debug(`[PromiseQueue]: Adding promise for key ${e}, running: ${this._running.size}, waiting: ${this._queue.length}`));
+  }
+  internalUpdate() {
+    const e = this.maxConcurrent - this._running.size;
+    for (let t = 0; t < e && this._queue.length > 0; t++) {
+      this.debug && console.debug(`[PromiseQueue]: Running ${this._running.size} promises, waiting for ${this._queue.length} more.`);
+      const { key: s, resolve: n } = this._queue.shift();
+      n({
+        use: (r) => this.add(s, r)
+      });
+    }
+  }
+}
+const gt = typeof window > "u" && typeof document > "u", Ae = Symbol("needle:raycast-mesh");
+function de(o) {
+  return (o == null ? void 0 : o[Ae]) instanceof ye ? o[Ae] : null;
+}
+function pt(o, e) {
+  if ((o.type === "Mesh" || o.type === "SkinnedMesh") && !de(o)) {
+    const s = yt(e);
+    s.userData = { isRaycastMesh: !0 }, o[Ae] = s;
+  }
+}
+function mt(o = !0) {
+  if (o) {
+    if (ae) return;
+    const e = ae = te.prototype.raycast;
+    te.prototype.raycast = function(t, s) {
+      const n = this, r = de(n);
+      let i;
+      r && n.isMesh && (i = n.geometry, n.geometry = r), e.call(this, t, s), i && (n.geometry = i);
+    };
+  } else {
+    if (!ae) return;
+    te.prototype.raycast = ae, ae = null;
+  }
+}
+let ae = null;
+function yt(o) {
+  const e = new ye();
+  for (const t in o.attributes)
+    e.setAttribute(t, o.getAttribute(t));
+  return e.setIndex(o.getIndex()), e;
+}
+const Q = new Array(), x = ue("debugprogressive");
+let pe, ee = -1;
+if (x) {
+  let o = function() {
+    ee += 1, ee >= e && (ee = -1), console.log(`Toggle LOD level [${ee}]`);
+  }, e = 6;
+  window.addEventListener("keyup", (t) => {
+    t.key === "p" && o(), t.key === "w" && (pe = !pe, console.log(`Toggle wireframe [${pe}]`));
+    const s = parseInt(t.key);
+    !isNaN(s) && s >= 0 && (ee = s, console.log(`Set LOD level to [${ee}]`));
+  });
+}
+function Ve(o) {
+  if (x)
+    if (Array.isArray(o))
+      for (const e of o)
+        Ve(e);
+    else o && "wireframe" in o && (o.wireframe = pe === !0);
+}
+const W = "NEEDLE_progressive", Oe = Symbol("needle-progressive-texture"), _ = class _ {
+  constructor(e, t) {
+    u(this, "parser");
+    u(this, "url");
+    u(this, "_isLoadingMesh");
+    u(this, "loadMesh", (e) => {
+      var s, n;
+      if (this._isLoadingMesh) return null;
+      const t = (n = (s = this.parser.json.meshes[e]) == null ? void 0 : s.extensions) == null ? void 0 : n[W];
+      return t ? (this._isLoadingMesh = !0, this.parser.getDependency("mesh", e).then((r) => {
+        var i;
+        return this._isLoadingMesh = !1, r && _.registerMesh(this.url, t.guid, r, (i = t.lods) == null ? void 0 : i.length, 0, t), r;
+      })) : null;
+    });
+    x && console.log("Progressive extension registered for", t), this.parser = e, this.url = t;
+  }
+  /** The name of the extension */
+  get name() {
+    return W;
+  }
+  static getMeshLODExtension(e) {
+    const t = this.getAssignedLODInformation(e);
+    return t != null && t.key ? this.lodInfos.get(t.key) : null;
+  }
+  static getPrimitiveIndex(e) {
+    var s;
+    const t = (s = this.getAssignedLODInformation(e)) == null ? void 0 : s.index;
+    return t ?? -1;
+  }
+  static getMaterialMinMaxLODsCount(e, t) {
+    const s = this, n = "LODS:minmax", r = e[n];
+    if (r != null) return r;
+    if (t || (t = {
+      min_count: 1 / 0,
+      max_count: 0,
+      lods: []
+    }), Array.isArray(e)) {
+      for (const a of e)
+        this.getMaterialMinMaxLODsCount(a, t);
+      return e[n] = t, t;
+    }
+    if (x === "verbose" && console.log("getMaterialMinMaxLODsCount", e), e.type === "ShaderMaterial" || e.type === "RawShaderMaterial") {
+      const a = e;
+      for (const l of Object.keys(a.uniforms)) {
+        const c = a.uniforms[l].value;
+        (c == null ? void 0 : c.isTexture) === !0 && i(c, t);
+      }
+    } else if (e.isMaterial)
+      for (const a of Object.keys(e)) {
+        const l = e[a];
+        (l == null ? void 0 : l.isTexture) === !0 && i(l, t);
+      }
+    return e[n] = t, t;
+    function i(a, l) {
+      const c = s.getAssignedLODInformation(a);
+      if (c) {
+        const d = s.lodInfos.get(c.key);
+        if (d && d.lods) {
+          l.min_count = Math.min(l.min_count, d.lods.length), l.max_count = Math.max(l.max_count, d.lods.length);
+          for (let p = 0; p < d.lods.length; p++) {
+            const f = d.lods[p];
+            f.width && (l.lods[p] = l.lods[p] || { min_height: 1 / 0, max_height: 0 }, l.lods[p].min_height = Math.min(l.lods[p].min_height, f.height), l.lods[p].max_height = Math.max(l.lods[p].max_height, f.height));
+          }
+        }
+      }
+    }
+  }
+  /** Check if a LOD level is available for a mesh or a texture
+   * @param obj the mesh or texture to check
+   * @param level the level of detail to check for (0 is the highest resolution). If undefined, the function checks if any LOD level is available
+   * @returns true if the LOD level is available (or if any LOD level is available if level is undefined)
+   */
+  static hasLODLevelAvailable(e, t) {
+    var r;
+    if (Array.isArray(e)) {
+      for (const i of e)
+        if (this.hasLODLevelAvailable(i, t)) return !0;
+      return !1;
+    }
+    if (e.isMaterial === !0) {
+      for (const i of Object.keys(e)) {
+        const a = e[i];
+        if (a && a.isTexture && this.hasLODLevelAvailable(a, t))
+          return !0;
+      }
+      return !1;
+    } else if (e.isGroup === !0) {
+      for (const i of e.children)
+        if (i.isMesh === !0 && this.hasLODLevelAvailable(i, t))
+          return !0;
+    }
+    let s, n;
+    if (e.isMesh ? s = e.geometry : (e.isBufferGeometry || e.isTexture) && (s = e), s && (r = s == null ? void 0 : s.userData) != null && r.LODS) {
+      const i = s.userData.LODS;
+      if (n = this.lodInfos.get(i.key), t === void 0) return n != null;
+      if (n)
+        return Array.isArray(n.lods) ? t < n.lods.length : t === 0;
+    }
+    return !1;
+  }
+  /** Load a different resolution of a mesh (if available)
+   * @param context the context
+   * @param source the sourceid of the file from which the mesh is loaded (this is usually the component's sourceId)
+   * @param mesh the mesh to load the LOD for
+   * @param level the level of detail to load (0 is the highest resolution)
+   * @returns a promise that resolves to the mesh with the requested LOD level
+   * @example
+   * ```javascript
+   * const mesh = this.gameObject as Mesh;
+   * NEEDLE_progressive.assignMeshLOD(context, sourceId, mesh, 1).then(mesh => {
+   *    console.log("Mesh with LOD level 1 loaded", mesh);
+   * });
+   * ```
+   */
+  static assignMeshLOD(e, t) {
+    var s;
+    if (!e) return Promise.resolve(null);
+    if (e instanceof te || e.isMesh === !0) {
+      const n = e.geometry, r = this.getAssignedLODInformation(n);
+      if (!r)
+        return Promise.resolve(null);
+      for (const i of Q)
+        (s = i.onBeforeGetLODMesh) == null || s.call(i, e, t);
+      return e["LOD:requested level"] = t, _.getOrLoadLOD(n, t).then((i) => {
+        if (Array.isArray(i)) {
+          const a = r.index || 0;
+          i = i[a];
+        }
+        return e["LOD:requested level"] === t && (delete e["LOD:requested level"], i && n != i && ((i == null ? void 0 : i.isBufferGeometry) ? e.geometry = i : x && console.error("Invalid LOD geometry", i))), i;
+      }).catch((i) => (console.error("Error loading mesh LOD", e, i), null));
+    } else x && console.error("Invalid call to assignMeshLOD: Request mesh LOD but the object is not a mesh", e);
+    return Promise.resolve(null);
+  }
+  static assignTextureLOD(e, t = 0) {
+    if (!e) return Promise.resolve(null);
+    if (e.isMesh === !0) {
+      const s = e;
+      if (Array.isArray(s.material)) {
+        const n = new Array();
+        for (const r of s.material) {
+          const i = this.assignTextureLOD(r, t);
+          n.push(i);
+        }
+        return Promise.all(n).then((r) => {
+          const i = new Array();
+          for (const a of r)
+            Array.isArray(a) && i.push(...a);
+          return i;
+        });
+      } else
+        return this.assignTextureLOD(s.material, t);
+    }
+    if (e.isMaterial === !0) {
+      const s = e, n = [], r = new Array();
+      if (s.uniforms && (s.isRawShaderMaterial || s.isShaderMaterial === !0)) {
+        const i = s;
+        for (const a of Object.keys(i.uniforms)) {
+          const l = i.uniforms[a].value;
+          if ((l == null ? void 0 : l.isTexture) === !0) {
+            const c = this.assignTextureLODForSlot(l, t, s, a).then((d) => (d && i.uniforms[a].value != d && (i.uniforms[a].value = d, i.uniformsNeedUpdate = !0), d));
+            n.push(c), r.push(a);
+          }
+        }
+      } else
+        for (const i of Object.keys(s)) {
+          const a = s[i];
+          if ((a == null ? void 0 : a.isTexture) === !0) {
+            const l = this.assignTextureLODForSlot(a, t, s, i);
+            n.push(l), r.push(i);
+          }
+        }
+      return Promise.all(n).then((i) => {
+        const a = new Array();
+        for (let l = 0; l < i.length; l++) {
+          const c = i[l], d = r[l];
+          c && c.isTexture === !0 ? a.push({ material: s, slot: d, texture: c, level: t }) : a.push({ material: s, slot: d, texture: null, level: t });
+        }
+        return a;
+      });
+    }
+    if (e instanceof ne || e.isTexture === !0) {
+      const s = e;
+      return this.assignTextureLODForSlot(s, t, null, null);
+    }
+    return Promise.resolve(null);
+  }
+  static assignTextureLODForSlot(e, t, s, n) {
+    return (e == null ? void 0 : e.isTexture) !== !0 ? Promise.resolve(null) : n === "glyphMap" ? Promise.resolve(e) : _.getOrLoadLOD(e, t).then((r) => {
+      if (Array.isArray(r)) return null;
+      if ((r == null ? void 0 : r.isTexture) === !0) {
+        if (r != e && s && n) {
+          const i = s[n];
+          if (i && !x) {
+            const a = this.getAssignedLODInformation(i);
+            if (a && (a == null ? void 0 : a.level) < t)
+              return x === "verbose" && console.warn("Assigned texture level is already higher: ", a.level, t, s, i, r), null;
+          }
+          s[n] = r;
+        }
+        return r;
+      } else x == "verbose" && console.warn("No LOD found for", e, t);
+      return null;
+    }).catch((r) => (console.error("Error loading LOD", e, r), null));
+  }
+  afterRoot(e) {
+    var t, s;
+    return x && console.log("AFTER", this.url, e), (t = this.parser.json.textures) == null || t.forEach((n, r) => {
+      var i;
+      if (n != null && n.extensions) {
+        const a = n == null ? void 0 : n.extensions[W];
+        if (a) {
+          if (!a.lods) {
+            x && console.warn("Texture has no LODs", a);
+            return;
+          }
+          let l = !1;
+          for (const c of this.parser.associations.keys())
+            if (c.isTexture === !0) {
+              const d = this.parser.associations.get(c);
+              (d == null ? void 0 : d.textures) === r && (l = !0, _.registerTexture(this.url, c, (i = a.lods) == null ? void 0 : i.length, r, a));
+            }
+          l || this.parser.getDependency("texture", r).then((c) => {
+            var d;
+            c && _.registerTexture(this.url, c, (d = a.lods) == null ? void 0 : d.length, r, a);
+          });
+        }
+      }
+    }), (s = this.parser.json.meshes) == null || s.forEach((n, r) => {
+      if (n != null && n.extensions) {
+        const i = n == null ? void 0 : n.extensions[W];
+        if (i && i.lods) {
+          for (const a of this.parser.associations.keys())
+            if (a.isMesh) {
+              const l = this.parser.associations.get(a);
+              (l == null ? void 0 : l.meshes) === r && _.registerMesh(this.url, i.guid, a, i.lods.length, l.primitives, i);
+            }
+        }
+      }
+    }), null;
+  }
+  static async getOrLoadLOD(e, t) {
+    var a, l, c, d;
+    const s = x == "verbose", n = e.userData.LODS;
+    if (!n)
+      return null;
+    const r = n == null ? void 0 : n.key;
+    let i;
+    if (e.isTexture === !0) {
+      const p = e;
+      p.source && p.source[Oe] && (i = p.source[Oe]);
+    }
+    if (i || (i = _.lodInfos.get(r)), i) {
+      if (t > 0) {
+        let D = !1;
+        const O = Array.isArray(i.lods);
+        if (O && t >= i.lods.length ? D = !0 : O || (D = !0), D)
+          return this.lowresCache.get(r);
+      }
+      const p = Array.isArray(i.lods) ? (a = i.lods[t]) == null ? void 0 : a.path : i.lods;
+      if (!p)
+        return x && !i["missing:uri"] && (i["missing:uri"] = !0, console.warn("Missing uri for progressive asset for LOD " + t, i)), null;
+      const f = dt(n.url, p);
+      if (f.endsWith(".glb") || f.endsWith(".gltf")) {
+        if (!i.guid)
+          return console.warn("missing pointer for glb/gltf texture", i), null;
+        const D = f + "_" + i.guid, O = this.previouslyLoaded.get(D);
+        if (O !== void 0) {
+          s && console.log(`LOD ${t} was already loading/loaded: ${D}`);
+          let h = await O.catch((T) => (console.error(`Error loading LOD ${t} from ${f}
+`, T), null)), w = !1;
+          if (h == null || (h instanceof ne && e instanceof ne ? (l = h.image) != null && l.data || (c = h.source) != null && c.data ? h = this.copySettings(e, h) : (w = !0, this.previouslyLoaded.delete(D)) : h instanceof ye && e instanceof ye && ((d = h.attributes.position) != null && d.array || (w = !0, this.previouslyLoaded.delete(D)))), !w)
+            return h;
+        }
+        const P = await this.queue.slot(f);
+        if (!P.use)
+          return x && console.log(`LOD ${t} was aborted: ${f}`), null;
+        const b = i, E = new Promise(async (h, w) => {
+          const T = new Ce();
+          Ne(T), x && (await new Promise((v) => setTimeout(v, 1e3)), s && console.warn("Start loading (delayed) " + f, b.guid));
+          let F = f;
+          if (b && Array.isArray(b.lods)) {
+            const v = b.lods[t];
+            v.hash && (F += "?v=" + v.hash);
+          }
+          const S = await T.loadAsync(F).catch((v) => (console.error(`Error loading LOD ${t} from ${f}
+`, v), h(null)));
+          if (!S)
+            return h(null);
+          const Z = S.parser;
+          s && console.log("Loading finished " + f, b.guid);
+          let A = 0;
+          if (S.parser.json.textures) {
+            let v = !1;
+            for (const m of S.parser.json.textures) {
+              if (m != null && m.extensions) {
+                const g = m == null ? void 0 : m.extensions[W];
+                if (g != null && g.guid && g.guid === b.guid) {
+                  v = !0;
+                  break;
+                }
+              }
+              A++;
+            }
+            if (v) {
+              let m = await Z.getDependency("texture", A);
+              return m && _.assignLODInformation(n.url, m, r, t, void 0), s && console.log('change "' + e.name + '" → "' + m.name + '"', f, A, m, D), e instanceof ne && (m = this.copySettings(e, m)), m && (m.guid = b.guid), h(m);
+            } else x && console.warn("Could not find texture with guid", b.guid, S.parser.json);
+          }
+          if (A = 0, S.parser.json.meshes) {
+            let v = !1;
+            for (const m of S.parser.json.meshes) {
+              if (m != null && m.extensions) {
+                const g = m == null ? void 0 : m.extensions[W];
+                if (g != null && g.guid && g.guid === b.guid) {
+                  v = !0;
+                  break;
+                }
+              }
+              A++;
+            }
+            if (v) {
+              const m = await Z.getDependency("mesh", A);
+              if (s && console.log(`Loaded Mesh "${m.name}"`, f, A, m, D), m.isMesh === !0) {
+                const g = m.geometry;
+                return _.assignLODInformation(n.url, g, r, t, 0), h(g);
+              } else {
+                const g = new Array();
+                for (let M = 0; M < m.children.length; M++) {
+                  const C = m.children[M];
+                  if (C.isMesh === !0) {
+                    const B = C.geometry;
+                    _.assignLODInformation(n.url, B, r, t, M), g.push(B);
+                  }
+                }
+                return h(g);
+              }
+            } else x && console.warn("Could not find mesh with guid", b.guid, S.parser.json);
+          }
+          return h(null);
+        });
+        return this.previouslyLoaded.set(D, E), P.use(E), await E;
+      } else if (e instanceof ne) {
+        s && console.log("Load texture from uri: " + f);
+        const O = await new je().loadAsync(f);
+        return O ? (O.guid = i.guid, O.flipY = !1, O.needsUpdate = !0, O.colorSpace = e.colorSpace, s && console.log(i, O)) : x && console.warn("failed loading", f), O;
+      }
+    } else
+      x && console.warn(`Can not load LOD ${t}: no LOD info found for "${r}" ${e.name}`, e.type);
+    return null;
+  }
+  static assignLODInformation(e, t, s, n, r) {
+    if (!t) return;
+    t.userData || (t.userData = {});
+    const i = new Lt(e, s, n, r);
+    t.userData.LODS = i;
+  }
+  static getAssignedLODInformation(e) {
+    var t;
+    return ((t = e == null ? void 0 : e.userData) == null ? void 0 : t.LODS) || null;
+  }
+  // private static readonly _copiedTextures: WeakMap<Texture, Texture> = new Map();
+  static copySettings(e, t) {
+    return t ? (x && console.warn(`Copy texture settings
+`, e.uuid, `
+`, t.uuid), t = t.clone(), t.offset = e.offset, t.repeat = e.repeat, t.colorSpace = e.colorSpace, t.magFilter = e.magFilter, t.minFilter = e.minFilter, t.wrapS = e.wrapS, t.wrapT = e.wrapT, t.flipY = e.flipY, t.anisotropy = e.anisotropy, t.mipmaps || (t.generateMipmaps = e.generateMipmaps), t) : e;
+  }
+};
+/**
+ * Register a texture with LOD information
+ */
+u(_, "registerTexture", (e, t, s, n, r) => {
+  if (x && console.log("> Progressive: register texture", n, t.name, t.uuid, t, r), !t) {
+    x && console.error("gltf-progressive: Register texture without texture");
+    return;
+  }
+  t.source && (t.source[Oe] = r);
+  const i = r.guid;
+  _.assignLODInformation(e, t, i, s, n), _.lodInfos.set(i, r), _.lowresCache.set(i, t);
+}), /**
+ * Register a mesh with LOD information
+ */
+u(_, "registerMesh", (e, t, s, n, r, i) => {
+  var c;
+  const a = s.geometry;
+  if (!a) {
+    x && console.warn("gltf-progressive: Register mesh without geometry");
+    return;
+  }
+  a.userData || (a.userData = {}), x && console.log("> Progressive: register mesh " + s.name, { index: r, uuid: s.uuid }, i, s), _.assignLODInformation(e, a, t, n, r), _.lodInfos.set(t, i);
+  let l = _.lowresCache.get(t);
+  l ? l.push(s.geometry) : l = [s.geometry], _.lowresCache.set(t, l), n > 0 && !de(s) && pt(s, a);
+  for (const d of Q)
+    (c = d.onRegisteredNewMesh) == null || c.call(d, s, i);
+}), /** A map of key = asset uuid and value = LOD information */
+u(_, "lodInfos", /* @__PURE__ */ new Map()), /** cache of already loaded mesh lods */
+u(_, "previouslyLoaded", /* @__PURE__ */ new Map()), /** this contains the geometry/textures that were originally loaded */
+u(_, "lowresCache", /* @__PURE__ */ new Map()), u(_, "queue", new ht(100, { debug: x != !1 }));
+let N = _;
+class Lt {
+  constructor(e, t, s, n) {
+    u(this, "url");
+    /** the key to lookup the LOD information */
+    u(this, "key");
+    u(this, "level");
+    /** For multi objects (e.g. a group of meshes) this is the index of the object */
+    u(this, "index");
+    this.url = e, this.key = t, this.level = s, n != null && (this.index = n);
+  }
+}
+class me {
+  constructor(e, t) {
+    u(this, "frame_start");
+    u(this, "frame_capture_end");
+    u(this, "ready");
+    u(this, "_resolve");
+    u(this, "_signal");
+    u(this, "_resolved", !1);
+    u(this, "_addedCount", 0);
+    u(this, "_resolvedCount", 0);
+    /** These promises are currently being awaited */
+    u(this, "_awaiting", []);
+    u(this, "_maxPromisesPerObject", 1);
+    u(this, "_currentFrame", 0);
+    u(this, "_seen", /* @__PURE__ */ new WeakMap());
+    var r;
+    const n = Math.max(t.frames ?? 2, 2);
+    this.frame_start = e, this.frame_capture_end = e + n, this.ready = new Promise((i) => {
+      this._resolve = i;
+    }), this.ready.finally(() => {
+      this._resolved = !0, this._awaiting.length = 0;
+    }), this._signal = t.signal, (r = this._signal) == null || r.addEventListener("abort", () => {
+      this.resolveNow();
+    }), this._maxPromisesPerObject = Math.max(1, t.maxPromisesPerObject ?? 1);
+  }
+  /**
+   * The number of promises that have been added to this group so far.
+   */
+  get awaitedCount() {
+    return this._addedCount;
+  }
+  get resolvedCount() {
+    return this._resolvedCount;
+  }
+  get currentlyAwaiting() {
+    return this._awaiting.length;
+  }
+  update(e) {
+    var t;
+    this._currentFrame = e, ((t = this._signal) != null && t.aborted || this._currentFrame > this.frame_capture_end && this._awaiting.length === 0) && this.resolveNow();
+  }
+  add(e, t, s) {
+    if (this._resolved) {
+      x && console.warn("PromiseGroup: Trying to add a promise to a resolved group, ignoring.");
+      return;
+    }
+    if (!(this._currentFrame > this.frame_capture_end)) {
+      if (this._maxPromisesPerObject >= 1)
+        if (this._seen.has(t)) {
+          let n = this._seen.get(t);
+          if (n >= this._maxPromisesPerObject) {
+            x && console.warn("PromiseGroup: Already awaiting object ignoring new promise for it.");
+            return;
+          }
+          this._seen.set(t, n + 1);
+        } else
+          this._seen.set(t, 1);
+      this._awaiting.push(s), this._addedCount++, s.finally(() => {
+        this._resolvedCount++, this._awaiting.splice(this._awaiting.indexOf(s), 1);
+      });
+    }
+  }
+  resolveNow() {
+    var e, t;
+    this._resolved || (t = this._resolve) == null || t.call(this, {
+      awaited_count: this._addedCount,
+      resolved_count: this._resolvedCount,
+      cancelled: ((e = this._signal) == null ? void 0 : e.aborted) ?? !1
+    });
+  }
+}
+u(me, "addPromise", (e, t, s, n) => {
+  n.forEach((r) => {
+    r.add(e, t, s);
+  });
+});
+const I = ue("debugprogressive"), xt = ue("noprogressive"), be = Symbol("Needle:LODSManager"), Se = Symbol("Needle:LODState"), H = Symbol("Needle:CurrentLOD"), G = { mesh_lod: -1, texture_lod: -1 };
+var y, $, X, we, j, re, _e, K;
+let xe = (y = class {
+  // readonly plugins: NEEDLE_progressive_plugin[] = [];
+  constructor(e, t) {
+    u(this, "renderer");
+    u(this, "context");
+    u(this, "projectionScreenMatrix", new $e());
+    /**
+     * The target triangle density is the desired max amount of triangles on screen when the mesh is filling the screen.  
+     * @default 200_000
+     */
+    u(this, "targetTriangleDensity", 2e5);
+    /**
+     * The interval in frames to automatically update the bounds of skinned meshes.   
+     * Set to 0 or a negative value to disable automatic bounds updates. 
+     * @default 30
+     */
+    u(this, "skinnedMeshAutoUpdateBoundsInterval", 30);
+    /**
+     * The update interval in frames. If set to 0, the LODs will be updated every frame. If set to 2, the LODs will be updated every second frame, etc.
+     * @default "auto"
+     */
+    u(this, "updateInterval", "auto");
+    Y(this, $, 1);
+    /**
+     * If set to true, the LODsManager will not update the LODs.
+     * @default false
+     */
+    u(this, "pause", !1);
+    /**
+     * When set to true the LODsManager will not update the LODs. This can be used to manually update the LODs using the `update` method.  
+     * Otherwise the LODs will be updated automatically when the renderer renders the scene.
+     * @default false
+     */
+    u(this, "manual", !1);
+    u(this, "_newPromiseGroups", []);
+    u(this, "_promiseGroupIds", 0);
+    u(this, "_lodchangedlisteners", []);
+    Y(this, X);
+    Y(this, we, new Je());
+    Y(this, j, 0);
+    Y(this, re, 0);
+    Y(this, _e, 0);
+    Y(this, K, 0);
+    u(this, "_fpsBuffer", [60, 60, 60, 60, 60]);
+    // private testIfLODLevelsAreAvailable() {
+    u(this, "_sphere", new et());
+    u(this, "_tempBox", new ke());
+    u(this, "_tempBox2", new ke());
+    u(this, "tempMatrix", new $e());
+    u(this, "_tempWorldPosition", new V());
+    u(this, "_tempBoxSize", new V());
+    u(this, "_tempBox2Size", new V());
+    this.renderer = e, this.context = { ...t };
+  }
+  /** @internal */
+  static getObjectLODState(e) {
+    return e[Se];
+  }
+  static addPlugin(e) {
+    Q.push(e);
+  }
+  static removePlugin(e) {
+    const t = Q.indexOf(e);
+    t >= 0 && Q.splice(t, 1);
+  }
+  /**
+   * Gets the LODsManager for the given renderer. If the LODsManager does not exist yet, it will be created.  
+   * @param renderer The renderer to get the LODsManager for.
+   * @returns The LODsManager instance.
+   */
+  static get(e, t) {
+    if (e[be])
+      return console.debug("[gltf-progressive] LODsManager already exists for this renderer"), e[be];
+    const s = new y(e, {
+      engine: "unknown",
+      ...t
+    });
+    return e[be] = s, s;
+  }
+  /** @deprecated use static `LODsManager.addPlugin()` method. This getter will be removed in later versions */
+  get plugins() {
+    return Q;
+  }
+  /**
+   * Call to await LODs loading during the next render cycle.
+   */
+  awaitLoading(e) {
+    const t = this._promiseGroupIds++, s = new me(L(this, j), { ...e });
+    this._newPromiseGroups.push(s);
+    const n = performance.now();
+    return s.ready.finally(() => {
+      const r = this._newPromiseGroups.indexOf(s);
+      r >= 0 && (this._newPromiseGroups.splice(r, 1), ft() && performance.measure("LODsManager:awaitLoading", {
+        start: n,
+        detail: { id: t, name: e == null ? void 0 : e.name, awaited: s.awaitedCount, resolved: s.resolvedCount }
+      }));
+    }), s.ready;
+  }
+  _postprocessPromiseGroups() {
+    if (this._newPromiseGroups.length !== 0)
+      for (let e = this._newPromiseGroups.length - 1; e >= 0; e--)
+        this._newPromiseGroups[e].update(L(this, j));
+  }
+  addEventListener(e, t) {
+    e === "changed" && this._lodchangedlisteners.push(t);
+  }
+  removeEventListener(e, t) {
+    if (e === "changed") {
+      const s = this._lodchangedlisteners.indexOf(t);
+      s >= 0 && this._lodchangedlisteners.splice(s, 1);
+    }
+  }
+  /**
+   * Enable the LODsManager. This will replace the render method of the renderer with a method that updates the LODs.
+   */
+  enable() {
+    if (L(this, X)) return;
+    console.debug("[gltf-progressive] Enabling LODsManager for renderer");
+    let e = 0;
+    z(this, X, this.renderer.render);
+    const t = this;
+    ze(this.renderer), this.renderer.render = function(s, n) {
+      const r = t.renderer.getRenderTarget();
+      (r == null || "isXRRenderTarget" in r && r.isXRRenderTarget) && (e = 0, z(t, j, L(t, j) + 1), z(t, re, L(t, we).getDelta()), z(t, _e, L(t, _e) + L(t, re)), t._fpsBuffer.shift(), t._fpsBuffer.push(1 / L(t, re)), z(t, K, t._fpsBuffer.reduce((a, l) => a + l) / t._fpsBuffer.length), I && L(t, j) % 200 === 0 && console.log("FPS", Math.round(L(t, K)), "Interval:", L(t, $)));
+      const i = e++;
+      L(t, X).call(this, s, n), t.onAfterRender(s, n, i);
+    };
+  }
+  disable() {
+    L(this, X) && (console.debug("[gltf-progressive] Disabling LODsManager for renderer"), this.renderer.render = L(this, X), z(this, X, void 0));
+  }
+  update(e, t) {
+    this.internalUpdate(e, t);
+  }
+  onAfterRender(e, t, s) {
+    if (this.pause) return;
+    const r = this.renderer.renderLists.get(e, 0).opaque;
+    let i = !0;
+    if (r.length === 1) {
+      const a = r[0].material;
+      (a.name === "EffectMaterial" || a.name === "CopyShader") && (i = !1);
+    }
+    if ((t.parent && t.parent.type === "CubeCamera" || s >= 1 && t.type === "OrthographicCamera") && (i = !1), i) {
+      if (xt || (this.updateInterval === "auto" ? L(this, K) < 40 && L(this, $) < 10 ? (z(this, $, L(this, $) + 1), I && console.warn("↓ Reducing LOD updates", L(this, $), L(this, K).toFixed(0))) : L(this, K) >= 60 && L(this, $) > 1 && (z(this, $, L(this, $) - 1), I && console.warn("↑ Increasing LOD updates", L(this, $), L(this, K).toFixed(0))) : z(this, $, this.updateInterval), L(this, $) > 0 && L(this, j) % L(this, $) != 0))
+        return;
+      this.internalUpdate(e, t), this._postprocessPromiseGroups();
+    }
+  }
+  /**
+   * Update LODs in a scene
+   */
+  internalUpdate(e, t) {
+    var l, c;
+    const s = this.renderer.renderLists.get(e, 0), n = s.opaque;
+    this.projectionScreenMatrix.multiplyMatrices(t.projectionMatrix, t.matrixWorldInverse);
+    const r = this.targetTriangleDensity;
+    for (const d of n) {
+      if (d.material && (((l = d.geometry) == null ? void 0 : l.type) === "BoxGeometry" || ((c = d.geometry) == null ? void 0 : c.type) === "BufferGeometry") && (d.material.name === "SphericalGaussianBlur" || d.material.name == "BackgroundCubeMaterial" || d.material.name === "CubemapFromEquirect" || d.material.name === "EquirectangularToCubeUV")) {
+        I && (d.material["NEEDLE_PROGRESSIVE:IGNORE-WARNING"] || (d.material["NEEDLE_PROGRESSIVE:IGNORE-WARNING"] = !0, console.warn("Ignoring skybox or BLIT object", d, d.material.name, d.material.type)));
+        continue;
+      }
+      switch (d.material.type) {
+        case "LineBasicMaterial":
+        case "LineDashedMaterial":
+        case "PointsMaterial":
+        case "ShadowMaterial":
+        case "MeshDistanceMaterial":
+        case "MeshDepthMaterial":
+          continue;
+      }
+      if (I === "color" && d.material && !d.object.progressive_debug_color) {
+        d.object.progressive_debug_color = !0;
+        const f = Math.random() * 16777215, D = new Ze({ color: f });
+        d.object.material = D;
+      }
+      const p = d.object;
+      (p instanceof te || p.isMesh) && this.updateLODs(e, t, p, r);
+    }
+    const i = s.transparent;
+    for (const d of i) {
+      const p = d.object;
+      (p instanceof te || p.isMesh) && this.updateLODs(e, t, p, r);
+    }
+    const a = s.transmissive;
+    for (const d of a) {
+      const p = d.object;
+      (p instanceof te || p.isMesh) && this.updateLODs(e, t, p, r);
+    }
+  }
+  /** Update the LOD levels for the renderer. */
+  updateLODs(e, t, s, n) {
+    var a, l;
+    s.userData || (s.userData = {});
+    let r = s[Se];
+    if (r || (r = new wt(), s[Se] = r), r.frames++ < 2)
+      return;
+    for (const c of Q)
+      (a = c.onBeforeUpdateLOD) == null || a.call(c, this.renderer, e, t, s);
+    const i = y.overrideGlobalLodLevel !== void 0 ? y.overrideGlobalLodLevel : ee;
+    i >= 0 ? (G.mesh_lod = i, G.texture_lod = i) : (this.calculateLodLevel(t, s, r, n, G), G.mesh_lod = Math.round(G.mesh_lod), G.texture_lod = Math.round(G.texture_lod)), G.mesh_lod >= 0 && this.loadProgressiveMeshes(s, G.mesh_lod), s.material && G.texture_lod >= 0 && this.loadProgressiveTextures(s.material, G.texture_lod), x && s.material && !s.isGizmo && Ve(s.material);
+    for (const c of Q)
+      (l = c.onAfterUpdatedLOD) == null || l.call(c, this.renderer, e, t, s, G);
+    r.lastLodLevel_Mesh = G.mesh_lod, r.lastLodLevel_Texture = G.texture_lod;
+  }
+  /** Load progressive textures for the given material
+   * @param material the material to load the textures for
+   * @param level the LOD level to load. Level 0 is the best quality, higher levels are lower quality
+   * @returns Promise with true if the LOD was loaded, false if not
+   */
+  loadProgressiveTextures(e, t) {
+    if (!e) return;
+    if (Array.isArray(e)) {
+      for (const r of e)
+        this.loadProgressiveTextures(r, t);
+      return;
+    }
+    let s = !1;
+    (e[H] === void 0 || t < e[H]) && (s = !0);
+    const n = e["DEBUG:LOD"];
+    if (n != null && (s = e[H] != n, t = n), s) {
+      e[H] = t;
+      const r = N.assignTextureLOD(e, t).then((i) => {
+        this._lodchangedlisteners.forEach((a) => a({ type: "texture", level: t, object: e }));
+      });
+      me.addPromise("texture", e, r, this._newPromiseGroups);
+    }
+  }
+  /** Load progressive meshes for the given mesh
+   * @param mesh the mesh to load the LOD for
+   * @param index the index of the mesh if it's part of a group
+   * @param level the LOD level to load. Level 0 is the best quality, higher levels are lower quality
+   * @returns Promise with true if the LOD was loaded, false if not
+   */
+  loadProgressiveMeshes(e, t) {
+    if (!e) return Promise.resolve(null);
+    let s = e[H] !== t;
+    const n = e["DEBUG:LOD"];
+    if (n != null && (s = e[H] != n, t = n), s) {
+      e[H] = t;
+      const r = e.geometry, i = N.assignMeshLOD(e, t).then((a) => (a && e[H] == t && r != e.geometry && this._lodchangedlisteners.forEach((l) => l({ type: "mesh", level: t, object: e })), a));
+      return me.addPromise("mesh", e, i, this._newPromiseGroups), i;
+    }
+    return Promise.resolve(null);
+  }
+  static isInside(e, t) {
+    const s = e.min, n = e.max, r = (s.x + n.x) * 0.5, i = (s.y + n.y) * 0.5;
+    return this._tempPtInside.set(r, i, s.z).applyMatrix4(t).z < 0;
+  }
+  calculateLodLevel(e, t, s, n, r) {
+    var b, E, J;
+    if (!t) {
+      r.mesh_lod = -1, r.texture_lod = -1;
+      return;
+    }
+    if (!e) {
+      r.mesh_lod = -1, r.texture_lod = -1;
+      return;
+    }
+    let a = 10 + 1, l = !1;
+    if (I && t["DEBUG:LOD"] != null)
+      return t["DEBUG:LOD"];
+    const c = (b = N.getMeshLODExtension(t.geometry)) == null ? void 0 : b.lods, d = N.getPrimitiveIndex(t.geometry), p = c && c.length > 0, f = N.getMaterialMinMaxLODsCount(t.material), D = (f == null ? void 0 : f.min_count) != 1 / 0 && f.min_count > 0 && f.max_count > 0;
+    if (!p && !D) {
+      r.mesh_lod = 0, r.texture_lod = 0;
+      return;
+    }
+    p || (l = !0, a = 0);
+    const O = this.renderer.domElement.clientHeight || this.renderer.domElement.height;
+    let P = t.geometry.boundingBox;
+    if (t.type === "SkinnedMesh") {
+      const h = t;
+      if (!h.boundingBox)
+        h.computeBoundingBox();
+      else if (this.skinnedMeshAutoUpdateBoundsInterval > 0) {
+        if (!h[y.$skinnedMeshBoundsOffset]) {
+          const T = y.skinnedMeshBoundsFrameOffsetCounter++;
+          h[y.$skinnedMeshBoundsOffset] = T;
+        }
+        const w = h[y.$skinnedMeshBoundsOffset];
+        if ((s.frames + w) % this.skinnedMeshAutoUpdateBoundsInterval === 0) {
+          const T = de(h), F = h.geometry;
+          T && (h.geometry = T), h.computeBoundingBox(), h.geometry = F;
+        }
+      }
+      P = h.boundingBox;
+    }
+    if (P) {
+      const h = e;
+      if (t.geometry.attributes.color && t.geometry.attributes.color.count < 100 && t.geometry.boundingSphere) {
+        this._sphere.copy(t.geometry.boundingSphere), this._sphere.applyMatrix4(t.matrixWorld);
+        const g = e.getWorldPosition(this._tempWorldPosition);
+        if (this._sphere.containsPoint(g)) {
+          r.mesh_lod = 0, r.texture_lod = 0;
+          return;
+        }
+      }
+      if (this._tempBox.copy(P), this._tempBox.applyMatrix4(t.matrixWorld), h.isPerspectiveCamera && y.isInside(this._tempBox, this.projectionScreenMatrix)) {
+        r.mesh_lod = 0, r.texture_lod = 0;
+        return;
+      }
+      if (this._tempBox.applyMatrix4(this.projectionScreenMatrix), this.renderer.xr.enabled && h.isPerspectiveCamera && h.fov > 70) {
+        const g = this._tempBox.min, M = this._tempBox.max;
+        let C = g.x, B = g.y, U = M.x, ie = M.y;
+        const ce = 2, Me = 1.5, fe = (g.x + M.x) * 0.5, he = (g.y + M.y) * 0.5;
+        C = (C - fe) * ce + fe, B = (B - he) * ce + he, U = (U - fe) * ce + fe, ie = (ie - he) * ce + he;
+        const Ke = C < 0 && U > 0 ? 0 : Math.min(Math.abs(g.x), Math.abs(M.x)), Ye = B < 0 && ie > 0 ? 0 : Math.min(Math.abs(g.y), Math.abs(M.y)), De = Math.max(Ke, Ye);
+        s.lastCentrality = (Me - De) * (Me - De) * (Me - De);
+      } else
+        s.lastCentrality = 1;
+      const w = this._tempBox.getSize(this._tempBoxSize);
+      w.multiplyScalar(0.5), screen.availHeight > 0 && O > 0 && w.multiplyScalar(O / screen.availHeight), e.isPerspectiveCamera ? w.x *= e.aspect : e.isOrthographicCamera;
+      const T = e.matrixWorldInverse, F = this._tempBox2;
+      F.copy(P), F.applyMatrix4(t.matrixWorld), F.applyMatrix4(T);
+      const S = F.getSize(this._tempBox2Size), Z = Math.max(S.x, S.y);
+      if (Math.max(w.x, w.y) != 0 && Z != 0 && (w.z = S.z / Math.max(S.x, S.y) * Math.max(w.x, w.y)), s.lastScreenCoverage = Math.max(w.x, w.y, w.z), s.lastScreenspaceVolume.copy(w), s.lastScreenCoverage *= s.lastCentrality, I && y.debugDrawLine) {
+        const g = this.tempMatrix.copy(this.projectionScreenMatrix);
+        g.invert();
+        const M = y.corner0, C = y.corner1, B = y.corner2, U = y.corner3;
+        M.copy(this._tempBox.min), C.copy(this._tempBox.max), C.x = M.x, B.copy(this._tempBox.max), B.y = M.y, U.copy(this._tempBox.max);
+        const ie = (M.z + U.z) * 0.5;
+        M.z = C.z = B.z = U.z = ie, M.applyMatrix4(g), C.applyMatrix4(g), B.applyMatrix4(g), U.applyMatrix4(g), y.debugDrawLine(M, C, 255), y.debugDrawLine(M, B, 255), y.debugDrawLine(C, U, 255), y.debugDrawLine(B, U, 255);
+      }
+      let v = 999;
+      if (c && s.lastScreenCoverage > 0)
+        for (let g = 0; g < c.length; g++) {
+          const M = c[g];
+          if ((((E = M.densities) == null ? void 0 : E[d]) || M.density || 1e-5) / s.lastScreenCoverage < n) {
+            v = g;
+            break;
+          }
+        }
+      v < a && (a = v, l = !0);
+    }
+    if (l ? r.mesh_lod = a : r.mesh_lod = s.lastLodLevel_Mesh, I && r.mesh_lod != s.lastLodLevel_Mesh) {
+      const w = c == null ? void 0 : c[r.mesh_lod];
+      w && console.log(`Mesh LOD changed: ${s.lastLodLevel_Mesh} → ${r.mesh_lod} (${w.density.toFixed(0)}) - ${t.name}`);
+    }
+    if (D) {
+      const h = "saveData" in globalThis.navigator && globalThis.navigator.saveData === !0;
+      if (s.lastLodLevel_Texture < 0) {
+        if (r.texture_lod = f.max_count - 1, I) {
+          const w = f.lods[f.max_count - 1];
+          I && console.log(`First Texture LOD ${r.texture_lod} (${w.max_height}px) - ${t.name}`);
+        }
+      } else {
+        const w = s.lastScreenspaceVolume.x + s.lastScreenspaceVolume.y + s.lastScreenspaceVolume.z;
+        let T = s.lastScreenCoverage * 4;
+        ((J = this.context) == null ? void 0 : J.engine) === "model-viewer" && (T *= 1.5);
+        const S = O / window.devicePixelRatio * T;
+        let Z = !1;
+        for (let A = f.lods.length - 1; A >= 0; A--) {
+          const v = f.lods[A];
+          if (!(h && v.max_height >= 2048) && !(ct() && v.max_height > 4096) && (v.max_height > S || !Z && A === 0)) {
+            if (Z = !0, r.texture_lod = A, r.texture_lod < s.lastLodLevel_Texture) {
+              const m = v.max_height;
+              I && console.log(`Texture LOD changed: ${s.lastLodLevel_Texture} → ${r.texture_lod} = ${m}px 
+Screensize: ${S.toFixed(0)}px, Coverage: ${(100 * s.lastScreenCoverage).toFixed(2)}%, Volume ${w.toFixed(1)} 
+${t.name}`);
+            }
+            break;
+          }
+        }
+      }
+    } else
+      r.texture_lod = 0;
+  }
+}, $ = new WeakMap(), X = new WeakMap(), we = new WeakMap(), j = new WeakMap(), re = new WeakMap(), _e = new WeakMap(), K = new WeakMap(), /** 
+ * Assign a function to draw debug lines for the LODs. This function will be called with the start and end position of the line and the color of the line when the `debugprogressive` query parameter is set.
+ */
+u(y, "debugDrawLine"), /**
+ * Force override the LOD level for all objects in the scene
+ */
+u(y, "overrideGlobalLodLevel"), u(y, "corner0", new V()), u(y, "corner1", new V()), u(y, "corner2", new V()), u(y, "corner3", new V()), u(y, "_tempPtInside", new V()), u(y, "skinnedMeshBoundsFrameOffsetCounter", 0), u(y, "$skinnedMeshBoundsOffset", Symbol("gltf-progressive-skinnedMeshBoundsOffset")), y);
+class wt {
+  constructor() {
+    u(this, "frames", 0);
+    u(this, "lastLodLevel_Mesh", -1);
+    u(this, "lastLodLevel_Texture", -1);
+    u(this, "lastScreenCoverage", 0);
+    u(this, "lastScreenspaceVolume", new V());
+    u(this, "lastCentrality", 0);
+  }
+}
+const Ee = Symbol("NEEDLE_mesh_lod"), ge = Symbol("NEEDLE_texture_lod");
+let le = null;
+function We() {
+  const o = _t();
+  o && (o.mapURLs(function(e) {
+    return Ie(), e;
+  }), Ie(), le == null || le.disconnect(), le = new MutationObserver((e) => {
+    e.forEach((t) => {
+      t.addedNodes.forEach((s) => {
+        s instanceof HTMLElement && s.tagName.toLowerCase() === "model-viewer" && Xe(s);
+      });
+    });
+  }), le.observe(document, { childList: !0, subtree: !0 }));
+}
+function _t() {
+  if (typeof customElements > "u") return null;
+  const o = customElements.get("model-viewer");
+  return o || (customElements.whenDefined("model-viewer").then(() => {
+    console.debug("[gltf-progressive] model-viewer defined"), We();
+  }), null);
+}
+function Ie() {
+  if (typeof document > "u") return;
+  document.querySelectorAll("model-viewer").forEach((e) => {
+    Xe(e);
+  });
+}
+const Re = /* @__PURE__ */ new WeakSet();
+let Mt = 0;
+function Xe(o) {
+  if (!o || Re.has(o))
+    return null;
+  Re.add(o), console.debug("[gltf-progressive] found new model-viewer..." + ++Mt + `
+`, o.getAttribute("src"));
+  let e = null, t = null, s = null;
+  for (let n = o; n != null; n = Object.getPrototypeOf(n)) {
+    const r = Object.getOwnPropertySymbols(n), i = r.find((c) => c.toString() == "Symbol(renderer)"), a = r.find((c) => c.toString() == "Symbol(scene)"), l = r.find((c) => c.toString() == "Symbol(needsRender)");
+    !e && i != null && (e = o[i].threeRenderer), !t && a != null && (t = o[a]), !s && l != null && (s = o[l]);
+  }
+  if (e && t) {
+    let n = function() {
+      if (s) {
+        let i = 0, a = setInterval(() => {
+          if (i++ > 5) {
+            clearInterval(a);
+            return;
+          }
+          s == null || s.call(o);
+        }, 300);
+      }
+    };
+    console.debug("[gltf-progressive] setup model-viewer");
+    const r = xe.get(e, { engine: "model-viewer" });
+    return xe.addPlugin(new Dt()), r.enable(), r.addEventListener("changed", () => {
+      s == null || s.call(o);
+    }), o.addEventListener("model-visibility", (i) => {
+      i.detail.visible && (s == null || s.call(o));
+    }), o.addEventListener("load", () => {
+      n();
+    }), () => {
+      r.disable();
+    };
+  }
+  return null;
+}
+class Dt {
+  constructor() {
+    u(this, "_didWarnAboutMissingUrl", !1);
+  }
+  onBeforeUpdateLOD(e, t, s, n) {
+    this.tryParseMeshLOD(t, n), this.tryParseTextureLOD(t, n);
+  }
+  getUrl(e) {
+    if (!e)
+      return null;
+    let t = e.getAttribute("src");
+    return t || (t = e.src), t || (this._didWarnAboutMissingUrl || console.warn("No url found in modelviewer", e), this._didWarnAboutMissingUrl = !0), t;
+  }
+  tryGetCurrentGLTF(e) {
+    return e._currentGLTF;
+  }
+  tryGetCurrentModelViewer(e) {
+    return e.element;
+  }
+  tryParseTextureLOD(e, t) {
+    if (t[ge] == !0) return;
+    t[ge] = !0;
+    const s = this.tryGetCurrentGLTF(e), n = this.tryGetCurrentModelViewer(e), r = this.getUrl(n);
+    if (r && s && t.material) {
+      let i = function(l) {
+        var d, p, f;
+        if (l[ge] == !0) return;
+        l[ge] = !0, l.userData && (l.userData.LOD = -1);
+        const c = Object.keys(l);
+        for (let D = 0; D < c.length; D++) {
+          const O = c[D], P = l[O];
+          if ((P == null ? void 0 : P.isTexture) === !0) {
+            const b = (p = (d = P.userData) == null ? void 0 : d.associations) == null ? void 0 : p.textures;
+            if (b == null) continue;
+            const E = s.parser.json.textures[b];
+            if (!E) {
+              console.warn("Texture data not found for texture index " + b);
+              continue;
+            }
+            if ((f = E == null ? void 0 : E.extensions) != null && f[W]) {
+              const J = E.extensions[W];
+              J && r && N.registerTexture(r, P, J.lods.length, b, J);
+            }
+          }
+        }
+      };
+      const a = t.material;
+      if (Array.isArray(a)) for (const l of a) i(l);
+      else i(a);
+    }
+  }
+  tryParseMeshLOD(e, t) {
+    var i, a;
+    if (t[Ee] == !0) return;
+    t[Ee] = !0;
+    const s = this.tryGetCurrentModelViewer(e), n = this.getUrl(s);
+    if (!n)
+      return;
+    const r = (a = (i = t.userData) == null ? void 0 : i.gltfExtensions) == null ? void 0 : a[W];
+    if (r && n) {
+      const l = t.uuid;
+      N.registerMesh(n, l, t, 0, r.lods.length, r);
+    }
+  }
+}
+function vt(o, e, t, s) {
+  ze(e), Ne(t), qe(t, {
+    progressive: !0,
+    ...s == null ? void 0 : s.hints
+  }), t.register((r) => new N(r, o));
+  const n = xe.get(e);
+  return (s == null ? void 0 : s.enableLODsManager) !== !1 && n.enable(), n;
+}
+We();
+if (!gt) {
+  const o = {
+    gltfProgressive: {
+      useNeedleProgressive: vt,
+      LODsManager: xe,
+      configureLoader: qe,
+      getRaycastMesh: de,
+      useRaycastMeshes: mt
+    }
+  };
+  if (!globalThis.Needle)
+    globalThis.Needle = o;
+  else
+    for (const e in o)
+      globalThis.Needle[e] = o[e];
+}
+export {
+  xe as LODsManager,
+  N as NEEDLE_progressive,
+  Ne as addDracoAndKTX2Loaders,
+  qe as configureLoader,
+  ze as createLoaders,
+  de as getRaycastMesh,
+  at as setDracoDecoderLocation,
+  lt as setKTX2TranscoderLocation
+};