npm - @needle-tools/gltf-progressive - Versions diffs - 3.4.0-next.dbcee85 → 3.4.0-next.ed30751 - Mend

@needle-tools/gltf-progressive 3.4.0-next.dbcee85 → 3.4.0-next.ed30751

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (11) hide show

package/gltf-progressive.js CHANGED Viewed

@@ -1,90 +1,90 @@
-import { BufferGeometry as E, Mesh as V, Box3 as he, Vector3 as C, Sphere as De, CompressedTexture as Be, Texture as F, Matrix3 as Ge, InterleavedBuffer as Fe, InterleavedBufferAttribute as We, BufferAttribute as Ue, TextureLoader as ze, Matrix4 as _e, Clock as Ne, MeshStandardMaterial as qe } from "three";
-import { GLTFLoader as ye } from "three/examples/jsm/loaders/GLTFLoader.js";
+import { BufferGeometry as E, Mesh as X, Box3 as ge, Vector3 as R, Sphere as Se, CompressedTexture as Ge, Texture as F, Matrix3 as Fe, InterleavedBuffer as We, InterleavedBufferAttribute as Ue, BufferAttribute as ze, TextureLoader as qe, Matrix4 as ve, Clock as Ne, MeshStandardMaterial as Ve } from "three";
+import { GLTFLoader as xe } from "three/examples/jsm/loaders/GLTFLoader.js";
 import { MeshoptDecoder as Ee } from "three/examples/jsm/libs/meshopt_decoder.module.js";
-import { DRACOLoader as Ve } from "three/examples/jsm/loaders/DRACOLoader.js";
-import { KTX2Loader as Xe } from "three/examples/jsm/loaders/KTX2Loader.js";
-const je = "";
-globalThis.GLTF_PROGRESSIVE_VERSION = je;
+import { DRACOLoader as Xe } from "three/examples/jsm/loaders/DRACOLoader.js";
+import { KTX2Loader as je } from "three/examples/jsm/loaders/KTX2Loader.js";
+const Ke = "";
+globalThis.GLTF_PROGRESSIVE_VERSION = Ke;
 console.debug("[gltf-progressive] version -");
-let R = "https://www.gstatic.com/draco/versioned/decoders/1.5.7/", X = "https://cdn.needle.tools/static/three/0.179.1/basis2/";
-const Ye = R, Ke = X, Oe = new URL(R + "draco_decoder.js");
-Oe.searchParams.append("range", "true");
-fetch(Oe, {
+let B = "https://www.gstatic.com/draco/versioned/decoders/1.5.7/", j = "https://cdn.needle.tools/static/three/0.179.1/basis2/";
+const Ye = B, He = j, Pe = new URL(B + "draco_decoder.js");
+Pe.searchParams.append("range", "true");
+fetch(Pe, {
   method: "GET",
   headers: {
     Range: "bytes=0-1"
   }
-}).catch((i) => {
-  console.debug(`Failed to fetch remote Draco decoder from ${R} (offline: ${typeof navigator < "u" ? navigator.onLine : "unknown"})`), R === Ye && Qe("./include/draco/"), X === Ke && Je("./include/ktx2/");
+}).catch((n) => {
+  console.debug(`Failed to fetch remote Draco decoder from ${B} (offline: ${typeof navigator < "u" ? navigator.onLine : "unknown"})`), B === Ye && Je("./include/draco/"), j === He && Ze("./include/ktx2/");
 }).finally(() => {
-  Pe();
+  Ce();
 });
-const He = () => ({
-  dracoDecoderPath: R,
-  ktx2TranscoderPath: X
+const Qe = () => ({
+  dracoDecoderPath: B,
+  ktx2TranscoderPath: j
 });
-function Qe(i) {
-  R = i, A && A[ge] != R ? (console.debug("Updating Draco decoder path to " + i), A[ge] = R, A.setDecoderPath(R), A.preload()) : console.debug("Setting Draco decoder path to " + i);
+function Je(n) {
+  B = n, k && k[pe] != B ? (console.debug("Updating Draco decoder path to " + n), k[pe] = B, k.setDecoderPath(B), k.preload()) : console.debug("Setting Draco decoder path to " + n);
 }
-function Je(i) {
-  X = i, $ && $.transcoderPath != X ? (console.debug("Updating KTX2 transcoder path to " + i), $.setTranscoderPath(X), $.init()) : console.debug("Setting KTX2 transcoder path to " + i);
+function Ze(n) {
+  j = n, G && G.transcoderPath != j ? (console.debug("Updating KTX2 transcoder path to " + n), G.setTranscoderPath(j), G.init()) : console.debug("Setting KTX2 transcoder path to " + n);
 }
-function xe(i) {
-  return Pe(), i ? $.detectSupport(i) : i !== null && console.warn("No renderer provided to detect ktx2 support - loading KTX2 textures might fail"), { dracoLoader: A, ktx2Loader: $, meshoptDecoder: oe };
+function we(n) {
+  return Ce(), n ? G.detectSupport(n) : n !== null && console.warn("No renderer provided to detect ktx2 support - loading KTX2 textures might fail"), { dracoLoader: k, ktx2Loader: G, meshoptDecoder: oe };
 }
-function Se(i) {
-  i.dracoLoader || i.setDRACOLoader(A), i.ktx2Loader || i.setKTX2Loader($), i.meshoptDecoder || i.setMeshoptDecoder(oe);
+function Te(n) {
+  n.dracoLoader || n.setDRACOLoader(k), n.ktx2Loader || n.setKTX2Loader(G), n.meshoptDecoder || n.setMeshoptDecoder(oe);
 }
-const ge = /* @__PURE__ */ Symbol("dracoDecoderPath");
-let A, oe, $;
-function Pe() {
-  A || (A = new Ve(), A[ge] = R, A.setDecoderPath(R), A.setDecoderConfig({ type: "js" }), A.preload()), $ || ($ = new Xe(), $.setTranscoderPath(X), $.init()), oe || (oe = Ee);
+const pe = /* @__PURE__ */ Symbol("dracoDecoderPath");
+let k, oe, G;
+function Ce() {
+  k || (k = new Xe(), k[pe] = B, k.setDecoderPath(B), k.setDecoderConfig({ type: "js" }), k.preload()), G || (G = new je(), G.setTranscoderPath(j), G.init()), oe || (oe = Ee);
 }
-const pe = /* @__PURE__ */ new WeakMap();
-function Te(i, t) {
-  let e = pe.get(i);
-  e ? e = Object.assign(e, t) : e = t, pe.set(i, e);
+const me = /* @__PURE__ */ new WeakMap();
+function Ae(n, t) {
+  let e = me.get(n);
+  e ? e = Object.assign(e, t) : e = t, me.set(n, e);
 }
-const Ze = ye.prototype.load;
-function et(...i) {
-  const t = pe.get(this);
-  let e = i[0];
+const et = xe.prototype.load;
+function tt(...n) {
+  const t = me.get(this);
+  let e = n[0];
   const s = new URL(e, window.location.href);
   if (s.hostname.endsWith("needle.tools")) {
-    const r = t?.progressive !== void 0 ? t.progressive : !0, n = t?.usecase ? t.usecase : "default";
-    r ? this.requestHeader.Accept = `*/*;progressive=allowed;usecase=${n}` : this.requestHeader.Accept = `*/*;usecase=${n}`, e = s.toString();
+    const i = t?.progressive !== void 0 ? t.progressive : !0, o = t?.usecase ? t.usecase : "default";
+    i ? this.requestHeader.Accept = `*/*;progressive=allowed;usecase=${o}` : this.requestHeader.Accept = `*/*;usecase=${o}`, e = s.toString();
   }
-  return i[0] = e, Ze?.call(this, ...i);
+  return n[0] = e, et?.call(this, ...n);
 }
-ye.prototype.load = et;
-j("debugprogressive");
-function j(i) {
+xe.prototype.load = tt;
+N("debugprogressive");
+function N(n) {
   if (typeof window > "u") return !1;
-  const e = new URL(window.location.href).searchParams.get(i);
+  const e = new URL(window.location.href).searchParams.get(n);
   return e == null || e === "0" || e === "false" ? !1 : e === "" ? !0 : e;
 }
-function tt(i, t) {
-  if (t === void 0 || i === void 0 || t.startsWith("./") || t.startsWith("http") || t.startsWith("data:") || t.startsWith("blob:"))
+function st(n, t) {
+  if (t === void 0 || n === void 0 || t.startsWith("./") || t.startsWith("http") || t.startsWith("data:") || t.startsWith("blob:"))
     return t;
-  const e = i.lastIndexOf("/");
+  const e = n.lastIndexOf("/");
   if (e >= 0) {
-    const s = i.substring(0, e + 1);
+    const s = n.substring(0, e + 1);
     for (; s.endsWith("/") && t.startsWith("/"); ) t = t.substring(1);
     return s + t;
   }
   return t;
 }
-function Ae() {
-  return K !== void 0 || (K = /iPhone|iPad|iPod|Android|IEMobile/i.test(navigator.userAgent), j("debugprogressive") && console.log("[glTF Progressive]: isMobileDevice", K)), K;
+function _e() {
+  return H !== void 0 || (H = /iPhone|iPad|iPod|Android|IEMobile/i.test(navigator.userAgent), N("debugprogressive") && console.log("[glTF Progressive]: isMobileDevice", H)), H;
 }
-let K;
-function Le() {
+let H;
+function be() {
   if (typeof window > "u") return !1;
-  const i = new URL(window.location.href), t = i.hostname === "localhost" || /^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/.test(i.hostname);
-  return i.hostname === "127.0.0.1" || t;
+  const n = new URL(window.location.href), t = n.hostname === "localhost" || /^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/.test(n.hostname);
+  return n.hostname === "127.0.0.1" || t;
 }
-class st {
-  constructor(t = 100, e = {}) {
+class rt {
+  constructor(t, e = {}) {
     this.maxConcurrent = t, this.debug = e.debug ?? !1, window.requestAnimationFrame(this.tick);
   }
   _running = /* @__PURE__ */ new Map();
@@ -110,87 +110,99 @@ class st {
     const t = this.maxConcurrent - this._running.size;
     for (let e = 0; e < t && this._queue.length > 0; e++) {
       this.debug && console.debug(`[PromiseQueue]: Running ${this._running.size} promises, waiting for ${this._queue.length} more.`);
-      const { key: s, resolve: o } = this._queue.shift();
-      o({
-        use: (r) => this.add(s, r)
+      const { key: s, resolve: r } = this._queue.shift();
+      r({
+        use: (i) => this.add(s, i)
       });
     }
   }
 }
-const rt = typeof window > "u" && typeof document > "u", me = /* @__PURE__ */ Symbol("needle:raycast-mesh");
-function Z(i) {
-  return i?.[me] instanceof E ? i[me] : null;
+function it(n) {
+  const t = n.image?.width ?? 0, e = n.image?.height ?? 0, s = n.image?.depth ?? 1, r = Math.floor(Math.log2(Math.max(t, e, s))) + 1, i = ot(n);
+  return t * e * s * i * (1 - Math.pow(0.25, r)) / (1 - 0.25);
+}
+function ot(n) {
+  let t = 4;
+  const e = n.format;
+  e === 1024 || e === 1025 ? t = 1 : e === 1026 || e === 1027 ? t = 2 : e === 1022 || e === 1029 ? t = 3 : (e === 1023 || e === 1033) && (t = 4);
+  let s = 1;
+  const r = n.type;
+  return r === 1009 || r === 1010 ? s = 1 : r === 1011 || r === 1012 ? s = 2 : r === 1013 || r === 1014 || r === 1015 ? s = 4 : r === 1016 && (s = 2), t * s;
 }
-function ot(i, t) {
-  if ((i.type === "Mesh" || i.type === "SkinnedMesh") && !Z(i)) {
-    const s = it(t);
-    s.userData = { isRaycastMesh: !0 }, i[me] = s;
+const nt = typeof window > "u" && typeof document > "u", ye = /* @__PURE__ */ Symbol("needle:raycast-mesh");
+function ee(n) {
+  return n?.[ye] instanceof E ? n[ye] : null;
+}
+function at(n, t) {
+  if ((n.type === "Mesh" || n.type === "SkinnedMesh") && !ee(n)) {
+    const s = ut(t);
+    s.userData = { isRaycastMesh: !0 }, n[ye] = s;
   }
 }
-function nt(i = !0) {
-  if (i) {
-    if (H) return;
-    const t = H = V.prototype.raycast;
-    V.prototype.raycast = function(e, s) {
-      const o = this, r = Z(o);
-      let n;
-      r && o.isMesh && (n = o.geometry, o.geometry = r), t.call(this, e, s), n && (o.geometry = n);
+function lt(n = !0) {
+  if (n) {
+    if (Q) return;
+    const t = Q = X.prototype.raycast;
+    X.prototype.raycast = function(e, s) {
+      const r = this, i = ee(r);
+      let o;
+      i && r.isMesh && (o = r.geometry, r.geometry = i), t.call(this, e, s), o && (r.geometry = o);
     };
   } else {
-    if (!H) return;
-    V.prototype.raycast = H, H = null;
+    if (!Q) return;
+    X.prototype.raycast = Q, Q = null;
   }
 }
-let H = null;
-function it(i) {
+let Q = null;
+function ut(n) {
   const t = new E();
-  for (const e in i.attributes)
-    t.setAttribute(e, i.getAttribute(e));
-  return t.setIndex(i.getIndex()), t;
+  for (const e in n.attributes)
+    t.setAttribute(e, n.getAttribute(e));
+  return t.setIndex(n.getIndex()), t;
 }
-const z = new Array(), h = j("debugprogressive");
-let J, q = -1;
+const q = new Array(), h = N("debugprogressive");
+let Z, V = -1;
 if (h) {
-  let i = function() {
-    q += 1, q >= t && (q = -1), console.log(`Toggle LOD level [${q}]`);
+  let n = function() {
+    V += 1, V >= t && (V = -1), console.log(`Toggle LOD level [${V}]`);
   }, t = 6;
   window.addEventListener("keyup", (e) => {
-    e.key === "p" && i(), e.key === "w" && (J = !J, console.log(`Toggle wireframe [${J}]`));
+    e.key === "p" && n(), e.key === "w" && (Z = !Z, console.log(`Toggle wireframe [${Z}]`));
     const s = parseInt(e.key);
-    !isNaN(s) && s >= 0 && (q = s, console.log(`Set LOD level to [${q}]`));
+    !isNaN(s) && s >= 0 && (V = s, console.log(`Set LOD level to [${V}]`));
   });
 }
-function Ce(i) {
-  if (h && J !== void 0)
-    if (Array.isArray(i))
-      for (const t of i)
-        Ce(t);
-    else i && "wireframe" in i && (i.wireframe = J === !0);
+function ke(n) {
+  if (h && Z !== void 0)
+    if (Array.isArray(n))
+      for (const t of n)
+        ke(t);
+    else n && "wireframe" in n && (n.wireframe = Z === !0);
 }
-const Q = new Array();
-let at = 0;
-const lt = Ae() ? 2 : 10;
-function ut(i) {
-  if (Q.length < lt) {
-    const s = Q.length;
+const J = new Array();
+let ct = 0;
+const dt = _e() ? 2 : 10;
+function ft(n) {
+  if (J.length < dt) {
+    const s = J.length;
     h && console.warn(`[Worker] Creating new worker #${s}`);
-    const o = we.createWorker(i || {});
-    return Q.push(o), o;
+    const r = Le.createWorker(n || {});
+    return J.push(r), r;
   }
-  const t = at++ % Q.length;
-  return Q[t];
+  const t = ct++ % J.length;
+  return J[t];
 }
-class we {
+class Le {
   constructor(t, e) {
     this.worker = t, this._debug = e.debug ?? !1, t.onmessage = (s) => {
-      const o = s.data;
-      switch (this._debug && console.log("[Worker] EVENT", o), o.type) {
+      const r = s.data;
+      switch (this._debug && console.log("[Worker] EVENT", r), r.type) {
         case "loaded-gltf":
-          for (const r of this._running)
-            if (r.url === o.result.url) {
-              dt(o.result), r.resolve(o.result);
-              const n = r.url;
-              n.startsWith("blob:") && URL.revokeObjectURL(n);
+          for (const i of this._running)
+            if (i.url === r.result.url) {
+              ht(r.result), i.resolve(r.result);
+              const o = i.url;
+              o.startsWith("blob:") && URL.revokeObjectURL(o);
             }
       }
     }, t.onerror = (s) => {
@@ -207,27 +219,27 @@ class we {
     ), {
       type: "module"
     });
-    return new we(e, t);
+    return new Le(e, t);
   }
   _running = [];
   _webglRenderer = null;
   async load(t, e) {
-    const s = He();
-    let o = e?.renderer;
-    o || (this._webglRenderer ??= (async () => {
+    const s = Qe();
+    let r = e?.renderer;
+    r || (this._webglRenderer ??= (async () => {
       const { WebGLRenderer: u } = await import("three");
       return new u();
-    })(), o = await this._webglRenderer);
-    const l = xe(o).ktx2Loader.workerConfig;
+    })(), r = await this._webglRenderer);
+    const a = we(r).ktx2Loader.workerConfig;
     t instanceof URL ? t = t.toString() : t.startsWith("file:") ? t = URL.createObjectURL(new Blob([t])) : !t.startsWith("blob:") && !t.startsWith("http:") && !t.startsWith("https:") && (t = new URL(t, window.location.href).toString());
-    const a = {
+    const l = {
       type: "load",
       url: t,
       dracoDecoderPath: s.dracoDecoderPath,
       ktx2TranscoderPath: s.ktx2TranscoderPath,
-      ktx2LoaderConfig: l
+      ktx2LoaderConfig: a
     };
-    return this._debug && console.debug("[Worker] Sending load request", a), this.worker.postMessage(a), new Promise((u) => {
+    return this._debug && console.debug("[Worker] Sending load request", l), this.worker.postMessage(l), new Promise((u) => {
       this._running.push({
         url: t.toString(),
         resolve: u
@@ -236,51 +248,51 @@ class we {
   }
   _debug = !1;
 }
-function dt(i) {
-  for (const t of i.geometries) {
+function ht(n) {
+  for (const t of n.geometries) {
     const e = t.geometry, s = new E();
     if (s.name = e.name || "", e.index) {
-      const o = e.index;
-      s.setIndex(ae(o));
+      const r = e.index;
+      s.setIndex(le(r));
     }
-    for (const o in e.attributes) {
-      const r = e.attributes[o], n = ae(r);
-      s.setAttribute(o, n);
+    for (const r in e.attributes) {
+      const i = e.attributes[r], o = le(i);
+      s.setAttribute(r, o);
     }
     if (e.morphAttributes)
-      for (const o in e.morphAttributes) {
-        const n = e.morphAttributes[o].map((l) => ae(l));
-        s.morphAttributes[o] = n;
+      for (const r in e.morphAttributes) {
+        const o = e.morphAttributes[r].map((a) => le(a));
+        s.morphAttributes[r] = o;
       }
-    if (s.morphTargetsRelative = e.morphTargetsRelative ?? !1, s.boundingBox = new he(), s.boundingBox.min = new C(
+    if (s.morphTargetsRelative = e.morphTargetsRelative ?? !1, s.boundingBox = new ge(), s.boundingBox.min = new R(
       e.boundingBox?.min.x,
       e.boundingBox?.min.y,
       e.boundingBox?.min.z
-    ), s.boundingBox.max = new C(
+    ), s.boundingBox.max = new R(
       e.boundingBox?.max.x,
       e.boundingBox?.max.y,
       e.boundingBox?.max.z
-    ), s.boundingSphere = new De(
-      new C(
+    ), s.boundingSphere = new Se(
+      new R(
         e.boundingSphere?.center.x,
         e.boundingSphere?.center.y,
         e.boundingSphere?.center.z
       ),
       e.boundingSphere?.radius
     ), e.groups)
-      for (const o of e.groups)
-        s.addGroup(o.start, o.count, o.materialIndex);
+      for (const r of e.groups)
+        s.addGroup(r.start, r.count, r.materialIndex);
     e.userData && (s.userData = e.userData), t.geometry = s;
   }
-  for (const t of i.textures) {
+  for (const t of n.textures) {
     const e = t.texture;
     let s = null;
     if (e.isCompressedTexture) {
-      const o = e.mipmaps, r = e.image?.width || e.source?.data?.width || -1, n = e.image?.height || e.source?.data?.height || -1;
-      s = new Be(
-        o,
+      const r = e.mipmaps, i = e.image?.width || e.source?.data?.width || -1, o = e.image?.height || e.source?.data?.height || -1;
+      s = new Ge(
         r,
-        n,
+        i,
+        o,
         e.format,
         e.type,
         e.mapping,
@@ -303,28 +315,30 @@ function dt(i) {
         e.type,
         e.anisotropy,
         e.colorSpace
-      ), s.mipmaps = e.mipmaps, s.channel = e.channel, s.source.data = e.source.data, s.flipY = e.flipY, s.premultiplyAlpha = e.premultiplyAlpha, s.unpackAlignment = e.unpackAlignment, s.matrix = new Ge(...e.matrix.elements);
+      ), s.mipmaps = e.mipmaps, s.channel = e.channel, s.source.data = e.source.data, s.flipY = e.flipY, s.premultiplyAlpha = e.premultiplyAlpha, s.unpackAlignment = e.unpackAlignment, s.matrix = new Fe(...e.matrix.elements);
     if (!s) {
       console.error("[Worker] Failed to create new texture from received data. Texture is not a CompressedTexture or Texture.");
       continue;
     }
     t.texture = s;
   }
-  return i;
+  return n;
 }
-function ae(i) {
-  let t = i;
-  if ("isInterleavedBufferAttribute" in i && i.isInterleavedBufferAttribute) {
-    const e = i.data, s = e.array, o = new Fe(s, e.stride);
-    t = new We(o, i.itemSize, s.byteOffset, i.normalized), t.offset = i.offset;
-  } else "isBufferAttribute" in i && i.isBufferAttribute && (t = new Ue(i.array, i.itemSize, i.normalized), t.usage = i.usage, t.gpuType = i.gpuType, t.updateRanges = i.updateRanges);
+function le(n) {
+  let t = n;
+  if ("isInterleavedBufferAttribute" in n && n.isInterleavedBufferAttribute) {
+    const e = n.data, s = e.array, r = new We(s, e.stride);
+    t = new Ue(r, n.itemSize, s.byteOffset, n.normalized), t.offset = n.offset;
+  } else "isBufferAttribute" in n && n.isBufferAttribute && (t = new ze(n.array, n.itemSize, n.normalized), t.usage = n.usage, t.gpuType = n.gpuType, t.updateRanges = n.updateRanges);
   return t;
 }
-const ct = j("gltf-progressive-worker"), ft = j("gltf-progressive-reduce-mipmaps"), le = /* @__PURE__ */ Symbol("needle-progressive-texture"), W = "NEEDLE_progressive";
+const gt = N("gltf-progressive-worker");
+N("gltf-progressive-reduce-mipmaps");
+const K = N("gltf-progressive-gc"), ue = /* @__PURE__ */ Symbol("needle-progressive-texture"), U = "NEEDLE_progressive";
 class m {
   /** The name of the extension */
   get name() {
-    return W;
+    return U;
   }
   // #region PUBLIC API
   static getMeshLODExtension(t) {
@@ -336,40 +350,40 @@ class m {
     return e ?? -1;
   }
   static getMaterialMinMaxLODsCount(t, e) {
-    const s = this, o = "LODS:minmax", r = t[o];
-    if (r != null) return r;
+    const s = this, r = "LODS:minmax", i = t[r];
+    if (i != null) return i;
     if (e || (e = {
       min_count: 1 / 0,
       max_count: 0,
       lods: []
     }), Array.isArray(t)) {
-      for (const l of t)
-        this.getMaterialMinMaxLODsCount(l, e);
-      return t[o] = e, e;
+      for (const a of t)
+        this.getMaterialMinMaxLODsCount(a, e);
+      return t[r] = e, e;
     }
     if (h === "verbose" && console.log("getMaterialMinMaxLODsCount", t), t.type === "ShaderMaterial" || t.type === "RawShaderMaterial") {
-      const l = t;
-      for (const a of Object.keys(l.uniforms)) {
-        const u = l.uniforms[a].value;
-        u?.isTexture === !0 && n(u, e);
+      const a = t;
+      for (const l of Object.keys(a.uniforms)) {
+        const u = a.uniforms[l].value;
+        u?.isTexture === !0 && o(u, e);
       }
     } else if (t.isMaterial)
-      for (const l of Object.keys(t)) {
-        const a = t[l];
-        a?.isTexture === !0 && n(a, e);
+      for (const a of Object.keys(t)) {
+        const l = t[a];
+        l?.isTexture === !0 && o(l, e);
       }
     else
       h && console.warn(`[getMaterialMinMaxLODsCount] Unsupported material type: ${t.type}`);
-    return t[o] = e, e;
-    function n(l, a) {
-      const u = s.getAssignedLODInformation(l);
+    return t[r] = e, e;
+    function o(a, l) {
+      const u = s.getAssignedLODInformation(a);
       if (u) {
         const d = s.lodInfos.get(u.key);
         if (d && d.lods) {
-          a.min_count = Math.min(a.min_count, d.lods.length), a.max_count = Math.max(a.max_count, d.lods.length);
-          for (let y = 0; y < d.lods.length; y++) {
-            const w = d.lods[y];
-            w.width && (a.lods[y] = a.lods[y] || { min_height: 1 / 0, max_height: 0 }, a.lods[y].min_height = Math.min(a.lods[y].min_height, w.height), a.lods[y].max_height = Math.max(a.lods[y].max_height, w.height));
+          l.min_count = Math.min(l.min_count, d.lods.length), l.max_count = Math.max(l.max_count, d.lods.length);
+          for (let g = 0; g < d.lods.length; g++) {
+            const y = d.lods[g];
+            y.width && (l.lods[g] = l.lods[g] || { min_height: 1 / 0, max_height: 0 }, l.lods[g].min_height = Math.min(l.lods[g].min_height, y.height), l.lods[g].max_height = Math.max(l.lods[g].max_height, y.height));
           }
         }
       }
@@ -382,28 +396,28 @@ class m {
    */
   static hasLODLevelAvailable(t, e) {
     if (Array.isArray(t)) {
-      for (const r of t)
-        if (this.hasLODLevelAvailable(r, e)) return !0;
+      for (const i of t)
+        if (this.hasLODLevelAvailable(i, e)) return !0;
       return !1;
     }
     if (t.isMaterial === !0) {
-      for (const r of Object.keys(t)) {
-        const n = t[r];
-        if (n && n.isTexture && this.hasLODLevelAvailable(n, e))
+      for (const i of Object.keys(t)) {
+        const o = t[i];
+        if (o && o.isTexture && this.hasLODLevelAvailable(o, e))
           return !0;
       }
       return !1;
     } else if (t.isGroup === !0) {
-      for (const r of t.children)
-        if (r.isMesh === !0 && this.hasLODLevelAvailable(r, e))
+      for (const i of t.children)
+        if (i.isMesh === !0 && this.hasLODLevelAvailable(i, e))
           return !0;
     }
-    let s, o;
+    let s, r;
     if (t.isMesh ? s = t.geometry : (t.isBufferGeometry || t.isTexture) && (s = t), s && s?.userData?.LODS) {
-      const r = s.userData.LODS;
-      if (o = this.lodInfos.get(r.key), e === void 0) return o != null;
-      if (o)
-        return Array.isArray(o.lods) ? e < o.lods.length : e === 0;
+      const i = s.userData.LODS;
+      if (r = this.lodInfos.get(i.key), e === void 0) return r != null;
+      if (r)
+        return Array.isArray(r.lods) ? e < r.lods.length : e === 0;
     }
     return !1;
   }
@@ -423,19 +437,19 @@ class m {
    */
   static assignMeshLOD(t, e) {
     if (!t) return Promise.resolve(null);
-    if (t instanceof V || t.isMesh === !0) {
-      const s = t.geometry, o = this.getAssignedLODInformation(s);
-      if (!o)
+    if (t instanceof X || t.isMesh === !0) {
+      const s = t.geometry, r = this.getAssignedLODInformation(s);
+      if (!r)
         return Promise.resolve(null);
-      for (const r of z)
-        r.onBeforeGetLODMesh?.(t, e);
-      return t["LOD:requested level"] = e, m.getOrLoadLOD(s, e).then((r) => {
-        if (Array.isArray(r)) {
-          const n = o.index || 0;
-          r = r[n];
+      for (const i of q)
+        i.onBeforeGetLODMesh?.(t, e);
+      return t["LOD:requested level"] = e, m.getOrLoadLOD(s, e).then((i) => {
+        if (Array.isArray(i)) {
+          const o = r.index || 0;
+          i = i[o];
         }
-        return t["LOD:requested level"] === e && (delete t["LOD:requested level"], r && s != r && (r?.isBufferGeometry ? t.geometry = r : h && console.error("Invalid LOD geometry", r))), r;
-      }).catch((r) => (console.error("Error loading mesh LOD", t, r), null));
+        return t["LOD:requested level"] === e && (delete t["LOD:requested level"], i && s != i && (i?.isBufferGeometry ? t.geometry = i : h && console.error("Invalid LOD geometry", i))), i;
+      }).catch((i) => (console.error("Error loading mesh LOD", t, i), null));
     } else h && console.error("Invalid call to assignMeshLOD: Request mesh LOD but the object is not a mesh", t);
     return Promise.resolve(null);
   }
@@ -444,46 +458,46 @@ class m {
     if (t.isMesh === !0) {
       const s = t;
       if (Array.isArray(s.material)) {
-        const o = new Array();
-        for (const r of s.material) {
-          const n = this.assignTextureLOD(r, e);
-          o.push(n);
+        const r = new Array();
+        for (const i of s.material) {
+          const o = this.assignTextureLOD(i, e);
+          r.push(o);
         }
-        return Promise.all(o).then((r) => {
-          const n = new Array();
-          for (const l of r)
-            Array.isArray(l) && n.push(...l);
-          return n;
+        return Promise.all(r).then((i) => {
+          const o = new Array();
+          for (const a of i)
+            Array.isArray(a) && o.push(...a);
+          return o;
         });
       } else
         return this.assignTextureLOD(s.material, e);
     }
     if (t.isMaterial === !0) {
-      const s = t, o = [], r = new Array();
+      const s = t, r = [], i = new Array();
       if (s.uniforms && (s.isRawShaderMaterial || s.isShaderMaterial === !0)) {
-        const n = s;
-        for (const l of Object.keys(n.uniforms)) {
-          const a = n.uniforms[l].value;
-          if (a?.isTexture === !0) {
-            const u = this.assignTextureLODForSlot(a, e, s, l).then((d) => (d && n.uniforms[l].value != d && (n.uniforms[l].value = d, n.uniformsNeedUpdate = !0), d));
-            o.push(u), r.push(l);
+        const o = s;
+        for (const a of Object.keys(o.uniforms)) {
+          const l = o.uniforms[a].value;
+          if (l?.isTexture === !0) {
+            const u = this.assignTextureLODForSlot(l, e, s, a).then((d) => (d && o.uniforms[a].value != d && (o.uniforms[a].value = d, o.uniformsNeedUpdate = !0), d));
+            r.push(u), i.push(a);
           }
         }
       } else
-        for (const n of Object.keys(s)) {
-          const l = s[n];
-          if (l?.isTexture === !0) {
-            const a = this.assignTextureLODForSlot(l, e, s, n);
-            o.push(a), r.push(n);
+        for (const o of Object.keys(s)) {
+          const a = s[o];
+          if (a?.isTexture === !0) {
+            const l = this.assignTextureLODForSlot(a, e, s, o);
+            r.push(l), i.push(o);
           }
         }
-      return Promise.all(o).then((n) => {
-        const l = new Array();
-        for (let a = 0; a < n.length; a++) {
-          const u = n[a], d = r[a];
-          u && u.isTexture === !0 ? l.push({ material: s, slot: d, texture: u, level: e }) : l.push({ material: s, slot: d, texture: null, level: e });
+      return Promise.all(r).then((o) => {
+        const a = new Array();
+        for (let l = 0; l < o.length; l++) {
+          const u = o[l], d = i[l];
+          u && u.isTexture === !0 ? a.push({ material: s, slot: d, texture: u, level: e }) : a.push({ material: s, slot: d, texture: null, level: e });
         }
-        return l;
+        return a;
       });
     }
     if (t instanceof F || t.isTexture === !0) {
@@ -492,29 +506,39 @@ class m {
     }
     return Promise.resolve(null);
   }
+  /**
+   * Set the maximum number of concurrent loading tasks for LOD resources. This limits how many LOD resources (meshes or textures) can be loaded at the same time to prevent overloading the network or GPU. If the limit is reached, additional loading requests will be queued and processed as previous ones finish.
+   * @default 50 on desktop, 20 on mobile devices
+   */
+  static set maxConcurrentLoadingTasks(t) {
+    m.queue.maxConcurrent = t;
+  }
+  static get maxConcurrentLoadingTasks() {
+    return m.queue.maxConcurrent;
+  }
   // #region INTERNAL
-  static assignTextureLODForSlot(t, e, s, o) {
-    return t?.isTexture !== !0 ? Promise.resolve(null) : o === "glyphMap" ? Promise.resolve(t) : m.getOrLoadLOD(t, e).then((r) => {
-      if (Array.isArray(r))
+  static assignTextureLODForSlot(t, e, s, r) {
+    return t?.isTexture !== !0 ? Promise.resolve(null) : r === "glyphMap" ? Promise.resolve(t) : m.getOrLoadLOD(t, e).then((i) => {
+      if (Array.isArray(i))
         return console.warn("Progressive: Got an array of textures for a texture slot, this should not happen..."), null;
-      if (r?.isTexture === !0) {
-        if (r != t && s && o) {
-          const n = s[o];
-          if (n && !h) {
-            const l = this.getAssignedLODInformation(n);
-            if (l && l?.level < e)
-              return h === "verbose" && console.warn("Assigned texture level is already higher: ", l.level, e, s, n, r), null;
+      if (i?.isTexture === !0) {
+        if (i != t && s && r) {
+          const o = s[r];
+          if (o && !h) {
+            const a = this.getAssignedLODInformation(o);
+            if (a && a?.level < e)
+              return h === "verbose" && console.warn("Assigned texture level is already higher: ", a.level, e, s, o, i), i && i !== o && ((h || K) && console.log(`[gltf-progressive] Disposing rejected lower-quality texture LOD ${e} (assigned is ${a.level})`, i.uuid), i.dispose()), null;
           }
-          if (ft && r.mipmaps) {
-            const l = r.mipmaps.length;
-            r.mipmaps.length = Math.min(r.mipmaps.length, 3), l !== r.mipmaps.length && h && console.debug(`Reduced mipmap count from ${l} to ${r.mipmaps.length} for ${r.uuid}: ${r.image?.width}x${r.image?.height}.`);
+          if (this.trackTextureUsage(i), o && o !== i && this.untrackTextureUsage(o) && (h || K)) {
+            const l = this.getAssignedLODInformation(o);
+            console.log(`[gltf-progressive] Disposed old texture LOD ${l?.level ?? "?"} → ${e} for ${s.name || s.type}.${r}`, o.uuid);
           }
-          s[o] = r;
+          s[r] = i;
         }
-        return r;
+        return i;
       } else h == "verbose" && console.warn("No LOD found for", t, e);
       return null;
-    }).catch((r) => (console.error("Error loading LOD", t, r), null));
+    }).catch((i) => (console.error("Error loading LOD", t, i), null));
   }
   parser;
   url;
@@ -525,7 +549,7 @@ class m {
   _isLoadingMesh;
   loadMesh = (t) => {
     if (this._isLoadingMesh) return null;
-    const e = this.parser.json.meshes[t]?.extensions?.[W];
+    const e = this.parser.json.meshes[t]?.extensions?.[U];
     return e ? (this._isLoadingMesh = !0, this.parser.getDependency("mesh", t).then((s) => (this._isLoadingMesh = !1, s && m.registerMesh(this.url, e.guid, s, e.lods?.length, 0, e), s))) : null;
   };
   // private _isLoadingTexture;
@@ -545,28 +569,28 @@ class m {
   afterRoot(t) {
     return h && console.log("AFTER", this.url, t), this.parser.json.textures?.forEach((e, s) => {
       if (e?.extensions) {
-        const o = e?.extensions[W];
-        if (o) {
-          if (!o.lods) {
-            h && console.warn("Texture has no LODs", o);
+        const r = e?.extensions[U];
+        if (r) {
+          if (!r.lods) {
+            h && console.warn("Texture has no LODs", r);
             return;
           }
-          let r = !1;
-          for (const n of this.parser.associations.keys())
-            n.isTexture === !0 && this.parser.associations.get(n)?.textures === s && (r = !0, m.registerTexture(this.url, n, o.lods?.length, s, o));
-          r || this.parser.getDependency("texture", s).then((n) => {
-            n && m.registerTexture(this.url, n, o.lods?.length, s, o);
+          let i = !1;
+          for (const o of this.parser.associations.keys())
+            o.isTexture === !0 && this.parser.associations.get(o)?.textures === s && (i = !0, m.registerTexture(this.url, o, r.lods?.length, s, r));
+          i || this.parser.getDependency("texture", s).then((o) => {
+            o && m.registerTexture(this.url, o, r.lods?.length, s, r);
           });
         }
       }
     }), this.parser.json.meshes?.forEach((e, s) => {
       if (e?.extensions) {
-        const o = e?.extensions[W];
-        if (o && o.lods) {
-          for (const r of this.parser.associations.keys())
-            if (r.isMesh) {
-              const n = this.parser.associations.get(r);
-              n?.meshes === s && m.registerMesh(this.url, o.guid, r, o.lods.length, n.primitives, o);
+        const r = e?.extensions[U];
+        if (r && r.lods) {
+          for (const i of this.parser.associations.keys())
+            if (i.isMesh) {
+              const o = this.parser.associations.get(i);
+              o?.meshes === s && m.registerMesh(this.url, r.guid, i, r.lods.length, o.primitives, r);
             }
         }
       }
@@ -575,38 +599,39 @@ class m {
   /**
    * Register a texture with LOD information
    */
-  static registerTexture = (t, e, s, o, r) => {
+  static registerTexture = (t, e, s, r, i) => {
     if (!e) {
       h && console.error("!! gltf-progressive: Called register texture without texture");
       return;
     }
     if (h) {
-      const l = e.image?.width || e.source?.data?.width || 0, a = e.image?.height || e.source?.data?.height || 0;
-      console.log(`> gltf-progressive: register texture[${o}] "${e.name || e.uuid}", Current: ${l}x${a}, Max: ${r.lods[0]?.width}x${r.lods[0]?.height}, uuid: ${e.uuid}`, r, e);
+      const a = e.image?.width || e.source?.data?.width || 0, l = e.image?.height || e.source?.data?.height || 0;
+      console.log(`> gltf-progressive: register texture[${r}] "${e.name || e.uuid}", Current: ${a}x${l}, Max: ${i.lods[0]?.width}x${i.lods[0]?.height}, uuid: ${e.uuid}`, i, e);
     }
-    e.source && (e.source[le] = r);
-    const n = r.guid;
-    m.assignLODInformation(t, e, n, s, o), m.lodInfos.set(n, r), m.lowresCache.set(n, new WeakRef(e));
+    e.source && (e.source[ue] = i);
+    const o = i.guid;
+    m.assignLODInformation(t, e, o, s, r), m.lodInfos.set(o, i), m.lowresCache.set(o, new WeakRef(e));
   };
   /**
    * Register a mesh with LOD information
    */
-  static registerMesh = (t, e, s, o, r, n) => {
-    const l = s.geometry;
-    if (!l) {
+  static registerMesh = (t, e, s, r, i, o) => {
+    const a = s.geometry;
+    if (!a) {
       h && console.warn("gltf-progressive: Register mesh without geometry");
       return;
     }
-    l.userData || (l.userData = {}), h && console.log("> Progressive: register mesh " + s.name, { index: r, uuid: s.uuid }, n, s), m.assignLODInformation(t, l, e, o, r), m.lodInfos.set(e, n);
+    a.userData || (a.userData = {}), h && console.log("> Progressive: register mesh " + s.name, { index: i, uuid: s.uuid }, o, s), m.assignLODInformation(t, a, e, r, i), m.lodInfos.set(e, o);
     let u = m.lowresCache.get(e)?.deref();
-    u ? u.push(s.geometry) : u = [s.geometry], m.lowresCache.set(e, new WeakRef(u)), o > 0 && !Z(s) && ot(s, l);
-    for (const d of z)
-      d.onRegisteredNewMesh?.(s, n);
+    u ? u.push(s.geometry) : u = [s.geometry], m.lowresCache.set(e, new WeakRef(u)), r > 0 && !ee(s) && at(s, a);
+    for (const d of q)
+      d.onRegisteredNewMesh?.(s, o);
   };
   /**
    * Dispose cached resources to free memory.
    * Call this when a model is removed from the scene to allow garbage collection of its LOD resources.
    * Calls three.js `.dispose()` on cached Textures and BufferGeometries to free GPU memory.
+   * Also clears reference counts for disposed textures.
    * @param guid Optional GUID to dispose resources for a specific model. If omitted, all cached resources are cleared.
    */
   static dispose(t) {
@@ -616,42 +641,48 @@ class m {
       if (e) {
         const s = e.deref();
         if (s) {
-          if (s.isTexture)
-            s.dispose();
-          else if (Array.isArray(s))
-            for (const o of s) o.dispose();
+          if (s.isTexture) {
+            const r = s;
+            this.textureRefCounts.delete(r.uuid), r.dispose();
+          } else if (Array.isArray(s))
+            for (const r of s) r.dispose();
         }
         this.lowresCache.delete(t);
       }
-      for (const [s, o] of this.cache)
-        s.includes(t) && (this._disposeCacheEntry(o), this.cache.delete(s));
+      for (const [s, r] of this.cache)
+        s.includes(t) && (this._disposeCacheEntry(r), this.cache.delete(s));
     } else {
-      this.lodInfos.clear();
+      this.cacheGeneration++, this.lodInfos.clear();
       for (const [, e] of this.lowresCache) {
         const s = e.deref();
         if (s) {
-          if (s.isTexture)
-            s.dispose();
-          else if (Array.isArray(s))
-            for (const o of s) o.dispose();
+          if (s.isTexture) {
+            const r = s;
+            this.textureRefCounts.delete(r.uuid), r.dispose();
+          } else if (Array.isArray(s))
+            for (const r of s) r.dispose();
         }
       }
       this.lowresCache.clear();
       for (const [, e] of this.cache)
         this._disposeCacheEntry(e);
-      this.cache.clear();
+      this.cache.clear(), this.textureRefCounts.clear();
     }
   }
   /** Dispose a single cache entry's three.js resource(s) to free GPU memory. */
   static _disposeCacheEntry(t) {
-    t instanceof WeakRef ? t.deref()?.dispose() : t.then((e) => {
-      if (e)
-        if (Array.isArray(e))
-          for (const s of e) s.dispose();
-        else
-          e.dispose();
-    }).catch(() => {
-    });
+    if (t instanceof WeakRef) {
+      const e = t.deref();
+      e && (e.isTexture && this.textureRefCounts.delete(e.uuid), e.dispose());
+    } else
+      this.disposedRequests.add(t), t.then((e) => {
+        if (e)
+          if (Array.isArray(e))
+            for (const s of e) s.dispose();
+          else
+            e.isTexture && this.textureRefCounts.delete(e.uuid), e.dispose();
+      }).catch(() => {
+      });
   }
   /** A map of key = asset uuid and value = LOD information */
   static lodInfos = /* @__PURE__ */ new Map();
@@ -659,6 +690,8 @@ class m {
   static cache = /* @__PURE__ */ new Map();
   /** this contains the geometry/textures that were originally loaded. Uses WeakRef to allow garbage collection when unused. */
   static lowresCache = /* @__PURE__ */ new Map();
+  /** Reference counting for textures to track usage across multiple materials/objects */
+  static textureRefCounts = /* @__PURE__ */ new Map();
   /**
    * FinalizationRegistry to automatically clean up `previouslyLoaded` cache entries
    * when their associated three.js resources are garbage collected by the browser.
@@ -666,161 +699,194 @@ class m {
    */
   static _resourceRegistry = new FinalizationRegistry((t) => {
     const e = m.cache.get(t);
-    h && console.debug(`[gltf-progressive] Resource GC'd
-${t}`), e instanceof WeakRef && (e.deref() || (m.cache.delete(t), h && console.log(`[gltf-progressive] Cache entry auto-cleaned (GC'd): ${t}`)));
+    (h || K) && console.debug(`[gltf-progressive] Memory: Resource GC'd
+${t}`), e instanceof WeakRef && (e.deref() || (m.cache.delete(t), (h || K) && console.log("[gltf-progressive] ↪ Cache entry deleted (GC)")));
   });
+  /**
+   * Track texture usage by incrementing reference count
+   */
+  static trackTextureUsage(t) {
+    const e = t.uuid, s = this.textureRefCounts.get(e) || 0;
+    this.textureRefCounts.set(e, s + 1), h === "verbose" && console.log(`[gltf-progressive] Track texture ${e}, refCount: ${s} → ${s + 1}`);
+  }
+  /**
+   * Untrack texture usage by decrementing reference count.
+   * Automatically disposes the texture when reference count reaches zero.
+   * @returns true if the texture was disposed, false otherwise
+   */
+  static untrackTextureUsage(t) {
+    const e = t.uuid, s = this.textureRefCounts.get(e);
+    if (!s)
+      return (h === "verbose" || K) && i("[gltf-progressive] Memory: Untrack untracked texture (dispose immediately)", 0), t.dispose(), !0;
+    const r = s - 1;
+    if (r <= 0)
+      return this.textureRefCounts.delete(e), (h || K) && i("[gltf-progressive] Memory: Dispose texture", r), t.dispose(), !0;
+    return this.textureRefCounts.set(e, r), h === "verbose" && i("[gltf-progressive] Memory: Untrack texture", r), !1;
+    function i(o, a) {
+      let l = t.image?.width || t.source?.data?.width || 0, u = t.image?.height || t.source?.data?.height || 0;
+      const d = l && u ? `${l}x${u}` : "N/A";
+      let g = "N/A";
+      l && u && (g = `~${(it(t) / (1024 * 1024)).toFixed(2)} MB`), console.log(`${o} — ${t.name} ${d} (${g}), refCount: ${s} → ${a}
+${e}`);
+    }
+  }
   static workers = [];
+  static cacheGeneration = 0;
+  static disposedRequests = /* @__PURE__ */ new WeakSet();
   static _workersIndex = 0;
   static async getOrLoadLOD(t, e) {
-    const s = h == "verbose", o = this.getAssignedLODInformation(t);
-    if (!o)
+    const s = this.cacheGeneration, r = h == "verbose", i = this.getAssignedLODInformation(t);
+    if (!i)
       return h && console.warn(`[gltf-progressive] No LOD information found: ${t.name}, uuid: ${t.uuid}, type: ${t.type}`, t), null;
-    const r = o?.key;
-    let n;
+    const o = i?.key;
+    let a;
     if (t.isTexture === !0) {
-      const a = t;
-      a.source && a.source[le] && (n = a.source[le]);
+      const u = t;
+      u.source && u.source[ue] && (a = u.source[ue]);
     }
-    if (n || (n = m.lodInfos.get(r)), !n)
-      h && console.warn(`Can not load LOD ${e}: no LOD info found for "${r}" ${t.name}`, t.type, m.lodInfos);
+    if (a || (a = m.lodInfos.get(o)), !a)
+      h && console.warn(`Can not load LOD ${e}: no LOD info found for "${o}" ${t.name}`, t.type, m.lodInfos);
     else {
       if (e > 0) {
-        let d = !1;
-        const y = Array.isArray(n.lods);
-        if (y && e >= n.lods.length ? d = !0 : y || (d = !0), d) {
-          const w = this.lowresCache.get(r);
-          if (w) {
-            const _ = w.deref();
-            if (_) return _;
-            this.lowresCache.delete(r), h && console.log(`[gltf-progressive] Lowres cache entry was GC'd: ${r}`);
+        let g = !1;
+        const y = Array.isArray(a.lods);
+        if (y && e >= a.lods.length ? g = !0 : y || (g = !0), g) {
+          const M = this.lowresCache.get(o);
+          if (M) {
+            const L = M.deref();
+            if (L) return L;
+            this.lowresCache.delete(o), h && console.log(`[gltf-progressive] Lowres cache entry was GC'd: ${o}`);
           }
           return null;
         }
       }
-      const a = Array.isArray(n.lods) ? n.lods[e]?.path : n.lods;
-      if (!a)
-        return h && !n["missing:uri"] && (n["missing:uri"] = !0, console.warn("Missing uri for progressive asset for LOD " + e, n)), null;
-      const u = tt(o.url, a);
-      if (u.endsWith(".glb") || u.endsWith(".gltf")) {
-        if (!n.guid)
-          return console.warn("missing pointer for glb/gltf texture", n), null;
-        const d = u + "_" + n.guid, y = await this.queue.slot(u), w = this.cache.get(d);
-        if (w !== void 0)
-          if (s && console.log(`LOD ${e} was already loading/loaded: ${d}`), w instanceof WeakRef) {
-            const c = w.deref();
-            if (c) {
-              let g = c, b = !1;
-              if (g instanceof F && t instanceof F ? g.image?.data || g.source?.data ? g = this.copySettings(t, g) : b = !0 : g instanceof E && t instanceof E && (g.attributes.position?.array || (b = !0)), !b)
-                return g;
+      const u = Array.isArray(a.lods) ? a.lods[e]?.path : a.lods;
+      if (!u)
+        return h && !a["missing:uri"] && (a["missing:uri"] = !0, console.warn("Missing uri for progressive asset for LOD " + e, a)), null;
+      const d = st(i.url, u);
+      if (d.endsWith(".glb") || d.endsWith(".gltf")) {
+        if (!a.guid)
+          return console.warn("missing pointer for glb/gltf texture", a), null;
+        const g = d + "_" + a.guid, y = await this.queue.slot(d);
+        if (s !== this.cacheGeneration) return null;
+        const M = this.cache.get(g);
+        if (M !== void 0)
+          if (r && console.log(`LOD ${e} was already loading/loaded: ${g}`), M instanceof WeakRef) {
+            const f = M.deref();
+            if (f) {
+              let _ = f, D = !1;
+              if (_ instanceof F && t instanceof F ? _.image?.data || _.source?.data ? _ = this.copySettings(t, _) : D = !0 : _ instanceof E && t instanceof E && (_.attributes.position?.array || (D = !0)), !D)
+                return _;
             }
-            this.cache.delete(d), h && console.log(`[gltf-progressive] Re-loading GC'd/disposed resource: ${d}`);
+            this.cache.delete(g), h && console.log(`[gltf-progressive] Re-loading GC'd/disposed resource: ${g}`);
           } else {
-            let c = await w.catch((b) => (console.error(`Error loading LOD ${e} from ${u}
-`, b), null)), g = !1;
-            if (c == null || (c instanceof F && t instanceof F ? c.image?.data || c.source?.data ? c = this.copySettings(t, c) : (g = !0, this.cache.delete(d)) : c instanceof E && t instanceof E && (c.attributes.position?.array || (g = !0, this.cache.delete(d)))), !g)
-              return c;
+            let f = await M.catch((D) => (console.error(`Error loading LOD ${e} from ${d}
+`, D), null));
+            if (s !== this.cacheGeneration || this.disposedRequests.has(M)) return null;
+            let _ = !1;
+            if (f == null || (f instanceof F && t instanceof F ? f.image?.data || f.source?.data ? f = this.copySettings(t, f) : (_ = !0, this.cache.delete(g)) : f instanceof E && t instanceof E && (f.attributes.position?.array || (_ = !0, this.cache.delete(g)))), !_)
+              return f;
           }
         if (!y.use)
-          return h && console.log(`LOD ${e} was aborted: ${u}`), null;
-        const _ = n, I = new Promise(async (c, g) => {
-          if (ct) {
-            const x = await (await ut({})).load(u);
-            if (x.textures.length > 0)
-              for (const f of x.textures) {
-                let p = f.texture;
-                return m.assignLODInformation(o.url, p, r, e, void 0), t instanceof F && (p = this.copySettings(t, p)), p && (p.guid = _.guid), c(p);
+          return h && console.log(`LOD ${e} was aborted: ${d}`), null;
+        const L = a, T = new Promise(async (f, _) => {
+          if (gt) {
+            const c = await (await ft({})).load(d);
+            if (c.textures.length > 0)
+              for (const p of c.textures) {
+                let w = p.texture;
+                return m.assignLODInformation(i.url, w, o, e, void 0), t instanceof F && (w = this.copySettings(t, w)), w && (w.guid = L.guid), f(w);
               }
-            if (x.geometries.length > 0) {
-              const f = new Array();
-              for (const p of x.geometries) {
-                const O = p.geometry;
-                m.assignLODInformation(o.url, O, r, e, p.primitiveIndex), f.push(O);
+            if (c.geometries.length > 0) {
+              const p = new Array();
+              for (const w of c.geometries) {
+                const b = w.geometry;
+                m.assignLODInformation(i.url, b, o, e, w.primitiveIndex), p.push(b);
               }
-              return c(f);
+              return f(p);
             }
-            return c(null);
+            return f(null);
           }
-          const b = new ye();
-          Se(b), h && (await new Promise((L) => setTimeout(L, 1e3)), s && console.warn("Start loading (delayed) " + u, _.guid));
-          let B = u;
-          if (_ && Array.isArray(_.lods)) {
-            const L = _.lods[e];
-            L.hash && (B += "?v=" + L.hash);
+          const D = new xe();
+          Te(D), h && (await new Promise((S) => setTimeout(S, 1e3)), r && console.warn("Start loading (delayed) " + d, L.guid));
+          let I = d;
+          if (L && Array.isArray(L.lods)) {
+            const S = L.lods[e];
+            S.hash && (I += "?v=" + S.hash);
           }
-          const D = await b.loadAsync(B).catch((L) => (console.error(`Error loading LOD ${e} from ${u}
-`, L), c(null)));
-          if (!D)
-            return c(null);
-          const N = D.parser;
-          s && console.log("Loading finished " + u, _.guid);
-          let P = 0;
-          if (D.parser.json.textures) {
-            let L = !1;
-            for (const x of D.parser.json.textures) {
-              if (x?.extensions) {
-                const f = x?.extensions[W];
-                if (f?.guid && f.guid === _.guid) {
-                  L = !0;
+          const C = await D.loadAsync(I).catch((S) => (console.error(`Error loading LOD ${e} from ${d}
+`, S), f(null)));
+          if (!C)
+            return f(null);
+          const W = C.parser;
+          r && console.log("Loading finished " + d, L.guid);
+          let O = 0;
+          if (C.parser.json.textures) {
+            let S = !1;
+            for (const c of C.parser.json.textures) {
+              if (c?.extensions) {
+                const p = c?.extensions[U];
+                if (p?.guid && p.guid === L.guid) {
+                  S = !0;
                   break;
                 }
               }
-              P++;
+              O++;
             }
-            if (L) {
-              let x = await N.getDependency("texture", P);
-              return x && m.assignLODInformation(o.url, x, r, e, void 0), s && console.log('change "' + t.name + '" → "' + x.name + '"', u, P, x, d), t instanceof F && (x = this.copySettings(t, x)), x && (x.guid = _.guid), c(x);
-            } else h && console.warn("Could not find texture with guid", _.guid, D.parser.json);
+            if (S) {
+              let c = await W.getDependency("texture", O);
+              return c && m.assignLODInformation(i.url, c, o, e, void 0), r && console.log('change "' + t.name + '" → "' + c.name + '"', d, O, c, g), t instanceof F && (c = this.copySettings(t, c)), c && (c.guid = L.guid), f(c);
+            } else h && console.warn("Could not find texture with guid", L.guid, C.parser.json);
           }
-          if (P = 0, D.parser.json.meshes) {
-            let L = !1;
-            for (const x of D.parser.json.meshes) {
-              if (x?.extensions) {
-                const f = x?.extensions[W];
-                if (f?.guid && f.guid === _.guid) {
-                  L = !0;
+          if (O = 0, C.parser.json.meshes) {
+            let S = !1;
+            for (const c of C.parser.json.meshes) {
+              if (c?.extensions) {
+                const p = c?.extensions[U];
+                if (p?.guid && p.guid === L.guid) {
+                  S = !0;
                   break;
                 }
               }
-              P++;
+              O++;
             }
-            if (L) {
-              const x = await N.getDependency("mesh", P);
-              if (s && console.log(`Loaded Mesh "${x.name}"`, u, P, x, d), x.isMesh === !0) {
-                const f = x.geometry;
-                return m.assignLODInformation(o.url, f, r, e, 0), c(f);
+            if (S) {
+              const c = await W.getDependency("mesh", O);
+              if (r && console.log(`Loaded Mesh "${c.name}"`, d, O, c, g), c.isMesh === !0) {
+                const p = c.geometry;
+                return m.assignLODInformation(i.url, p, o, e, 0), f(p);
               } else {
-                const f = new Array();
-                for (let p = 0; p < x.children.length; p++) {
-                  const O = x.children[p];
-                  if (O.isMesh === !0) {
-                    const S = O.geometry;
-                    m.assignLODInformation(o.url, S, r, e, p), f.push(S);
+                const p = new Array();
+                for (let w = 0; w < c.children.length; w++) {
+                  const b = c.children[w];
+                  if (b.isMesh === !0) {
+                    const A = b.geometry;
+                    m.assignLODInformation(i.url, A, o, e, w), p.push(A);
                   }
                 }
-                return c(f);
+                return f(p);
               }
-            } else h && console.warn("Could not find mesh with guid", _.guid, D.parser.json);
+            } else h && console.warn("Could not find mesh with guid", L.guid, C.parser.json);
           }
-          return c(null);
+          return f(null);
         });
-        this.cache.set(d, I), y.use(I);
-        const M = await I;
-        return M != null ? M instanceof F ? (this.cache.set(d, new WeakRef(M)), m._resourceRegistry.register(M, d)) : Array.isArray(M) ? this.cache.set(d, Promise.resolve(M)) : this.cache.set(d, Promise.resolve(M)) : this.cache.set(d, Promise.resolve(null)), M;
+        this.cache.set(g, T), y.use(T);
+        const x = await T;
+        return s !== this.cacheGeneration || this.cache.get(g) !== T ? null : (x != null ? x instanceof F ? (this.cache.set(g, new WeakRef(x)), m._resourceRegistry.register(x, g)) : Array.isArray(x) ? this.cache.set(g, Promise.resolve(x)) : this.cache.set(g, Promise.resolve(x)) : this.cache.set(g, Promise.resolve(null)), x);
       } else if (t instanceof F) {
-        s && console.log("Load texture from uri: " + u);
-        const y = await new ze().loadAsync(u);
-        return y ? (y.guid = n.guid, y.flipY = !1, y.needsUpdate = !0, y.colorSpace = t.colorSpace, s && console.log(n, y)) : h && console.warn("failed loading", u), y;
+        r && console.log("Load texture from uri: " + d);
+        const y = await new qe().loadAsync(d);
+        return s !== this.cacheGeneration ? (y?.dispose(), null) : (y ? (y.guid = a.guid, y.flipY = !1, y.needsUpdate = !0, y.colorSpace = t.colorSpace, r && console.log(a, y)) : h && console.warn("failed loading", d), y);
       }
     }
     return null;
   }
-  static maxConcurrent = 50;
-  static queue = new st(m.maxConcurrent, { debug: h != !1 });
-  static assignLODInformation(t, e, s, o, r) {
+  static queue = new rt(_e() ? 20 : 50, { debug: h != !1 });
+  static assignLODInformation(t, e, s, r, i) {
     if (!e) return;
     e.userData || (e.userData = {});
-    const n = new ht(t, s, o, r);
-    e.userData.LODS = n, "source" in e && typeof e.source == "object" && (e.source.LODS = n);
+    const o = new pt(t, s, r, i);
+    e.userData.LODS = o, "source" in e && typeof e.source == "object" && (e.source.LODS = o);
   }
   static getAssignedLODInformation(t) {
     return t ? t.userData?.LODS ? t.userData.LODS : "source" in t && t.source?.LODS ? t.source.LODS : null : null;
@@ -832,21 +898,21 @@ ${t}`), e instanceof WeakRef && (e.deref() || (m.cache.delete(t), h && console.l
 `, e.uuid), e = e.clone(), e.offset = t.offset, e.repeat = t.repeat, e.colorSpace = t.colorSpace, e.magFilter = t.magFilter, e.minFilter = t.minFilter, e.wrapS = t.wrapS, e.wrapT = t.wrapT, e.flipY = t.flipY, e.anisotropy = t.anisotropy, e.mipmaps || (e.generateMipmaps = t.generateMipmaps), e) : t;
   }
 }
-class ht {
+class pt {
   url;
   /** the key to lookup the LOD information */
   key;
   level;
   /** For multi objects (e.g. a group of meshes) this is the index of the object */
   index;
-  constructor(t, e, s, o) {
-    this.url = t, this.key = e, this.level = s, o != null && (this.index = o);
+  constructor(t, e, s, r) {
+    this.url = t, this.key = e, this.level = s, r != null && (this.index = r);
   }
 }
-class ue {
-  static addPromise = (t, e, s, o) => {
-    o.forEach((r) => {
-      r.add(t, e, s);
+class ce {
+  static addPromise = (t, e, s, r) => {
+    r.forEach((i) => {
+      i.add(t, e, s);
     });
   };
   ready;
@@ -876,9 +942,9 @@ class ue {
   _awaiting = [];
   _maxPromisesPerObject = 1;
   constructor(t, e) {
-    const o = Math.max(e.frames ?? 2, 2);
-    this._frame_start = e.waitForFirstCapture ? void 0 : t, this._frames_to_capture = o, this.ready = new Promise((r) => {
-      this._resolve = r;
+    const r = Math.max(e.frames ?? 2, 2);
+    this._frame_start = e.waitForFirstCapture ? void 0 : t, this._frames_to_capture = r, this.ready = new Promise((i) => {
+      this._resolve = i;
     }), this.ready.finally(() => {
       this._resolved = !0, this._awaiting.length = 0;
     }), this._signal = e.signal, this._signal?.addEventListener("abort", () => {
@@ -898,12 +964,12 @@ class ue {
     if (!(this._frame_start !== void 0 && this._currentFrame > this._frame_start + this._frames_to_capture)) {
       if (this._maxPromisesPerObject >= 1)
         if (this._seen.has(e)) {
-          let o = this._seen.get(e);
-          if (o >= this._maxPromisesPerObject) {
+          let r = this._seen.get(e);
+          if (r >= this._maxPromisesPerObject) {
             h && console.warn("PromiseGroup: Already awaiting object ignoring new promise for it.");
             return;
           }
-          this._seen.set(e, o + 1);
+          this._seen.set(e, r + 1);
         } else
           this._seen.set(e, 1);
       this._awaiting.push(s), this._addedCount++, s.finally(() => {
@@ -919,7 +985,7 @@ class ue {
     });
   }
 }
-const k = j("debugprogressive"), gt = j("noprogressive"), de = /* @__PURE__ */ Symbol("Needle:LODSManager"), ce = /* @__PURE__ */ Symbol("Needle:LODState"), U = /* @__PURE__ */ Symbol("Needle:CurrentLOD"), T = { mesh_lod: -1, texture_lod: -1 };
+const $ = N("debugprogressive"), mt = N("noprogressive"), de = /* @__PURE__ */ Symbol("Needle:LODSManager"), fe = /* @__PURE__ */ Symbol("Needle:LODState"), z = /* @__PURE__ */ Symbol("Needle:CurrentLOD"), P = { mesh_lod: -1, texture_lod: -1 };
 class v {
   /**
    * 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.
@@ -927,14 +993,14 @@ class v {
   static debugDrawLine;
   /** @internal */
   static getObjectLODState(t) {
-    return t[ce];
+    return t[fe];
   }
   static addPlugin(t) {
-    z.push(t);
+    q.push(t);
   }
   static removePlugin(t) {
-    const e = z.indexOf(t);
-    e >= 0 && z.splice(e, 1);
+    const e = q.indexOf(t);
+    e >= 0 && q.splice(e, 1);
   }
   /**
    * Gets the LODsManager for the given renderer. If the LODsManager does not exist yet, it will be created.
@@ -952,10 +1018,10 @@ class v {
   }
   renderer;
   context;
-  projectionScreenMatrix = new _e();
+  projectionScreenMatrix = new ve();
   /** @deprecated use static `LODsManager.addPlugin()` method. This getter will be removed in later versions */
   get plugins() {
-    return z;
+    return q;
   }
   /**
    * Force override the LOD level for all objects (meshes + textures) rendered in the scene
@@ -996,13 +1062,13 @@ class v {
    * Call to await LODs loading during the next render cycle.
    */
   awaitLoading(t) {
-    const e = this._promiseGroupIds++, s = new ue(this.#r, { ...t });
+    const e = this._promiseGroupIds++, s = new ce(this.#r, { ...t });
     this._newPromiseGroups.push(s);
-    const o = performance.now();
+    const r = performance.now();
     return s.ready.finally(() => {
-      const r = this._newPromiseGroups.indexOf(s);
-      r >= 0 && (this._newPromiseGroups.splice(r, 1), Le() && performance.measure("LODsManager:awaitLoading", {
-        start: o,
+      const i = this._newPromiseGroups.indexOf(s);
+      i >= 0 && (this._newPromiseGroups.splice(i, 1), be() && performance.measure("LODsManager:awaitLoading", {
+        start: r,
         detail: { id: e, name: t?.name, awaited: s.awaitedCount, resolved: s.resolvedCount }
       }));
     }), s.ready;
@@ -1027,10 +1093,10 @@ class v {
     this.renderer = t, this.context = { ...e };
   }
   #t;
-  #n = new Ne();
+  #o = new Ne();
   #r = 0;
-  #o = 0;
   #i = 0;
+  #n = 0;
   #s = 0;
   _fpsBuffer = [60, 60, 60, 60, 60];
   /**
@@ -1042,11 +1108,11 @@ class v {
     let t = 0;
     this.#t = this.renderer.render;
     const e = this;
-    xe(this.renderer), this.renderer.render = function(s, o) {
-      const r = e.renderer.getRenderTarget();
-      (r == null || "isXRRenderTarget" in r && r.isXRRenderTarget) && (t = 0, e.#r += 1, e.#o = e.#n.getDelta(), e.#i += e.#o, e._fpsBuffer.shift(), e._fpsBuffer.push(1 / e.#o), e.#s = e._fpsBuffer.reduce((l, a) => l + a) / e._fpsBuffer.length, k && e.#r % 200 === 0 && console.log("FPS", Math.round(e.#s), "Interval:", e.#e));
-      const n = t++;
-      e.#t.call(this, s, o), e.onAfterRender(s, o, n);
+    we(this.renderer), this.renderer.render = function(s, r) {
+      const i = e.renderer.getRenderTarget();
+      (i == null || "isXRRenderTarget" in i && i.isXRRenderTarget) && (t = 0, e.#r += 1, e.#i = e.#o.getDelta(), e.#n += e.#i, e._fpsBuffer.shift(), e._fpsBuffer.push(1 / e.#i), e.#s = e._fpsBuffer.reduce((a, l) => a + l) / e._fpsBuffer.length, $ && e.#r % 200 === 0 && console.log("FPS", Math.round(e.#s), "Interval:", e.#e));
+      const o = t++;
+      e.#t.call(this, s, r), e.onAfterRender(s, r, o);
     };
   }
   disable() {
@@ -1057,14 +1123,14 @@ class v {
   }
   onAfterRender(t, e, s) {
     if (this.pause) return;
-    const r = this.renderer.renderLists.get(t, 0).opaque;
-    let n = !0;
-    if (r.length === 1) {
-      const l = r[0].material;
-      (l.name === "EffectMaterial" || l.name === "CopyShader") && (n = !1);
+    const i = this.renderer.renderLists.get(t, 0).opaque;
+    let o = !0;
+    if (i.length === 1) {
+      const a = i[0].material;
+      (a.name === "EffectMaterial" || a.name === "CopyShader") && (o = !1);
     }
-    if ((e.parent && e.parent.type === "CubeCamera" || s >= 1 && e.type === "OrthographicCamera") && (n = !1), n) {
-      if (gt || (this.updateInterval === "auto" ? this.#s < 40 && this.#e < 10 ? (this.#e += 1, k && console.warn("↓ Reducing LOD updates", this.#e, this.#s.toFixed(0))) : this.#s >= 60 && this.#e > 1 && (this.#e -= 1, k && console.warn("↑ Increasing LOD updates", this.#e, this.#s.toFixed(0))) : this.#e = this.updateInterval, this.#e > 0 && this.#r % this.#e != 0))
+    if ((e.parent && e.parent.type === "CubeCamera" || s >= 1 && e.type === "OrthographicCamera") && (o = !1), o) {
+      if (mt || (this.updateInterval === "auto" ? this.#s < 40 && this.#e < 10 ? (this.#e += 1, $ && console.warn("↓ Reducing LOD updates", this.#e, this.#s.toFixed(0))) : this.#s >= 60 && this.#e > 1 && (this.#e -= 1, $ && console.warn("↑ Increasing LOD updates", this.#e, this.#s.toFixed(0))) : this.#e = this.updateInterval, this.#e > 0 && this.#r % this.#e != 0))
         return;
       this.internalUpdate(t, e), this._postprocessPromiseGroups();
     }
@@ -1073,15 +1139,15 @@ class v {
    * Update LODs in a scene
    */
   internalUpdate(t, e) {
-    const s = this.renderer.renderLists.get(t, 0), o = s.opaque;
+    const s = this.renderer.renderLists.get(t, 0), r = s.opaque;
     this.projectionScreenMatrix.multiplyMatrices(e.projectionMatrix, e.matrixWorldInverse);
-    const r = this.targetTriangleDensity;
-    for (const a of o) {
-      if (a.material && (a.geometry?.type === "BoxGeometry" || a.geometry?.type === "BufferGeometry") && (a.material.name === "SphericalGaussianBlur" || a.material.name == "BackgroundCubeMaterial" || a.material.name === "CubemapFromEquirect" || a.material.name === "EquirectangularToCubeUV")) {
-        k && (a.material["NEEDLE_PROGRESSIVE:IGNORE-WARNING"] || (a.material["NEEDLE_PROGRESSIVE:IGNORE-WARNING"] = !0, console.warn("Ignoring skybox or BLIT object", a, a.material.name, a.material.type)));
+    const i = this.targetTriangleDensity;
+    for (const l of r) {
+      if (l.material && (l.geometry?.type === "BoxGeometry" || l.geometry?.type === "BufferGeometry") && (l.material.name === "SphericalGaussianBlur" || l.material.name == "BackgroundCubeMaterial" || l.material.name === "CubemapFromEquirect" || l.material.name === "EquirectangularToCubeUV")) {
+        $ && (l.material["NEEDLE_PROGRESSIVE:IGNORE-WARNING"] || (l.material["NEEDLE_PROGRESSIVE:IGNORE-WARNING"] = !0, console.warn("Ignoring skybox or BLIT object", l, l.material.name, l.material.type)));
         continue;
       }
-      switch (a.material.type) {
+      switch (l.material.type) {
         case "LineBasicMaterial":
         case "LineDashedMaterial":
         case "PointsMaterial":
@@ -1090,38 +1156,38 @@ class v {
         case "MeshDepthMaterial":
           continue;
       }
-      if (k === "color" && a.material && !a.object.progressive_debug_color) {
-        a.object.progressive_debug_color = !0;
-        const d = Math.random() * 16777215, y = new qe({ color: d });
-        a.object.material = y;
+      if ($ === "color" && l.material && !l.object.progressive_debug_color) {
+        l.object.progressive_debug_color = !0;
+        const d = Math.random() * 16777215, g = new Ve({ color: d });
+        l.object.material = g;
       }
-      const u = a.object;
-      (u instanceof V || u.isMesh) && this.updateLODs(t, e, u, r);
+      const u = l.object;
+      (u instanceof X || u.isMesh) && this.updateLODs(t, e, u, i);
     }
-    const n = s.transparent;
-    for (const a of n) {
-      const u = a.object;
-      (u instanceof V || u.isMesh) && this.updateLODs(t, e, u, r);
+    const o = s.transparent;
+    for (const l of o) {
+      const u = l.object;
+      (u instanceof X || u.isMesh) && this.updateLODs(t, e, u, i);
     }
-    const l = s.transmissive;
-    for (const a of l) {
-      const u = a.object;
-      (u instanceof V || u.isMesh) && this.updateLODs(t, e, u, r);
+    const a = s.transmissive;
+    for (const l of a) {
+      const u = l.object;
+      (u instanceof X || u.isMesh) && this.updateLODs(t, e, u, i);
     }
   }
   /** Update the LOD levels for the renderer. */
-  updateLODs(t, e, s, o) {
+  updateLODs(t, e, s, r) {
     s.userData || (s.userData = {});
-    let r = s[ce];
-    if (r || (r = new pt(), s[ce] = r), r.frames++ < 2)
+    let i = s[fe];
+    if (i || (i = new yt(), s[fe] = i), i.frames++ < 2)
       return;
-    for (const l of z)
-      l.onBeforeUpdateLOD?.(this.renderer, t, e, s);
-    const n = this.overrideLodLevel !== void 0 ? this.overrideLodLevel : q;
-    n >= 0 ? (T.mesh_lod = n, T.texture_lod = n) : (this.calculateLodLevel(e, s, r, o, T), T.mesh_lod = Math.round(T.mesh_lod), T.texture_lod = Math.round(T.texture_lod)), T.mesh_lod >= 0 && this.loadProgressiveMeshes(s, T.mesh_lod), s.material && T.texture_lod >= 0 && this.loadProgressiveTextures(s.material, T.texture_lod, n), h && s.material && !s.isGizmo && Ce(s.material);
-    for (const l of z)
-      l.onAfterUpdatedLOD?.(this.renderer, t, e, s, T);
-    r.lastLodLevel_Mesh = T.mesh_lod, r.lastLodLevel_Texture = T.texture_lod;
+    for (const a of q)
+      a.onBeforeUpdateLOD?.(this.renderer, t, e, s);
+    const o = this.overrideLodLevel !== void 0 ? this.overrideLodLevel : V;
+    o >= 0 ? (P.mesh_lod = o, P.texture_lod = o) : (this.calculateLodLevel(e, s, i, r, P), P.mesh_lod = Math.round(P.mesh_lod), P.texture_lod = Math.round(P.texture_lod)), P.mesh_lod >= 0 && this.loadProgressiveMeshes(s, P.mesh_lod), s.material && P.texture_lod >= 0 && this.loadProgressiveTextures(s.material, P.texture_lod, o), h && s.material && !s.isGizmo && ke(s.material);
+    for (const a of q)
+      a.onAfterUpdatedLOD?.(this.renderer, t, e, s, P);
+    i.lastLodLevel_Mesh = P.mesh_lod, i.lastLodLevel_Texture = P.texture_lod;
   }
   /** Load progressive textures for the given material
    * @param material the material to load the textures for
@@ -1131,17 +1197,17 @@ class v {
   loadProgressiveTextures(t, e, s) {
     if (!t) return;
     if (Array.isArray(t)) {
-      for (const r of t)
-        this.loadProgressiveTextures(r, e);
+      for (const i of t)
+        this.loadProgressiveTextures(i, e);
       return;
     }
-    let o = !1;
-    if ((t[U] === void 0 || e < t[U]) && (o = !0), s !== void 0 && s >= 0 && (o = t[U] != s, e = s), o) {
-      t[U] = e;
-      const r = m.assignTextureLOD(t, e).then((n) => {
-        this._lodchangedlisteners.forEach((l) => l({ type: "texture", level: e, object: t }));
+    let r = !1;
+    if ((t[z] === void 0 || e < t[z]) && (r = !0), s !== void 0 && s >= 0 && (r = t[z] != s, e = s), r) {
+      t[z] = e;
+      const i = m.assignTextureLOD(t, e).then((o) => {
+        this._lodchangedlisteners.forEach((a) => a({ type: "texture", level: e, object: t }));
       });
-      ue.addPromise("texture", t, r, this._newPromiseGroups);
+      ce.addPromise("texture", t, i, this._newPromiseGroups);
     }
   }
   /** Load progressive meshes for the given mesh
@@ -1152,143 +1218,143 @@ class v {
    */
   loadProgressiveMeshes(t, e) {
     if (!t) return Promise.resolve(null);
-    let s = t[U] !== e;
-    const o = t["DEBUG:LOD"];
-    if (o != null && (s = t[U] != o, e = o), s) {
-      t[U] = e;
-      const r = t.geometry, n = m.assignMeshLOD(t, e).then((l) => (l && t[U] == e && r != t.geometry && this._lodchangedlisteners.forEach((a) => a({ type: "mesh", level: e, object: t })), l));
-      return ue.addPromise("mesh", t, n, this._newPromiseGroups), n;
+    let s = t[z] !== e;
+    const r = t["DEBUG:LOD"];
+    if (r != null && (s = t[z] != r, e = r), s) {
+      t[z] = e;
+      const i = t.geometry, o = m.assignMeshLOD(t, e).then((a) => (a && t[z] == e && i != t.geometry && this._lodchangedlisteners.forEach((l) => l({ type: "mesh", level: e, object: t })), a));
+      return ce.addPromise("mesh", t, o, this._newPromiseGroups), o;
     }
     return Promise.resolve(null);
   }
   // private testIfLODLevelsAreAvailable() {
-  _sphere = new De();
-  _tempBox = new he();
-  _tempBox2 = new he();
-  tempMatrix = new _e();
-  _tempWorldPosition = new C();
-  _tempBoxSize = new C();
-  _tempBox2Size = new C();
-  static corner0 = new C();
-  static corner1 = new C();
-  static corner2 = new C();
-  static corner3 = new C();
-  static _tempPtInside = new C();
+  _sphere = new Se();
+  _tempBox = new ge();
+  _tempBox2 = new ge();
+  tempMatrix = new ve();
+  _tempWorldPosition = new R();
+  _tempBoxSize = new R();
+  _tempBox2Size = new R();
+  static corner0 = new R();
+  static corner1 = new R();
+  static corner2 = new R();
+  static corner3 = new R();
+  static _tempPtInside = new R();
   static isInside(t, e) {
-    const s = t.min, o = t.max, r = (s.x + o.x) * 0.5, n = (s.y + o.y) * 0.5;
-    return this._tempPtInside.set(r, n, s.z).applyMatrix4(e).z < 0;
+    const s = t.min, r = t.max, i = (s.x + r.x) * 0.5, o = (s.y + r.y) * 0.5;
+    return this._tempPtInside.set(i, o, s.z).applyMatrix4(e).z < 0;
   }
   static skinnedMeshBoundsFrameOffsetCounter = 0;
   static $skinnedMeshBoundsOffset = /* @__PURE__ */ Symbol("gltf-progressive-skinnedMeshBoundsOffset");
   // #region calculateLodLevel
-  calculateLodLevel(t, e, s, o, r) {
+  calculateLodLevel(t, e, s, r, i) {
     if (!e) {
-      r.mesh_lod = -1, r.texture_lod = -1;
+      i.mesh_lod = -1, i.texture_lod = -1;
       return;
     }
     if (!t) {
-      r.mesh_lod = -1, r.texture_lod = -1;
+      i.mesh_lod = -1, i.texture_lod = -1;
       return;
     }
-    let l = 10 + 1, a = !1;
-    if (k && e["DEBUG:LOD"] != null)
+    let a = 10 + 1, l = !1;
+    if ($ && e["DEBUG:LOD"] != null)
       return e["DEBUG:LOD"];
-    const u = m.getMeshLODExtension(e.geometry)?.lods, d = m.getPrimitiveIndex(e.geometry), y = u && u.length > 0, w = m.getMaterialMinMaxLODsCount(e.material), _ = w.min_count !== 1 / 0 && w.min_count >= 0 && w.max_count >= 0;
-    if (!y && !_) {
-      r.mesh_lod = 0, r.texture_lod = 0;
+    const u = m.getMeshLODExtension(e.geometry)?.lods, d = m.getPrimitiveIndex(e.geometry), g = u && u.length > 0, y = m.getMaterialMinMaxLODsCount(e.material), M = y.min_count !== 1 / 0 && y.min_count >= 0 && y.max_count >= 0;
+    if (!g && !M) {
+      i.mesh_lod = 0, i.texture_lod = 0;
       return;
     }
-    y || (a = !0, l = 0);
-    const I = this.renderer.domElement.clientHeight || this.renderer.domElement.height;
-    let M = e.geometry.boundingBox;
+    g || (l = !0, a = 0);
+    const L = this.renderer.domElement.clientHeight || this.renderer.domElement.height;
+    let T = e.geometry.boundingBox;
     if (e.type === "SkinnedMesh") {
-      const c = e;
-      if (!c.boundingBox)
-        c.computeBoundingBox();
+      const x = e;
+      if (!x.boundingBox)
+        x.computeBoundingBox();
       else if (this.skinnedMeshAutoUpdateBoundsInterval > 0) {
-        if (!c[v.$skinnedMeshBoundsOffset]) {
-          const b = v.skinnedMeshBoundsFrameOffsetCounter++;
-          c[v.$skinnedMeshBoundsOffset] = b;
+        if (!x[v.$skinnedMeshBoundsOffset]) {
+          const _ = v.skinnedMeshBoundsFrameOffsetCounter++;
+          x[v.$skinnedMeshBoundsOffset] = _;
         }
-        const g = c[v.$skinnedMeshBoundsOffset];
-        if ((s.frames + g) % this.skinnedMeshAutoUpdateBoundsInterval === 0) {
-          const b = Z(c), B = c.geometry;
-          b && (c.geometry = b), c.computeBoundingBox(), c.geometry = B;
+        const f = x[v.$skinnedMeshBoundsOffset];
+        if ((s.frames + f) % this.skinnedMeshAutoUpdateBoundsInterval === 0) {
+          const _ = ee(x), D = x.geometry;
+          _ && (x.geometry = _), x.computeBoundingBox(), x.geometry = D;
         }
       }
-      M = c.boundingBox;
+      T = x.boundingBox;
     }
-    if (M) {
-      const c = t;
+    if (T) {
+      const x = t;
       if (e.geometry.attributes.color && e.geometry.attributes.color.count < 100 && e.geometry.boundingSphere) {
         this._sphere.copy(e.geometry.boundingSphere), this._sphere.applyMatrix4(e.matrixWorld);
-        const f = t.getWorldPosition(this._tempWorldPosition);
-        if (this._sphere.containsPoint(f)) {
-          r.mesh_lod = 0, r.texture_lod = 0;
+        const c = t.getWorldPosition(this._tempWorldPosition);
+        if (this._sphere.containsPoint(c)) {
+          i.mesh_lod = 0, i.texture_lod = 0;
           return;
         }
       }
-      if (this._tempBox.copy(M), this._tempBox.applyMatrix4(e.matrixWorld), c.isPerspectiveCamera && v.isInside(this._tempBox, this.projectionScreenMatrix)) {
-        r.mesh_lod = 0, r.texture_lod = 0;
+      if (this._tempBox.copy(T), this._tempBox.applyMatrix4(e.matrixWorld), x.isPerspectiveCamera && v.isInside(this._tempBox, this.projectionScreenMatrix)) {
+        i.mesh_lod = 0, i.texture_lod = 0;
         return;
       }
-      if (this._tempBox.applyMatrix4(this.projectionScreenMatrix), this.renderer.xr.enabled && c.isPerspectiveCamera && c.fov > 70) {
-        const f = this._tempBox.min, p = this._tempBox.max;
-        let O = f.x, S = f.y, G = p.x, Y = p.y;
-        const ee = 2, ne = 1.5, te = (f.x + p.x) * 0.5, se = (f.y + p.y) * 0.5;
-        O = (O - te) * ee + te, S = (S - se) * ee + se, G = (G - te) * ee + te, Y = (Y - se) * ee + se;
-        const Re = O < 0 && G > 0 ? 0 : Math.min(Math.abs(f.x), Math.abs(p.x)), $e = S < 0 && Y > 0 ? 0 : Math.min(Math.abs(f.y), Math.abs(p.y)), ie = Math.max(Re, $e);
-        s.lastCentrality = (ne - ie) * (ne - ie) * (ne - ie);
+      if (this._tempBox.applyMatrix4(this.projectionScreenMatrix), this.renderer.xr.enabled && x.isPerspectiveCamera && x.fov > 70) {
+        const c = this._tempBox.min, p = this._tempBox.max;
+        let w = c.x, b = c.y, A = p.x, Y = p.y;
+        const te = 2, ne = 1.5, se = (c.x + p.x) * 0.5, re = (c.y + p.y) * 0.5;
+        w = (w - se) * te + se, b = (b - re) * te + re, A = (A - se) * te + se, Y = (Y - re) * te + re;
+        const $e = w < 0 && A > 0 ? 0 : Math.min(Math.abs(c.x), Math.abs(p.x)), Be = b < 0 && Y > 0 ? 0 : Math.min(Math.abs(c.y), Math.abs(p.y)), ae = Math.max($e, Be);
+        s.lastCentrality = (ne - ae) * (ne - ae) * (ne - ae);
       } else
         s.lastCentrality = 1;
-      const g = this._tempBox.getSize(this._tempBoxSize);
-      g.multiplyScalar(0.5), screen.availHeight > 0 && I > 0 && g.multiplyScalar(I / screen.availHeight), t.isPerspectiveCamera ? g.x *= t.aspect : t.isOrthographicCamera;
-      const b = t.matrixWorldInverse, B = this._tempBox2;
-      B.copy(M), B.applyMatrix4(e.matrixWorld), B.applyMatrix4(b);
-      const D = B.getSize(this._tempBox2Size), N = Math.max(D.x, D.y);
-      if (Math.max(g.x, g.y) != 0 && N != 0 && (g.z = D.z / Math.max(D.x, D.y) * Math.max(g.x, g.y)), s.lastScreenCoverage = Math.max(g.x, g.y, g.z), s.lastScreenspaceVolume.copy(g), s.lastScreenCoverage *= s.lastCentrality, k && v.debugDrawLine) {
-        const f = this.tempMatrix.copy(this.projectionScreenMatrix);
-        f.invert();
-        const p = v.corner0, O = v.corner1, S = v.corner2, G = v.corner3;
-        p.copy(this._tempBox.min), O.copy(this._tempBox.max), O.x = p.x, S.copy(this._tempBox.max), S.y = p.y, G.copy(this._tempBox.max);
-        const Y = (p.z + G.z) * 0.5;
-        p.z = O.z = S.z = G.z = Y, p.applyMatrix4(f), O.applyMatrix4(f), S.applyMatrix4(f), G.applyMatrix4(f), v.debugDrawLine(p, O, 255), v.debugDrawLine(p, S, 255), v.debugDrawLine(O, G, 255), v.debugDrawLine(S, G, 255);
+      const f = this._tempBox.getSize(this._tempBoxSize);
+      f.multiplyScalar(0.5), screen.availHeight > 0 && L > 0 && f.multiplyScalar(L / screen.availHeight), t.isPerspectiveCamera ? f.x *= t.aspect : t.isOrthographicCamera;
+      const _ = t.matrixWorldInverse, D = this._tempBox2;
+      D.copy(T), D.applyMatrix4(e.matrixWorld), D.applyMatrix4(_);
+      const I = D.getSize(this._tempBox2Size), C = Math.max(I.x, I.y);
+      if (Math.max(f.x, f.y) != 0 && C != 0 && (f.z = I.z / Math.max(I.x, I.y) * Math.max(f.x, f.y)), s.lastScreenCoverage = Math.max(f.x, f.y, f.z), s.lastScreenspaceVolume.copy(f), s.lastScreenCoverage *= s.lastCentrality, $ && v.debugDrawLine) {
+        const c = this.tempMatrix.copy(this.projectionScreenMatrix);
+        c.invert();
+        const p = v.corner0, w = v.corner1, b = v.corner2, A = v.corner3;
+        p.copy(this._tempBox.min), w.copy(this._tempBox.max), w.x = p.x, b.copy(this._tempBox.max), b.y = p.y, A.copy(this._tempBox.max);
+        const Y = (p.z + A.z) * 0.5;
+        p.z = w.z = b.z = A.z = Y, p.applyMatrix4(c), w.applyMatrix4(c), b.applyMatrix4(c), A.applyMatrix4(c), v.debugDrawLine(p, w, 255), v.debugDrawLine(p, b, 255), v.debugDrawLine(w, A, 255), v.debugDrawLine(b, A, 255);
       }
-      let L = 999;
+      let O = 999;
       if (u && s.lastScreenCoverage > 0)
-        for (let f = 0; f < u.length; f++) {
-          const p = u[f], S = (p.densities?.[d] || p.density || 1e-5) / s.lastScreenCoverage;
-          if (d > 0 && Le() && !p.densities && !globalThis["NEEDLE:MISSING_LOD_PRIMITIVE_DENSITIES"] && (window["NEEDLE:MISSING_LOD_PRIMITIVE_DENSITIES"] = !0, console.warn("[Needle Progressive] Detected usage of mesh without primitive densities. This might cause incorrect LOD level selection: Consider re-optimizing your model by updating your Needle Integration, Needle glTF Pipeline or running optimization again on Needle Cloud.")), S < o) {
-            L = f;
+        for (let c = 0; c < u.length; c++) {
+          const p = u[c], b = (p.densities?.[d] || p.density || 1e-5) / s.lastScreenCoverage;
+          if (d > 0 && be() && !p.densities && !globalThis["NEEDLE:MISSING_LOD_PRIMITIVE_DENSITIES"] && (window["NEEDLE:MISSING_LOD_PRIMITIVE_DENSITIES"] = !0, console.warn("[Needle Progressive] Detected usage of mesh without primitive densities. This might cause incorrect LOD level selection: Consider re-optimizing your model by updating your Needle Integration, Needle glTF Pipeline or running optimization again on Needle Cloud.")), b < r) {
+            O = c;
             break;
           }
         }
-      L < l && (l = L, a = !0);
+      O < a && (a = O, l = !0);
     }
-    if (a ? r.mesh_lod = l : r.mesh_lod = s.lastLodLevel_Mesh, k && r.mesh_lod != s.lastLodLevel_Mesh) {
-      const g = u?.[r.mesh_lod];
-      g && console.log(`Mesh LOD changed: ${s.lastLodLevel_Mesh} → ${r.mesh_lod} (density: ${g.densities?.[d].toFixed(0)}) | ${e.name}`);
+    if (l ? i.mesh_lod = a : i.mesh_lod = s.lastLodLevel_Mesh, $ && i.mesh_lod != s.lastLodLevel_Mesh) {
+      const f = u?.[i.mesh_lod];
+      f && console.log(`Mesh LOD changed: ${s.lastLodLevel_Mesh} → ${i.mesh_lod} (density: ${f.densities?.[d].toFixed(0)}) | ${e.name}`);
     }
-    if (_) {
-      const c = "saveData" in globalThis.navigator && globalThis.navigator.saveData === !0;
+    if (M) {
+      const x = "saveData" in globalThis.navigator && globalThis.navigator.saveData === !0;
       if (s.lastLodLevel_Texture < 0) {
-        if (r.texture_lod = w.max_count - 1, k) {
-          const g = w.lods[w.max_count - 1];
-          k && console.log(`First Texture LOD ${r.texture_lod} (${g.max_height}px) - ${e.name}`);
+        if (i.texture_lod = y.max_count - 1, $) {
+          const f = y.lods[y.max_count - 1];
+          $ && console.log(`First Texture LOD ${i.texture_lod} (${f.max_height}px) - ${e.name}`);
         }
       } else {
-        const g = s.lastScreenspaceVolume.x + s.lastScreenspaceVolume.y + s.lastScreenspaceVolume.z;
-        let b = s.lastScreenCoverage * 4;
-        this.context?.engine === "model-viewer" && (b *= 1.5);
-        const D = I / window.devicePixelRatio * b;
-        let N = !1;
-        for (let P = w.lods.length - 1; P >= 0; P--) {
-          const L = w.lods[P];
-          if (!(c && L.max_height >= 2048) && !(Ae() && L.max_height > 4096) && (L.max_height > D || !N && P === 0)) {
-            if (N = !0, r.texture_lod = P, k && r.texture_lod < s.lastLodLevel_Texture) {
-              const x = L.max_height;
-              console.log(`Texture LOD changed: ${s.lastLodLevel_Texture} → ${r.texture_lod} = ${x}px
-Screensize: ${D.toFixed(0)}px, Coverage: ${(100 * s.lastScreenCoverage).toFixed(2)}%, Volume ${g.toFixed(1)}
+        const f = s.lastScreenspaceVolume.x + s.lastScreenspaceVolume.y + s.lastScreenspaceVolume.z;
+        let _ = s.lastScreenCoverage * 4;
+        this.context?.engine === "model-viewer" && (_ *= 1.5);
+        const I = L / window.devicePixelRatio * _;
+        let C = !1;
+        for (let W = y.lods.length - 1; W >= 0; W--) {
+          const O = y.lods[W];
+          if (!(x && O.max_height >= 2048) && !(_e() && O.max_height > 4096) && (O.max_height > I || !C && W === 0)) {
+            if (C = !0, i.texture_lod = W, $ && i.texture_lod < s.lastLodLevel_Texture) {
+              const S = O.max_height;
+              console.log(`Texture LOD changed: ${s.lastLodLevel_Texture} → ${i.texture_lod} = ${S}px
+Screensize: ${I.toFixed(0)}px, Coverage: ${(100 * s.lastScreenCoverage).toFixed(2)}%, Volume ${f.toFixed(1)}
 ${e.name}`);
             }
             break;
@@ -1296,86 +1362,86 @@ ${e.name}`);
         }
       }
     } else
-      r.texture_lod = 0;
+      i.texture_lod = 0;
   }
 }
-class pt {
+class yt {
   frames = 0;
   lastLodLevel_Mesh = -1;
   lastLodLevel_Texture = -1;
   lastScreenCoverage = 0;
-  lastScreenspaceVolume = new C();
+  lastScreenspaceVolume = new R();
   lastCentrality = 0;
 }
-const ve = /* @__PURE__ */ Symbol("NEEDLE_mesh_lod"), re = /* @__PURE__ */ Symbol("NEEDLE_texture_lod");
-let fe = null;
-function Ie() {
-  const i = mt();
-  i && (i.mapURLs(function(t) {
-    return be(), t;
-  }), be(), fe?.disconnect(), fe = new MutationObserver((t) => {
+const Me = /* @__PURE__ */ Symbol("NEEDLE_mesh_lod"), ie = /* @__PURE__ */ Symbol("NEEDLE_texture_lod");
+let he = null;
+function Re() {
+  const n = xt();
+  n && (n.mapURLs(function(t) {
+    return De(), t;
+  }), De(), he?.disconnect(), he = new MutationObserver((t) => {
     t.forEach((e) => {
       e.addedNodes.forEach((s) => {
-        s instanceof HTMLElement && s.tagName.toLowerCase() === "model-viewer" && ke(s);
+        s instanceof HTMLElement && s.tagName.toLowerCase() === "model-viewer" && Ie(s);
       });
     });
-  }), fe.observe(document, { childList: !0, subtree: !0 }));
+  }), he.observe(document, { childList: !0, subtree: !0 }));
 }
-function mt() {
+function xt() {
   if (typeof customElements > "u") return null;
-  const i = customElements.get("model-viewer");
-  return i || (customElements.whenDefined("model-viewer").then(() => {
-    console.debug("[gltf-progressive] model-viewer defined"), Ie();
+  const n = customElements.get("model-viewer");
+  return n || (customElements.whenDefined("model-viewer").then(() => {
+    console.debug("[gltf-progressive] model-viewer defined"), Re();
   }), null);
 }
-function be() {
+function De() {
   if (typeof document > "u") return;
   document.querySelectorAll("model-viewer").forEach((t) => {
-    ke(t);
+    Ie(t);
   });
 }
-const Me = /* @__PURE__ */ new WeakSet();
-let yt = 0;
-function ke(i) {
-  if (!i || Me.has(i))
+const Oe = /* @__PURE__ */ new WeakSet();
+let wt = 0;
+function Ie(n) {
+  if (!n || Oe.has(n))
     return null;
-  Me.add(i), console.debug("[gltf-progressive] found new model-viewer..." + ++yt + `
-`, i.getAttribute("src"));
+  Oe.add(n), console.debug("[gltf-progressive] found new model-viewer..." + ++wt + `
+`, n.getAttribute("src"));
   let t = null, e = null, s = null;
-  for (let o = i; o != null; o = Object.getPrototypeOf(o)) {
-    const r = Object.getOwnPropertySymbols(o), n = r.find((u) => u.toString() == "Symbol(renderer)"), l = r.find((u) => u.toString() == "Symbol(scene)"), a = r.find((u) => u.toString() == "Symbol(needsRender)");
-    !t && n != null && (t = i[n].threeRenderer), !e && l != null && (e = i[l]), !s && a != null && (s = i[a]);
+  for (let r = n; r != null; r = Object.getPrototypeOf(r)) {
+    const i = Object.getOwnPropertySymbols(r), o = i.find((u) => u.toString() == "Symbol(renderer)"), a = i.find((u) => u.toString() == "Symbol(scene)"), l = i.find((u) => u.toString() == "Symbol(needsRender)");
+    !t && o != null && (t = n[o].threeRenderer), !e && a != null && (e = n[a]), !s && l != null && (s = n[l]);
   }
   if (t && e) {
-    let o = function() {
+    let r = function() {
       if (s) {
-        let n = 0, l = setInterval(() => {
-          if (n++ > 5) {
-            clearInterval(l);
+        let o = 0, a = setInterval(() => {
+          if (o++ > 5) {
+            clearInterval(a);
             return;
           }
-          s?.call(i);
+          s?.call(n);
         }, 300);
       }
     };
     console.debug("[gltf-progressive] setup model-viewer");
-    const r = v.get(t, { engine: "model-viewer" });
-    return v.addPlugin(new xt()), r.enable(), r.addEventListener("changed", () => {
-      s?.call(i);
-    }), i.addEventListener("model-visibility", (n) => {
-      n.detail.visible && s?.call(i);
-    }), i.addEventListener("load", () => {
-      o();
+    const i = v.get(t, { engine: "model-viewer" });
+    return v.addPlugin(new _t()), i.enable(), i.addEventListener("changed", () => {
+      s?.call(n);
+    }), n.addEventListener("model-visibility", (o) => {
+      o.detail.visible && s?.call(n);
+    }), n.addEventListener("load", () => {
+      r();
     }), () => {
-      r.disable();
+      i.disable();
     };
   }
   return null;
 }
-class xt {
+class _t {
   _didWarnAboutMissingUrl = !1;
-  onBeforeUpdateLOD(t, e, s, o) {
-    this.tryParseMeshLOD(e, o), this.tryParseTextureLOD(e, o);
+  onBeforeUpdateLOD(t, e, s, r) {
+    this.tryParseMeshLOD(e, r), this.tryParseTextureLOD(e, r);
   }
   getUrl(t) {
     if (!t)
@@ -1390,101 +1456,101 @@ class xt {
     return t.element;
   }
   tryParseTextureLOD(t, e) {
-    if (e[re] == !0) return;
-    e[re] = !0;
-    const s = this.tryGetCurrentGLTF(t), o = this.tryGetCurrentModelViewer(t), r = this.getUrl(o);
-    if (r && s && e.material) {
-      let n = function(a) {
-        if (a[re] == !0) return;
-        a[re] = !0, a.userData && (a.userData.LOD = -1);
-        const u = Object.keys(a);
+    if (e[ie] == !0) return;
+    e[ie] = !0;
+    const s = this.tryGetCurrentGLTF(t), r = this.tryGetCurrentModelViewer(t), i = this.getUrl(r);
+    if (i && s && e.material) {
+      let o = function(l) {
+        if (l[ie] == !0) return;
+        l[ie] = !0, l.userData && (l.userData.LOD = -1);
+        const u = Object.keys(l);
         for (let d = 0; d < u.length; d++) {
-          const y = u[d], w = a[y];
-          if (w?.isTexture === !0) {
-            const _ = w.userData?.associations?.textures;
-            if (_ == null) continue;
-            const I = s.parser.json.textures[_];
-            if (!I) {
-              console.warn("Texture data not found for texture index " + _);
+          const g = u[d], y = l[g];
+          if (y?.isTexture === !0) {
+            const M = y.userData?.associations?.textures;
+            if (M == null) continue;
+            const L = s.parser.json.textures[M];
+            if (!L) {
+              console.warn("Texture data not found for texture index " + M);
               continue;
             }
-            if (I?.extensions?.[W]) {
-              const M = I.extensions[W];
-              M && r && m.registerTexture(r, w, M.lods.length, _, M);
+            if (L?.extensions?.[U]) {
+              const T = L.extensions[U];
+              T && i && m.registerTexture(i, y, T.lods.length, M, T);
             }
           }
         }
       };
-      const l = e.material;
-      if (Array.isArray(l)) for (const a of l) n(a);
-      else n(l);
+      const a = e.material;
+      if (Array.isArray(a)) for (const l of a) o(l);
+      else o(a);
     }
   }
   tryParseMeshLOD(t, e) {
-    if (e[ve] == !0) return;
-    e[ve] = !0;
-    const s = this.tryGetCurrentModelViewer(t), o = this.getUrl(s);
-    if (!o)
+    if (e[Me] == !0) return;
+    e[Me] = !0;
+    const s = this.tryGetCurrentModelViewer(t), r = this.getUrl(s);
+    if (!r)
       return;
-    const r = e.userData?.gltfExtensions?.[W];
-    if (r && o) {
-      const n = e.uuid;
-      m.registerMesh(o, n, e, 0, r.lods.length, r);
+    const i = e.userData?.gltfExtensions?.[U];
+    if (i && r) {
+      const o = e.uuid;
+      m.registerMesh(r, o, e, 0, i.lods.length, i);
     }
   }
 }
-function wt(...i) {
-  let t, e, s, o;
-  switch (i.length) {
+function Lt(...n) {
+  let t, e, s, r;
+  switch (n.length) {
     case 2:
-      [s, e] = i, o = {};
+      [s, e] = n, r = {};
       break;
     case 3:
-      [s, e, o] = i;
+      [s, e, r] = n;
       break;
     case 4:
-      [t, e, s, o] = i;
+      [t, e, s, r] = n;
       break;
     default:
       throw new Error("Invalid arguments");
   }
-  xe(e), Se(s), Te(s, {
+  we(e), Te(s), Ae(s, {
     progressive: !0,
-    ...o?.hints
-  }), s.register((n) => new m(n));
-  const r = v.get(e);
-  return o?.enableLODsManager !== !1 && r.enable(), r;
+    ...r?.hints
+  }), s.register((o) => new m(o));
+  const i = v.get(e);
+  return r?.enableLODsManager !== !1 && i.enable(), i;
 }
-Ie();
-if (!rt) {
-  const i = {
+Re();
+if (!nt) {
+  const n = {
     gltfProgressive: {
-      useNeedleProgressive: wt,
+      useNeedleProgressive: Lt,
       LODsManager: v,
-      configureLoader: Te,
-      getRaycastMesh: Z,
-      useRaycastMeshes: nt
+      configureLoader: Ae,
+      getRaycastMesh: ee,
+      useRaycastMeshes: lt
     }
   };
   if (!globalThis.Needle)
-    globalThis.Needle = i;
+    globalThis.Needle = n;
   else
-    for (const t in i)
-      globalThis.Needle[t] = i[t];
+    for (const t in n)
+      globalThis.Needle[t] = n[t];
 }
 export {
-  W as EXTENSION_NAME,
+  U as EXTENSION_NAME,
   v as LODsManager,
   m as NEEDLE_progressive,
-  je as VERSION,
-  Se as addDracoAndKTX2Loaders,
-  Te as configureLoader,
-  xe as createLoaders,
-  Z as getRaycastMesh,
-  Ie as patchModelViewer,
-  ot as registerRaycastMesh,
-  Qe as setDracoDecoderLocation,
-  Je as setKTX2TranscoderLocation,
-  wt as useNeedleProgressive,
-  nt as useRaycastMeshes
+  Ke as VERSION,
+  Te as addDracoAndKTX2Loaders,
+  Ae as configureLoader,
+  we as createLoaders,
+  ee as getRaycastMesh,
+  Re as patchModelViewer,
+  at as registerRaycastMesh,
+  Je as setDracoDecoderLocation,
+  Ze as setKTX2TranscoderLocation,
+  Lt as useNeedleProgressive,
+  lt as useRaycastMeshes
 };