@needle-tools/engine 4.13.0 → 4.13.1-next.6cb1b73

package/dist/{gltf-progressive-eiJCrjLb.js → gltf-progressive-CsyU_5lc.js}

@@ -1,10 +1,10 @@
-import { BufferGeometry as J, Mesh as q, Box3 as ge, Vector3 as A, Sphere as Oe, CompressedTexture as Ge, Texture as E, Matrix3 as Fe, InterleavedBuffer as We, InterleavedBufferAttribute as Ue, BufferAttribute as ze, TextureLoader as Ee, Matrix4 as _e, Clock as Ne, MeshStandardMaterial as qe } from "./three-VvRoMeIN.js";
+import { BufferGeometry as q, Mesh as V, Box3 as ge, Vector3 as C, Sphere as Oe, CompressedTexture as Ge, Texture as F, Matrix3 as Fe, InterleavedBuffer as We, InterleavedBufferAttribute as Ue, BufferAttribute as ze, TextureLoader as Ne, Matrix4 as _e, Clock as Ee, MeshStandardMaterial as qe } from "./three-VvRoMeIN.js";
 import { DRACOLoader as Ve, KTX2Loader as Xe, MeshoptDecoder as je, GLTFLoader as xe } from "./three-examples-BhfOE7NG.js";
 const Ke = "";
 globalThis.GLTF_PROGRESSIVE_VERSION = Ke;
 console.debug("[gltf-progressive] version -");
-let k = "https://www.gstatic.com/draco/versioned/decoders/1.5.7/", V = "https://cdn.needle.tools/static/three/0.179.1/basis2/";
-const Ye = k, He = V, Se = new URL(k + "draco_decoder.js");
+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, He = X, Se = new URL(R + "draco_decoder.js");
 Se.searchParams.append("range", "true");
 fetch(Se, {
   method: "GET",
@@ -12,30 +12,30 @@ fetch(Se, {
     Range: "bytes=0-1"
   }
 }).catch((i) => {
-  console.debug(`Failed to fetch remote Draco decoder from ${k} (offline: ${typeof navigator < "u" ? navigator.onLine : "unknown"})`), k === Ye && Je("./include/draco/"), V === He && Ze("./include/ktx2/");
+  console.debug(`Failed to fetch remote Draco decoder from ${R} (offline: ${typeof navigator < "u" ? navigator.onLine : "unknown"})`), R === Ye && Je("./include/draco/"), X === He && Ze("./include/ktx2/");
 }).finally(() => {
-  Pe();
+  Te();
 });
 const Qe = () => ({
-  dracoDecoderPath: k,
-  ktx2TranscoderPath: V
+  dracoDecoderPath: R,
+  ktx2TranscoderPath: X
 });
 function Je(i) {
-  k = i, P && P[pe] != k ? (console.debug("Updating Draco decoder path to " + i), P[pe] = k, P.setDecoderPath(k), P.preload()) : console.debug("Setting Draco decoder path to " + i);
+  R = i, A && A[pe] != R ? (console.debug("Updating Draco decoder path to " + i), A[pe] = R, A.setDecoderPath(R), A.preload()) : console.debug("Setting Draco decoder path to " + i);
 }
 function Ze(i) {
-  V = i, R && R.transcoderPath != V ? (console.debug("Updating KTX2 transcoder path to " + i), R.setTranscoderPath(V), R.init()) : console.debug("Setting KTX2 transcoder path to " + 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 we(i) {
-  return Pe(), i ? R.detectSupport(i) : i !== null && console.warn("No renderer provided to detect ktx2 support - loading KTX2 textures might fail"), { dracoLoader: P, ktx2Loader: R, meshoptDecoder: ne };
+  return Te(), i ? $.detectSupport(i) : i !== null && console.warn("No renderer provided to detect ktx2 support - loading KTX2 textures might fail"), { dracoLoader: A, ktx2Loader: $, meshoptDecoder: ne };
 }
-function Te(i) {
-  i.dracoLoader || i.setDRACOLoader(P), i.ktx2Loader || i.setKTX2Loader(R), i.meshoptDecoder || i.setMeshoptDecoder(ne);
+function Pe(i) {
+  i.dracoLoader || i.setDRACOLoader(A), i.ktx2Loader || i.setKTX2Loader($), i.meshoptDecoder || i.setMeshoptDecoder(ne);
 }
 const pe = /* @__PURE__ */ Symbol("dracoDecoderPath");
-let P, ne, R;
-function Pe() {
-  P || (P = new Ve(), P[pe] = k, P.setDecoderPath(k), P.setDecoderConfig({ type: "js" }), P.preload()), R || (R = new Xe(), R.setTranscoderPath(V), R.init()), ne || (ne = je);
+let A, ne, $;
+function Te() {
+  A || (A = new Ve(), A[pe] = R, A.setDecoderPath(R), A.setDecoderConfig({ type: "js" }), A.preload()), $ || ($ = new Xe(), $.setTranscoderPath(X), $.init()), ne || (ne = je);
 }
 const me = /* @__PURE__ */ new WeakMap();
 function Ae(i, t) {
@@ -54,8 +54,8 @@ function tt(...i) {
   return i[0] = e, et?.call(this, ...i);
 }
 xe.prototype.load = tt;
-X("debugprogressive");
-function X(i) {
+j("debugprogressive");
+function j(i) {
   if (typeof window > "u") return !1;
   const e = new URL(window.location.href).searchParams.get(i);
   return e == null || e === "0" || e === "false" ? !1 : e === "" ? !0 : e;
@@ -71,10 +71,10 @@ function st(i, t) {
   }
   return t;
 }
-function Ie() {
-  return K !== void 0 || (K = /iPhone|iPad|iPod|Android|IEMobile/i.test(navigator.userAgent), X("debugprogressive") && console.log("[glTF Progressive]: isMobileDevice", K)), K;
+function Ce() {
+  return Y !== void 0 || (Y = /iPhone|iPad|iPod|Android|IEMobile/i.test(navigator.userAgent), j("debugprogressive") && console.log("[glTF Progressive]: isMobileDevice", Y)), Y;
 }
-let K;
+let Y;
 function Me() {
   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);
@@ -116,7 +116,7 @@ class rt {
 }
 const nt = typeof window > "u" && typeof document > "u", ye = /* @__PURE__ */ Symbol("needle:raycast-mesh");
 function Z(i) {
-  return i?.[ye] instanceof J ? i[ye] : null;
+  return i?.[ye] instanceof q ? i[ye] : null;
 }
 function ot(i, t) {
   if ((i.type === "Mesh" || i.type === "SkinnedMesh") && !Z(i)) {
@@ -126,56 +126,56 @@ function ot(i, t) {
 }
 function it(i = !0) {
   if (i) {
-    if (Y) return;
-    const t = Y = q.prototype.raycast;
-    q.prototype.raycast = function(e, s) {
+    if (H) return;
+    const t = H = V.prototype.raycast;
+    V.prototype.raycast = function(e, s) {
       const n = this, r = Z(n);
       let o;
       r && n.isMesh && (o = n.geometry, n.geometry = r), t.call(this, e, s), o && (n.geometry = o);
     };
   } else {
-    if (!Y) return;
-    q.prototype.raycast = Y, Y = null;
+    if (!H) return;
+    V.prototype.raycast = H, H = null;
   }
 }
-let Y = null;
+let H = null;
 function at(i) {
-  const t = new J();
+  const t = new q();
   for (const e in i.attributes)
     t.setAttribute(e, i.getAttribute(e));
   return t.setIndex(i.getIndex()), t;
 }
-const U = new Array(), g = X("debugprogressive");
-let Q, N = -1;
-if (g) {
+const z = new Array(), h = j("debugprogressive");
+let J, E = -1;
+if (h) {
   let i = function() {
-    N += 1, N >= t && (N = -1), console.log(`Toggle LOD level [${N}]`);
+    E += 1, E >= t && (E = -1), console.log(`Toggle LOD level [${E}]`);
   }, t = 6;
   window.addEventListener("keyup", (e) => {
-    e.key === "p" && i(), e.key === "w" && (Q = !Q, console.log(`Toggle wireframe [${Q}]`));
+    e.key === "p" && i(), e.key === "w" && (J = !J, console.log(`Toggle wireframe [${J}]`));
     const s = parseInt(e.key);
-    !isNaN(s) && s >= 0 && (N = s, console.log(`Set LOD level to [${N}]`));
+    !isNaN(s) && s >= 0 && (E = s, console.log(`Set LOD level to [${E}]`));
   });
 }
-function Ce(i) {
-  if (g && Q !== void 0)
+function ke(i) {
+  if (h && J !== void 0)
     if (Array.isArray(i))
       for (const t of i)
-        Ce(t);
-    else i && "wireframe" in i && (i.wireframe = Q === !0);
+        ke(t);
+    else i && "wireframe" in i && (i.wireframe = J === !0);
 }
-const H = new Array();
+const Q = new Array();
 let lt = 0;
-const ut = Ie() ? 2 : 10;
+const ut = Ce() ? 2 : 10;
 function dt(i) {
-  if (H.length < ut) {
-    const s = H.length;
-    g && console.warn(`[Worker] Creating new worker #${s}`);
+  if (Q.length < ut) {
+    const s = Q.length;
+    h && console.warn(`[Worker] Creating new worker #${s}`);
     const n = Le.createWorker(i || {});
-    return H.push(n), n;
+    return Q.push(n), n;
   }
-  const t = lt++ % H.length;
-  return H[t];
+  const t = lt++ % Q.length;
+  return Q[t];
 }
 class Le {
   constructor(t, e) {
@@ -231,7 +231,7 @@ class Le {
 }
 function ct(i) {
   for (const t of i.geometries) {
-    const e = t.geometry, s = new J();
+    const e = t.geometry, s = new q();
     if (s.name = e.name || "", e.index) {
       const n = e.index;
       s.setIndex(le(n));
@@ -245,16 +245,16 @@ function ct(i) {
         const o = e.morphAttributes[n].map((l) => le(l));
         s.morphAttributes[n] = o;
       }
-    if (s.morphTargetsRelative = e.morphTargetsRelative ?? !1, s.boundingBox = new ge(), s.boundingBox.min = new A(
+    if (s.morphTargetsRelative = e.morphTargetsRelative ?? !1, s.boundingBox = new ge(), s.boundingBox.min = new C(
       e.boundingBox?.min.x,
       e.boundingBox?.min.y,
       e.boundingBox?.min.z
-    ), s.boundingBox.max = new A(
+    ), s.boundingBox.max = new C(
       e.boundingBox?.max.x,
       e.boundingBox?.max.y,
       e.boundingBox?.max.z
     ), s.boundingSphere = new Oe(
-      new A(
+      new C(
         e.boundingSphere?.center.x,
         e.boundingSphere?.center.y,
         e.boundingSphere?.center.z
@@ -285,7 +285,7 @@ function ct(i) {
         e.colorSpace
       );
     } else
-      s = new E(
+      s = new F(
         e.image,
         e.mapping,
         e.wrapS,
@@ -313,11 +313,11 @@ function le(i) {
   } else "isBufferAttribute" in i && i.isBufferAttribute && (t = new ze(i.array, i.itemSize, i.normalized), t.usage = i.usage, t.gpuType = i.gpuType, t.updateRanges = i.updateRanges);
   return t;
 }
-const ft = X("gltf-progressive-worker"), ht = X("gltf-progressive-reduce-mipmaps"), ue = /* @__PURE__ */ Symbol("needle-progressive-texture"), F = "NEEDLE_progressive";
-class y {
+const ft = j("gltf-progressive-worker"), ht = j("gltf-progressive-reduce-mipmaps"), ue = /* @__PURE__ */ Symbol("needle-progressive-texture"), W = "NEEDLE_progressive";
+class m {
   /** The name of the extension */
   get name() {
-    return F;
+    return W;
   }
   // #region PUBLIC API
   static getMeshLODExtension(t) {
@@ -340,7 +340,7 @@ class y {
         this.getMaterialMinMaxLODsCount(l, e);
       return t[n] = e, e;
     }
-    if (g === "verbose" && console.log("getMaterialMinMaxLODsCount", t), t.type === "ShaderMaterial" || t.type === "RawShaderMaterial") {
+    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;
@@ -352,7 +352,7 @@ class y {
         a?.isTexture === !0 && o(a, e);
       }
     else
-      g && console.warn(`[getMaterialMinMaxLODsCount] Unsupported material type: ${t.type}`);
+      h && console.warn(`[getMaterialMinMaxLODsCount] Unsupported material type: ${t.type}`);
     return t[n] = e, e;
     function o(l, a) {
       const u = s.getAssignedLODInformation(l);
@@ -360,9 +360,9 @@ class y {
         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 p = 0; p < d.lods.length; p++) {
-            const L = d.lods[p];
-            L.width && (a.lods[p] = a.lods[p] || { min_height: 1 / 0, max_height: 0 }, a.lods[p].min_height = Math.min(a.lods[p].min_height, L.height), a.lods[p].max_height = Math.max(a.lods[p].max_height, L.height));
+          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));
           }
         }
       }
@@ -416,20 +416,20 @@ class y {
    */
   static assignMeshLOD(t, e) {
     if (!t) return Promise.resolve(null);
-    if (t instanceof q || t.isMesh === !0) {
+    if (t instanceof V || t.isMesh === !0) {
       const s = t.geometry, n = this.getAssignedLODInformation(s);
       if (!n)
         return Promise.resolve(null);
-      for (const r of U)
+      for (const r of z)
         r.onBeforeGetLODMesh?.(t, e);
-      return t["LOD:requested level"] = e, y.getOrLoadLOD(s, e).then((r) => {
+      return t["LOD:requested level"] = e, m.getOrLoadLOD(s, e).then((r) => {
         if (Array.isArray(r)) {
           const o = n.index || 0;
           r = r[o];
         }
-        return t["LOD:requested level"] === e && (delete t["LOD:requested level"], r && s != r && (r?.isBufferGeometry ? t.geometry = r : g && console.error("Invalid LOD geometry", r))), r;
+        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));
-    } else g && console.error("Invalid call to assignMeshLOD: Request mesh LOD but the object is not a mesh", t);
+    } else h && console.error("Invalid call to assignMeshLOD: Request mesh LOD but the object is not a mesh", t);
     return Promise.resolve(null);
   }
   static assignTextureLOD(t, e = 0) {
@@ -479,7 +479,7 @@ class y {
         return l;
       });
     }
-    if (t instanceof E || t.isTexture === !0) {
+    if (t instanceof F || t.isTexture === !0) {
       const s = t;
       return this.assignTextureLODForSlot(s, e, null, null);
     }
@@ -487,25 +487,25 @@ class y {
   }
   // #region INTERNAL
   static assignTextureLODForSlot(t, e, s, n) {
-    return t?.isTexture !== !0 ? Promise.resolve(null) : n === "glyphMap" ? Promise.resolve(t) : y.getOrLoadLOD(t, e).then((r) => {
+    return t?.isTexture !== !0 ? Promise.resolve(null) : n === "glyphMap" ? Promise.resolve(t) : m.getOrLoadLOD(t, e).then((r) => {
       if (Array.isArray(r))
         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 && n) {
           const o = s[n];
-          if (o && !g) {
+          if (o && !h) {
             const l = this.getAssignedLODInformation(o);
             if (l && l?.level < e)
-              return g === "verbose" && console.warn("Assigned texture level is already higher: ", l.level, e, s, o, r), null;
+              return h === "verbose" && console.warn("Assigned texture level is already higher: ", l.level, e, s, o, r), null;
           }
           if (ht && r.mipmaps) {
             const l = r.mipmaps.length;
-            r.mipmaps.length = Math.min(r.mipmaps.length, 3), l !== r.mipmaps.length && g && console.debug(`Reduced mipmap count from ${l} to ${r.mipmaps.length} for ${r.uuid}: ${r.image?.width}x${r.image?.height}.`);
+            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}.`);
           }
           s[n] = r;
         }
         return r;
-      } else g == "verbose" && console.warn("No LOD found for", t, e);
+      } else h == "verbose" && console.warn("No LOD found for", t, e);
       return null;
     }).catch((r) => (console.error("Error loading LOD", t, r), null));
   }
@@ -513,13 +513,13 @@ class y {
   url;
   constructor(t) {
     const e = t.options.path;
-    g && console.log("Progressive extension registered for", e), this.parser = t, this.url = e;
+    h && console.log("Progressive extension registered for", e), this.parser = t, this.url = e;
   }
   _isLoadingMesh;
   loadMesh = (t) => {
     if (this._isLoadingMesh) return null;
-    const e = this.parser.json.meshes[t]?.extensions?.[F];
-    return e ? (this._isLoadingMesh = !0, this.parser.getDependency("mesh", t).then((s) => (this._isLoadingMesh = !1, s && y.registerMesh(this.url, e.guid, s, e.lods?.length, 0, e), s))) : null;
+    const e = this.parser.json.meshes[t]?.extensions?.[W];
+    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;
   // loadTexture = (textureIndex: number) => {
@@ -536,30 +536,30 @@ class y {
   //     });
   // }
   afterRoot(t) {
-    return g && console.log("AFTER", this.url, t), this.parser.json.textures?.forEach((e, s) => {
+    return h && console.log("AFTER", this.url, t), this.parser.json.textures?.forEach((e, s) => {
       if (e?.extensions) {
-        const n = e?.extensions[F];
+        const n = e?.extensions[W];
         if (n) {
           if (!n.lods) {
-            g && console.warn("Texture has no LODs", n);
+            h && console.warn("Texture has no LODs", n);
             return;
           }
           let r = !1;
           for (const o of this.parser.associations.keys())
-            o.isTexture === !0 && this.parser.associations.get(o)?.textures === s && (r = !0, y.registerTexture(this.url, o, n.lods?.length, s, n));
+            o.isTexture === !0 && this.parser.associations.get(o)?.textures === s && (r = !0, m.registerTexture(this.url, o, n.lods?.length, s, n));
           r || this.parser.getDependency("texture", s).then((o) => {
-            o && y.registerTexture(this.url, o, n.lods?.length, s, n);
+            o && m.registerTexture(this.url, o, n.lods?.length, s, n);
           });
         }
       }
     }), this.parser.json.meshes?.forEach((e, s) => {
       if (e?.extensions) {
-        const n = e?.extensions[F];
+        const n = e?.extensions[W];
         if (n && n.lods) {
           for (const r of this.parser.associations.keys())
             if (r.isMesh) {
               const o = this.parser.associations.get(r);
-              o?.meshes === s && y.registerMesh(this.url, n.guid, r, n.lods.length, o.primitives, n);
+              o?.meshes === s && m.registerMesh(this.url, n.guid, r, n.lods.length, o.primitives, n);
             }
         }
       }
@@ -570,16 +570,16 @@ class y {
    */
   static registerTexture = (t, e, s, n, r) => {
     if (!e) {
-      g && console.error("!! gltf-progressive: Called register texture without texture");
+      h && console.error("!! gltf-progressive: Called register texture without texture");
       return;
     }
-    if (g) {
+    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[${n}] "${e.name || e.uuid}", Current: ${l}x${a}, Max: ${r.lods[0]?.width}x${r.lods[0]?.height}, uuid: ${e.uuid}`, r, e);
     }
     e.source && (e.source[ue] = r);
     const o = r.guid;
-    y.assignLODInformation(t, e, o, s, n), y.lodInfos.set(o, r), y.lowresCache.set(o, e);
+    m.assignLODInformation(t, e, o, s, n), m.lodInfos.set(o, r), m.lowresCache.set(o, new WeakRef(e));
   };
   /**
    * Register a mesh with LOD information
@@ -587,151 +587,228 @@ class y {
   static registerMesh = (t, e, s, n, r, o) => {
     const l = s.geometry;
     if (!l) {
-      g && console.warn("gltf-progressive: Register mesh without geometry");
+      h && console.warn("gltf-progressive: Register mesh without geometry");
       return;
     }
-    l.userData || (l.userData = {}), g && console.log("> Progressive: register mesh " + s.name, { index: r, uuid: s.uuid }, o, s), y.assignLODInformation(t, l, e, n, r), y.lodInfos.set(e, o);
-    let a = y.lowresCache.get(e);
-    a ? a.push(s.geometry) : a = [s.geometry], y.lowresCache.set(e, a), n > 0 && !Z(s) && ot(s, l);
-    for (const u of U)
-      u.onRegisteredNewMesh?.(s, o);
+    l.userData || (l.userData = {}), h && console.log("> Progressive: register mesh " + s.name, { index: r, uuid: s.uuid }, o, s), m.assignLODInformation(t, l, e, n, r), 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)), n > 0 && !Z(s) && ot(s, l);
+    for (const d of z)
+      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.
+   * @param guid Optional GUID to dispose resources for a specific model. If omitted, all cached resources are cleared.
+   */
+  static dispose(t) {
+    if (t) {
+      this.lodInfos.delete(t);
+      const e = this.lowresCache.get(t);
+      if (e) {
+        const s = e.deref();
+        if (s) {
+          if (s.isTexture)
+            s.dispose();
+          else if (Array.isArray(s))
+            for (const n of s) n.dispose();
+        }
+        this.lowresCache.delete(t);
+      }
+      for (const [s, n] of this.cache)
+        s.includes(t) && (this._disposeCacheEntry(n), this.cache.delete(s));
+    } else {
+      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 n of s) n.dispose();
+        }
+      }
+      this.lowresCache.clear();
+      for (const [, e] of this.cache)
+        this._disposeCacheEntry(e);
+      this.cache.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(() => {
+    });
+  }
   /** A map of key = asset uuid and value = LOD information */
   static lodInfos = /* @__PURE__ */ new Map();
-  /** cache of already loaded mesh lods */
-  static previouslyLoaded = /* @__PURE__ */ new Map();
-  /** this contains the geometry/textures that were originally loaded */
+  /** cache of already loaded mesh lods. Uses WeakRef for single resources to allow garbage collection when unused. */
+  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();
+  /**
+   * FinalizationRegistry to automatically clean up `previouslyLoaded` cache entries
+   * when their associated three.js resources are garbage collected by the browser.
+   * The held value is the cache key string used in `previouslyLoaded`.
+   */
+  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}`)));
+  });
   static workers = [];
   static _workersIndex = 0;
   static async getOrLoadLOD(t, e) {
-    const s = g == "verbose", n = this.getAssignedLODInformation(t);
+    const s = h == "verbose", n = this.getAssignedLODInformation(t);
     if (!n)
-      return g && console.warn(`[gltf-progressive] No LOD information found: ${t.name}, uuid: ${t.uuid}, type: ${t.type}`, t), null;
+      return h && console.warn(`[gltf-progressive] No LOD information found: ${t.name}, uuid: ${t.uuid}, type: ${t.type}`, t), null;
     const r = n?.key;
     let o;
     if (t.isTexture === !0) {
       const a = t;
       a.source && a.source[ue] && (o = a.source[ue]);
     }
-    if (o || (o = y.lodInfos.get(r)), !o)
-      g && console.warn(`Can not load LOD ${e}: no LOD info found for "${r}" ${t.name}`, t.type, y.lodInfos);
+    if (o || (o = m.lodInfos.get(r)), !o)
+      h && console.warn(`Can not load LOD ${e}: no LOD info found for "${r}" ${t.name}`, t.type, m.lodInfos);
     else {
       if (e > 0) {
         let d = !1;
-        const p = Array.isArray(o.lods);
-        if (p && e >= o.lods.length ? d = !0 : p || (d = !0), d)
-          return this.lowresCache.get(r);
+        const y = Array.isArray(o.lods);
+        if (y && e >= o.lods.length ? d = !0 : y || (d = !0), d) {
+          const w = this.lowresCache.get(r);
+          if (w) {
+            const L = w.deref();
+            if (L) return L;
+            this.lowresCache.delete(r), h && console.log(`[gltf-progressive] Lowres cache entry was GC'd: ${r}`);
+          }
+          return null;
+        }
       }
       const a = Array.isArray(o.lods) ? o.lods[e]?.path : o.lods;
       if (!a)
-        return g && !o["missing:uri"] && (o["missing:uri"] = !0, console.warn("Missing uri for progressive asset for LOD " + e, o)), null;
+        return h && !o["missing:uri"] && (o["missing:uri"] = !0, console.warn("Missing uri for progressive asset for LOD " + e, o)), null;
       const u = st(n.url, a);
       if (u.endsWith(".glb") || u.endsWith(".gltf")) {
         if (!o.guid)
           return console.warn("missing pointer for glb/gltf texture", o), null;
-        const d = u + "_" + o.guid, p = await this.queue.slot(u), L = this.previouslyLoaded.get(d);
-        if (L !== void 0) {
-          s && console.log(`LOD ${e} was already loading/loaded: ${d}`);
-          let c = await L.catch((O) => (console.error(`Error loading LOD ${e} from ${u}
-`, O), null)), x = !1;
-          if (c == null || (c instanceof E && t instanceof E ? c.image?.data || c.source?.data ? c = this.copySettings(t, c) : (x = !0, this.previouslyLoaded.delete(d)) : c instanceof J && t instanceof J && (c.attributes.position?.array || (x = !0, this.previouslyLoaded.delete(d)))), !x)
-            return c;
-        }
-        if (!p.use)
-          return g && console.log(`LOD ${e} was aborted: ${u}`), null;
-        const _ = o, I = new Promise(async (c, x) => {
+        const d = u + "_" + o.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, M = !1;
+              if (g instanceof F && t instanceof F ? g.image?.data || g.source?.data ? g = this.copySettings(t, g) : M = !0 : g instanceof q && t instanceof q && (g.attributes.position?.array || (M = !0)), !M)
+                return g;
+            }
+            this.cache.delete(d), h && console.log(`[gltf-progressive] Re-loading GC'd/disposed resource: ${d}`);
+          } else {
+            let c = await w.catch((M) => (console.error(`Error loading LOD ${e} from ${u}
+`, M), 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 q && t instanceof q && (c.attributes.position?.array || (g = !0, this.cache.delete(d)))), !g)
+              return c;
+          }
+        if (!y.use)
+          return h && console.log(`LOD ${e} was aborted: ${u}`), null;
+        const L = o, k = new Promise(async (c, g) => {
           if (ft) {
-            const m = await (await dt({})).load(u);
-            if (m.textures.length > 0)
-              for (const f of m.textures) {
-                let h = f.texture;
-                return y.assignLODInformation(n.url, h, r, e, void 0), t instanceof E && (h = this.copySettings(t, h)), h && (h.guid = _.guid), c(h);
+            const x = await (await dt({})).load(u);
+            if (x.textures.length > 0)
+              for (const f of x.textures) {
+                let p = f.texture;
+                return m.assignLODInformation(n.url, p, r, e, void 0), t instanceof F && (p = this.copySettings(t, p)), p && (p.guid = L.guid), c(p);
               }
-            if (m.geometries.length > 0) {
+            if (x.geometries.length > 0) {
               const f = new Array();
-              for (const h of m.geometries) {
-                const v = h.geometry;
-                y.assignLODInformation(n.url, v, r, e, h.primitiveIndex), f.push(v);
+              for (const p of x.geometries) {
+                const D = p.geometry;
+                m.assignLODInformation(n.url, D, r, e, p.primitiveIndex), f.push(D);
               }
               return c(f);
             }
             return c(null);
           }
-          const O = new xe();
-          Te(O), g && (await new Promise((w) => setTimeout(w, 1e3)), s && console.warn("Start loading (delayed) " + u, _.guid));
+          const M = new xe();
+          Pe(M), h && (await new Promise((_) => setTimeout(_, 1e3)), s && console.warn("Start loading (delayed) " + u, L.guid));
           let B = u;
-          if (_ && Array.isArray(_.lods)) {
-            const w = _.lods[e];
-            w.hash && (B += "?v=" + w.hash);
+          if (L && Array.isArray(L.lods)) {
+            const _ = L.lods[e];
+            _.hash && (B += "?v=" + _.hash);
           }
-          const M = await O.loadAsync(B).catch((w) => (console.error(`Error loading LOD ${e} from ${u}
-`, w), c(null)));
-          if (!M)
+          const b = await M.loadAsync(B).catch((_) => (console.error(`Error loading LOD ${e} from ${u}
+`, _), c(null)));
+          if (!b)
             return c(null);
-          const z = M.parser;
-          s && console.log("Loading finished " + u, _.guid);
-          let S = 0;
-          if (M.parser.json.textures) {
-            let w = !1;
-            for (const m of M.parser.json.textures) {
-              if (m?.extensions) {
-                const f = m?.extensions[F];
-                if (f?.guid && f.guid === _.guid) {
-                  w = !0;
+          const N = b.parser;
+          s && console.log("Loading finished " + u, L.guid);
+          let P = 0;
+          if (b.parser.json.textures) {
+            let _ = !1;
+            for (const x of b.parser.json.textures) {
+              if (x?.extensions) {
+                const f = x?.extensions[W];
+                if (f?.guid && f.guid === L.guid) {
+                  _ = !0;
                   break;
                 }
               }
-              S++;
+              P++;
             }
-            if (w) {
-              let m = await z.getDependency("texture", S);
-              return m && y.assignLODInformation(n.url, m, r, e, void 0), s && console.log('change "' + t.name + '" → "' + m.name + '"', u, S, m, d), t instanceof E && (m = this.copySettings(t, m)), m && (m.guid = _.guid), c(m);
-            } else g && console.warn("Could not find texture with guid", _.guid, M.parser.json);
+            if (_) {
+              let x = await N.getDependency("texture", P);
+              return x && m.assignLODInformation(n.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 = L.guid), c(x);
+            } else h && console.warn("Could not find texture with guid", L.guid, b.parser.json);
           }
-          if (S = 0, M.parser.json.meshes) {
-            let w = !1;
-            for (const m of M.parser.json.meshes) {
-              if (m?.extensions) {
-                const f = m?.extensions[F];
-                if (f?.guid && f.guid === _.guid) {
-                  w = !0;
+          if (P = 0, b.parser.json.meshes) {
+            let _ = !1;
+            for (const x of b.parser.json.meshes) {
+              if (x?.extensions) {
+                const f = x?.extensions[W];
+                if (f?.guid && f.guid === L.guid) {
+                  _ = !0;
                   break;
                 }
               }
-              S++;
+              P++;
             }
-            if (w) {
-              const m = await z.getDependency("mesh", S);
-              if (s && console.log(`Loaded Mesh "${m.name}"`, u, S, m, d), m.isMesh === !0) {
-                const f = m.geometry;
-                return y.assignLODInformation(n.url, f, r, e, 0), c(f);
+            if (_) {
+              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(n.url, f, r, e, 0), c(f);
               } else {
                 const f = new Array();
-                for (let h = 0; h < m.children.length; h++) {
-                  const v = m.children[h];
-                  if (v.isMesh === !0) {
-                    const b = v.geometry;
-                    y.assignLODInformation(n.url, b, r, e, h), f.push(b);
+                for (let p = 0; p < x.children.length; p++) {
+                  const D = x.children[p];
+                  if (D.isMesh === !0) {
+                    const S = D.geometry;
+                    m.assignLODInformation(n.url, S, r, e, p), f.push(S);
                   }
                 }
                 return c(f);
               }
-            } else g && console.warn("Could not find mesh with guid", _.guid, M.parser.json);
+            } else h && console.warn("Could not find mesh with guid", L.guid, b.parser.json);
           }
           return c(null);
         });
-        return this.previouslyLoaded.set(d, I), p.use(I), await I;
-      } else if (t instanceof E) {
+        this.cache.set(d, k), y.use(k);
+        const v = await k;
+        return v != null ? v instanceof F ? (this.cache.set(d, new WeakRef(v)), m._resourceRegistry.register(v, d)) : Array.isArray(v) ? this.cache.set(d, Promise.resolve(v)) : this.cache.set(d, Promise.resolve(v)) : this.cache.set(d, Promise.resolve(null)), v;
+      } else if (t instanceof F) {
         s && console.log("Load texture from uri: " + u);
-        const p = await new Ee().loadAsync(u);
-        return p ? (p.guid = o.guid, p.flipY = !1, p.needsUpdate = !0, p.colorSpace = t.colorSpace, s && console.log(o, p)) : g && console.warn("failed loading", u), p;
+        const y = await new Ne().loadAsync(u);
+        return y ? (y.guid = o.guid, y.flipY = !1, y.needsUpdate = !0, y.colorSpace = t.colorSpace, s && console.log(o, y)) : h && console.warn("failed loading", u), y;
       }
     }
     return null;
   }
   static maxConcurrent = 50;
-  static queue = new rt(y.maxConcurrent, { debug: g != !1 });
+  static queue = new rt(m.maxConcurrent, { debug: h != !1 });
   static assignLODInformation(t, e, s, n, r) {
     if (!e) return;
     e.userData || (e.userData = {});
@@ -743,7 +820,7 @@ class y {
   }
   // private static readonly _copiedTextures: WeakMap<Texture, Texture> = new Map();
   static copySettings(t, e) {
-    return e ? (g === "verbose" && console.debug(`Copy texture settings
+    return e ? (h === "verbose" && console.debug(`Copy texture settings
 `, t.uuid, `
 `, 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;
   }
@@ -808,7 +885,7 @@ class de {
   _seen = /* @__PURE__ */ new WeakMap();
   add(t, e, s) {
     if (this._resolved) {
-      g && console.warn("PromiseGroup: Trying to add a promise to a resolved group, ignoring.");
+      h && console.warn("PromiseGroup: Trying to add a promise to a resolved group, ignoring.");
       return;
     }
     if (!(this._frame_start !== void 0 && this._currentFrame > this._frame_start + this._frames_to_capture)) {
@@ -816,7 +893,7 @@ class de {
         if (this._seen.has(e)) {
           let n = this._seen.get(e);
           if (n >= this._maxPromisesPerObject) {
-            g && console.warn("PromiseGroup: Already awaiting object ignoring new promise for it.");
+            h && console.warn("PromiseGroup: Already awaiting object ignoring new promise for it.");
             return;
           }
           this._seen.set(e, n + 1);
@@ -835,8 +912,8 @@ class de {
     });
   }
 }
-const C = X("debugprogressive"), pt = X("noprogressive"), ce = /* @__PURE__ */ Symbol("Needle:LODSManager"), fe = /* @__PURE__ */ Symbol("Needle:LODState"), W = /* @__PURE__ */ Symbol("Needle:CurrentLOD"), T = { mesh_lod: -1, texture_lod: -1 };
-let oe = class D {
+const I = j("debugprogressive"), pt = j("noprogressive"), ce = /* @__PURE__ */ Symbol("Needle:LODSManager"), fe = /* @__PURE__ */ Symbol("Needle:LODState"), U = /* @__PURE__ */ Symbol("Needle:CurrentLOD"), T = { mesh_lod: -1, texture_lod: -1 };
+let oe = class O {
   /** 
    * 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.
    */
@@ -846,11 +923,11 @@ let oe = class D {
     return t[fe];
   }
   static addPlugin(t) {
-    U.push(t);
+    z.push(t);
   }
   static removePlugin(t) {
-    const e = U.indexOf(t);
-    e >= 0 && U.splice(e, 1);
+    const e = z.indexOf(t);
+    e >= 0 && z.splice(e, 1);
   }
   /**
    * Gets the LODsManager for the given renderer. If the LODsManager does not exist yet, it will be created.  
@@ -860,7 +937,7 @@ let oe = class D {
   static get(t, e) {
     if (t[ce])
       return console.debug("[gltf-progressive] LODsManager already exists for this renderer"), t[ce];
-    const s = new D(t, {
+    const s = new O(t, {
       engine: "unknown",
       ...e
     });
@@ -871,7 +948,7 @@ let oe = class D {
   projectionScreenMatrix = new _e();
   /** @deprecated use static `LODsManager.addPlugin()` method. This getter will be removed in later versions */
   get plugins() {
-    return U;
+    return z;
   }
   /**
    * Force override the LOD level for all objects (meshes + textures) rendered in the scene
@@ -943,7 +1020,7 @@ let oe = class D {
     this.renderer = t, this.context = { ...e };
   }
   #t;
-  #o = new Ne();
+  #o = new Ee();
   #r = 0;
   #n = 0;
   #i = 0;
@@ -960,7 +1037,7 @@ let oe = class D {
     const e = this;
     we(this.renderer), this.renderer.render = function(s, n) {
       const r = e.renderer.getRenderTarget();
-      (r == null || "isXRRenderTarget" in r && r.isXRRenderTarget) && (t = 0, e.#r += 1, e.#n = e.#o.getDelta(), e.#i += e.#n, e._fpsBuffer.shift(), e._fpsBuffer.push(1 / e.#n), e.#s = e._fpsBuffer.reduce((l, a) => l + a) / e._fpsBuffer.length, C && e.#r % 200 === 0 && console.log("FPS", Math.round(e.#s), "Interval:", e.#e));
+      (r == null || "isXRRenderTarget" in r && r.isXRRenderTarget) && (t = 0, e.#r += 1, e.#n = e.#o.getDelta(), e.#i += e.#n, e._fpsBuffer.shift(), e._fpsBuffer.push(1 / e.#n), e.#s = e._fpsBuffer.reduce((l, a) => l + a) / e._fpsBuffer.length, I && e.#r % 200 === 0 && console.log("FPS", Math.round(e.#s), "Interval:", e.#e));
       const o = t++;
       e.#t.call(this, s, n), e.onAfterRender(s, n, o);
     };
@@ -980,7 +1057,7 @@ let oe = class D {
       (l.name === "EffectMaterial" || l.name === "CopyShader") && (o = !1);
     }
     if ((e.parent && e.parent.type === "CubeCamera" || s >= 1 && e.type === "OrthographicCamera") && (o = !1), o) {
-      if (pt || (this.updateInterval === "auto" ? this.#s < 40 && this.#e < 10 ? (this.#e += 1, C && console.warn("↓ Reducing LOD updates", this.#e, this.#s.toFixed(0))) : this.#s >= 60 && this.#e > 1 && (this.#e -= 1, C && console.warn("↑ Increasing LOD updates", this.#e, this.#s.toFixed(0))) : this.#e = this.updateInterval, this.#e > 0 && this.#r % this.#e != 0))
+      if (pt || (this.updateInterval === "auto" ? this.#s < 40 && this.#e < 10 ? (this.#e += 1, I && console.warn("↓ Reducing LOD updates", this.#e, this.#s.toFixed(0))) : this.#s >= 60 && this.#e > 1 && (this.#e -= 1, I && 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();
     }
@@ -994,7 +1071,7 @@ let oe = class D {
     const r = this.targetTriangleDensity;
     for (const a of n) {
       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")) {
-        C && (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)));
+        I && (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)));
         continue;
       }
       switch (a.material.type) {
@@ -1006,23 +1083,23 @@ let oe = class D {
         case "MeshDepthMaterial":
           continue;
       }
-      if (C === "color" && a.material && !a.object.progressive_debug_color) {
+      if (I === "color" && a.material && !a.object.progressive_debug_color) {
         a.object.progressive_debug_color = !0;
-        const d = Math.random() * 16777215, p = new qe({ color: d });
-        a.object.material = p;
+        const d = Math.random() * 16777215, y = new qe({ color: d });
+        a.object.material = y;
       }
       const u = a.object;
-      (u instanceof q || u.isMesh) && this.updateLODs(t, e, u, r);
+      (u instanceof V || u.isMesh) && this.updateLODs(t, e, u, r);
     }
     const o = s.transparent;
     for (const a of o) {
       const u = a.object;
-      (u instanceof q || u.isMesh) && this.updateLODs(t, e, u, r);
+      (u instanceof V || u.isMesh) && this.updateLODs(t, e, u, r);
     }
     const l = s.transmissive;
     for (const a of l) {
       const u = a.object;
-      (u instanceof q || u.isMesh) && this.updateLODs(t, e, u, r);
+      (u instanceof V || u.isMesh) && this.updateLODs(t, e, u, r);
     }
   }
   /** Update the LOD levels for the renderer. */
@@ -1031,11 +1108,11 @@ let oe = class D {
     let r = s[fe];
     if (r || (r = new mt(), s[fe] = r), r.frames++ < 2)
       return;
-    for (const l of U)
+    for (const l of z)
       l.onBeforeUpdateLOD?.(this.renderer, t, e, s);
-    const o = this.overrideLodLevel !== void 0 ? this.overrideLodLevel : N;
-    o >= 0 ? (T.mesh_lod = o, T.texture_lod = o) : (this.calculateLodLevel(e, s, r, n, 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, o), g && s.material && !s.isGizmo && Ce(s.material);
-    for (const l of U)
+    const o = this.overrideLodLevel !== void 0 ? this.overrideLodLevel : E;
+    o >= 0 ? (T.mesh_lod = o, T.texture_lod = o) : (this.calculateLodLevel(e, s, r, n, 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, o), h && s.material && !s.isGizmo && ke(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;
   }
@@ -1052,9 +1129,9 @@ let oe = class D {
       return;
     }
     let n = !1;
-    if ((t[W] === void 0 || e < t[W]) && (n = !0), s !== void 0 && s >= 0 && (n = t[W] != s, e = s), n) {
-      t[W] = e;
-      const r = y.assignTextureLOD(t, e).then((o) => {
+    if ((t[U] === void 0 || e < t[U]) && (n = !0), s !== void 0 && s >= 0 && (n = t[U] != s, e = s), n) {
+      t[U] = e;
+      const r = m.assignTextureLOD(t, e).then((o) => {
         this._lodchangedlisteners.forEach((l) => l({ type: "texture", level: e, object: t }));
       });
       de.addPromise("texture", t, r, this._newPromiseGroups);
@@ -1068,11 +1145,11 @@ let oe = class D {
    */
   loadProgressiveMeshes(t, e) {
     if (!t) return Promise.resolve(null);
-    let s = t[W] !== e;
+    let s = t[U] !== e;
     const n = t["DEBUG:LOD"];
-    if (n != null && (s = t[W] != n, e = n), s) {
-      t[W] = e;
-      const r = t.geometry, o = y.assignMeshLOD(t, e).then((l) => (l && t[W] == e && r != t.geometry && this._lodchangedlisteners.forEach((a) => a({ type: "mesh", level: e, object: t })), l));
+    if (n != null && (s = t[U] != n, e = n), s) {
+      t[U] = e;
+      const r = t.geometry, o = 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 de.addPromise("mesh", t, o, this._newPromiseGroups), o;
     }
     return Promise.resolve(null);
@@ -1082,14 +1159,14 @@ let oe = class D {
   _tempBox = new ge();
   _tempBox2 = new ge();
   tempMatrix = new _e();
-  _tempWorldPosition = new A();
-  _tempBoxSize = new A();
-  _tempBox2Size = new A();
-  static corner0 = new A();
-  static corner1 = new A();
-  static corner2 = new A();
-  static corner3 = new A();
-  static _tempPtInside = new A();
+  _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();
   static isInside(t, e) {
     const s = t.min, n = t.max, r = (s.x + n.x) * 0.5, o = (s.y + n.y) * 0.5;
     return this._tempPtInside.set(r, o, s.z).applyMatrix4(e).z < 0;
@@ -1107,34 +1184,34 @@ let oe = class D {
       return;
     }
     let l = 10 + 1, a = !1;
-    if (C && e["DEBUG:LOD"] != null)
+    if (I && e["DEBUG:LOD"] != null)
       return e["DEBUG:LOD"];
-    const u = y.getMeshLODExtension(e.geometry)?.lods, d = y.getPrimitiveIndex(e.geometry), p = u && u.length > 0, L = y.getMaterialMinMaxLODsCount(e.material), _ = L.min_count !== 1 / 0 && L.min_count >= 0 && L.max_count >= 0;
-    if (!p && !_) {
+    const u = m.getMeshLODExtension(e.geometry)?.lods, d = m.getPrimitiveIndex(e.geometry), y = u && u.length > 0, w = m.getMaterialMinMaxLODsCount(e.material), L = w.min_count !== 1 / 0 && w.min_count >= 0 && w.max_count >= 0;
+    if (!y && !L) {
       r.mesh_lod = 0, r.texture_lod = 0;
       return;
     }
-    p || (a = !0, l = 0);
-    const I = this.renderer.domElement.clientHeight || this.renderer.domElement.height;
-    let G = e.geometry.boundingBox;
+    y || (a = !0, l = 0);
+    const k = this.renderer.domElement.clientHeight || this.renderer.domElement.height;
+    let v = e.geometry.boundingBox;
     if (e.type === "SkinnedMesh") {
       const c = e;
       if (!c.boundingBox)
         c.computeBoundingBox();
       else if (this.skinnedMeshAutoUpdateBoundsInterval > 0) {
-        if (!c[D.$skinnedMeshBoundsOffset]) {
-          const O = D.skinnedMeshBoundsFrameOffsetCounter++;
-          c[D.$skinnedMeshBoundsOffset] = O;
+        if (!c[O.$skinnedMeshBoundsOffset]) {
+          const M = O.skinnedMeshBoundsFrameOffsetCounter++;
+          c[O.$skinnedMeshBoundsOffset] = M;
         }
-        const x = c[D.$skinnedMeshBoundsOffset];
-        if ((s.frames + x) % this.skinnedMeshAutoUpdateBoundsInterval === 0) {
-          const O = Z(c), B = c.geometry;
-          O && (c.geometry = O), c.computeBoundingBox(), c.geometry = B;
+        const g = c[O.$skinnedMeshBoundsOffset];
+        if ((s.frames + g) % this.skinnedMeshAutoUpdateBoundsInterval === 0) {
+          const M = Z(c), B = c.geometry;
+          M && (c.geometry = M), c.computeBoundingBox(), c.geometry = B;
         }
       }
-      G = c.boundingBox;
+      v = c.boundingBox;
     }
-    if (G) {
+    if (v) {
       const c = 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);
@@ -1144,67 +1221,67 @@ let oe = class D {
           return;
         }
       }
-      if (this._tempBox.copy(G), this._tempBox.applyMatrix4(e.matrixWorld), c.isPerspectiveCamera && D.isInside(this._tempBox, this.projectionScreenMatrix)) {
+      if (this._tempBox.copy(v), this._tempBox.applyMatrix4(e.matrixWorld), c.isPerspectiveCamera && O.isInside(this._tempBox, this.projectionScreenMatrix)) {
         r.mesh_lod = 0, r.texture_lod = 0;
         return;
       }
       if (this._tempBox.applyMatrix4(this.projectionScreenMatrix), this.renderer.xr.enabled && c.isPerspectiveCamera && c.fov > 70) {
-        const f = this._tempBox.min, h = this._tempBox.max;
-        let v = f.x, b = f.y, $ = h.x, j = h.y;
-        const ee = 2, ie = 1.5, te = (f.x + h.x) * 0.5, se = (f.y + h.y) * 0.5;
-        v = (v - te) * ee + te, b = (b - se) * ee + se, $ = ($ - te) * ee + te, j = (j - se) * ee + se;
-        const Be = v < 0 && $ > 0 ? 0 : Math.min(Math.abs(f.x), Math.abs(h.x)), $e = b < 0 && j > 0 ? 0 : Math.min(Math.abs(f.y), Math.abs(h.y)), ae = Math.max(Be, $e);
+        const f = this._tempBox.min, p = this._tempBox.max;
+        let D = f.x, S = f.y, G = p.x, K = p.y;
+        const ee = 2, ie = 1.5, te = (f.x + p.x) * 0.5, se = (f.y + p.y) * 0.5;
+        D = (D - te) * ee + te, S = (S - se) * ee + se, G = (G - te) * ee + te, K = (K - se) * ee + se;
+        const $e = D < 0 && G > 0 ? 0 : Math.min(Math.abs(f.x), Math.abs(p.x)), Be = S < 0 && K > 0 ? 0 : Math.min(Math.abs(f.y), Math.abs(p.y)), ae = Math.max($e, Be);
         s.lastCentrality = (ie - ae) * (ie - ae) * (ie - ae);
       } else
         s.lastCentrality = 1;
-      const x = this._tempBox.getSize(this._tempBoxSize);
-      x.multiplyScalar(0.5), screen.availHeight > 0 && I > 0 && x.multiplyScalar(I / screen.availHeight), t.isPerspectiveCamera ? x.x *= t.aspect : t.isOrthographicCamera;
-      const O = t.matrixWorldInverse, B = this._tempBox2;
-      B.copy(G), B.applyMatrix4(e.matrixWorld), B.applyMatrix4(O);
-      const M = B.getSize(this._tempBox2Size), z = Math.max(M.x, M.y);
-      if (Math.max(x.x, x.y) != 0 && z != 0 && (x.z = M.z / Math.max(M.x, M.y) * Math.max(x.x, x.y)), s.lastScreenCoverage = Math.max(x.x, x.y, x.z), s.lastScreenspaceVolume.copy(x), s.lastScreenCoverage *= s.lastCentrality, C && D.debugDrawLine) {
+      const g = this._tempBox.getSize(this._tempBoxSize);
+      g.multiplyScalar(0.5), screen.availHeight > 0 && k > 0 && g.multiplyScalar(k / screen.availHeight), t.isPerspectiveCamera ? g.x *= t.aspect : t.isOrthographicCamera;
+      const M = t.matrixWorldInverse, B = this._tempBox2;
+      B.copy(v), B.applyMatrix4(e.matrixWorld), B.applyMatrix4(M);
+      const b = B.getSize(this._tempBox2Size), N = Math.max(b.x, b.y);
+      if (Math.max(g.x, g.y) != 0 && N != 0 && (g.z = b.z / Math.max(b.x, b.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, I && O.debugDrawLine) {
         const f = this.tempMatrix.copy(this.projectionScreenMatrix);
         f.invert();
-        const h = D.corner0, v = D.corner1, b = D.corner2, $ = D.corner3;
-        h.copy(this._tempBox.min), v.copy(this._tempBox.max), v.x = h.x, b.copy(this._tempBox.max), b.y = h.y, $.copy(this._tempBox.max);
-        const j = (h.z + $.z) * 0.5;
-        h.z = v.z = b.z = $.z = j, h.applyMatrix4(f), v.applyMatrix4(f), b.applyMatrix4(f), $.applyMatrix4(f), D.debugDrawLine(h, v, 255), D.debugDrawLine(h, b, 255), D.debugDrawLine(v, $, 255), D.debugDrawLine(b, $, 255);
+        const p = O.corner0, D = O.corner1, S = O.corner2, G = O.corner3;
+        p.copy(this._tempBox.min), D.copy(this._tempBox.max), D.x = p.x, S.copy(this._tempBox.max), S.y = p.y, G.copy(this._tempBox.max);
+        const K = (p.z + G.z) * 0.5;
+        p.z = D.z = S.z = G.z = K, p.applyMatrix4(f), D.applyMatrix4(f), S.applyMatrix4(f), G.applyMatrix4(f), O.debugDrawLine(p, D, 255), O.debugDrawLine(p, S, 255), O.debugDrawLine(D, G, 255), O.debugDrawLine(S, G, 255);
       }
-      let w = 999;
+      let _ = 999;
       if (u && s.lastScreenCoverage > 0)
         for (let f = 0; f < u.length; f++) {
-          const h = u[f], b = (h.densities?.[d] || h.density || 1e-5) / s.lastScreenCoverage;
-          if (d > 0 && Me() && !h.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 < n) {
-            w = f;
+          const p = u[f], S = (p.densities?.[d] || p.density || 1e-5) / s.lastScreenCoverage;
+          if (d > 0 && Me() && !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 < n) {
+            _ = f;
             break;
           }
         }
-      w < l && (l = w, a = !0);
+      _ < l && (l = _, a = !0);
     }
-    if (a ? r.mesh_lod = l : r.mesh_lod = s.lastLodLevel_Mesh, C && r.mesh_lod != s.lastLodLevel_Mesh) {
-      const x = u?.[r.mesh_lod];
-      x && console.log(`Mesh LOD changed: ${s.lastLodLevel_Mesh} → ${r.mesh_lod} (density: ${x.densities?.[d].toFixed(0)}) | ${e.name}`);
+    if (a ? r.mesh_lod = l : r.mesh_lod = s.lastLodLevel_Mesh, I && 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 (_) {
+    if (L) {
       const c = "saveData" in globalThis.navigator && globalThis.navigator.saveData === !0;
       if (s.lastLodLevel_Texture < 0) {
-        if (r.texture_lod = L.max_count - 1, C) {
-          const x = L.lods[L.max_count - 1];
-          C && console.log(`First Texture LOD ${r.texture_lod} (${x.max_height}px) - ${e.name}`);
+        if (r.texture_lod = w.max_count - 1, I) {
+          const g = w.lods[w.max_count - 1];
+          I && console.log(`First Texture LOD ${r.texture_lod} (${g.max_height}px) - ${e.name}`);
         }
       } else {
-        const x = s.lastScreenspaceVolume.x + s.lastScreenspaceVolume.y + s.lastScreenspaceVolume.z;
-        let O = s.lastScreenCoverage * 4;
-        this.context?.engine === "model-viewer" && (O *= 1.5);
-        const M = I / window.devicePixelRatio * O;
-        let z = !1;
-        for (let S = L.lods.length - 1; S >= 0; S--) {
-          const w = L.lods[S];
-          if (!(c && w.max_height >= 2048) && !(Ie() && w.max_height > 4096) && (w.max_height > M || !z && S === 0)) {
-            if (z = !0, r.texture_lod = S, C && r.texture_lod < s.lastLodLevel_Texture) {
-              const m = w.max_height;
-              console.log(`Texture LOD changed: ${s.lastLodLevel_Texture} → ${r.texture_lod} = ${m}px 
-Screensize: ${M.toFixed(0)}px, Coverage: ${(100 * s.lastScreenCoverage).toFixed(2)}%, Volume ${x.toFixed(1)} 
+        const g = s.lastScreenspaceVolume.x + s.lastScreenspaceVolume.y + s.lastScreenspaceVolume.z;
+        let M = s.lastScreenCoverage * 4;
+        this.context?.engine === "model-viewer" && (M *= 1.5);
+        const b = k / window.devicePixelRatio * M;
+        let N = !1;
+        for (let P = w.lods.length - 1; P >= 0; P--) {
+          const _ = w.lods[P];
+          if (!(c && _.max_height >= 2048) && !(Ce() && _.max_height > 4096) && (_.max_height > b || !N && P === 0)) {
+            if (N = !0, r.texture_lod = P, I && r.texture_lod < s.lastLodLevel_Texture) {
+              const x = _.max_height;
+              console.log(`Texture LOD changed: ${s.lastLodLevel_Texture} → ${r.texture_lod} = ${x}px 
+Screensize: ${b.toFixed(0)}px, Coverage: ${(100 * s.lastScreenCoverage).toFixed(2)}%, Volume ${g.toFixed(1)} 
 ${e.name}`);
             }
             break;
@@ -1220,16 +1297,16 @@ class mt {
   lastLodLevel_Mesh = -1;
   lastLodLevel_Texture = -1;
   lastScreenCoverage = 0;
-  lastScreenspaceVolume = new A();
+  lastScreenspaceVolume = new C();
   lastCentrality = 0;
 }
 const ve = /* @__PURE__ */ Symbol("NEEDLE_mesh_lod"), re = /* @__PURE__ */ Symbol("NEEDLE_texture_lod");
 let he = null;
-function ke() {
+function Ie() {
   const i = yt();
   i && (i.mapURLs(function(t) {
-    return De(), t;
-  }), De(), he?.disconnect(), he = new MutationObserver((t) => {
+    return be(), t;
+  }), be(), he?.disconnect(), he = new MutationObserver((t) => {
     t.forEach((e) => {
       e.addedNodes.forEach((s) => {
         s instanceof HTMLElement && s.tagName.toLowerCase() === "model-viewer" && Re(s);
@@ -1241,21 +1318,21 @@ function yt() {
   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"), ke();
+    console.debug("[gltf-progressive] model-viewer defined"), Ie();
   }), null);
 }
-function De() {
+function be() {
   if (typeof document > "u") return;
   document.querySelectorAll("model-viewer").forEach((t) => {
     Re(t);
   });
 }
-const be = /* @__PURE__ */ new WeakSet();
+const De = /* @__PURE__ */ new WeakSet();
 let xt = 0;
 function Re(i) {
-  if (!i || be.has(i))
+  if (!i || De.has(i))
     return null;
-  be.add(i), console.debug("[gltf-progressive] found new model-viewer..." + ++xt + `
+  De.add(i), console.debug("[gltf-progressive] found new model-viewer..." + ++xt + `
 `, i.getAttribute("src"));
   let t = null, e = null, s = null;
   for (let n = i; n != null; n = Object.getPrototypeOf(n)) {
@@ -1315,18 +1392,18 @@ class wt {
         a[re] = !0, a.userData && (a.userData.LOD = -1);
         const u = Object.keys(a);
         for (let d = 0; d < u.length; d++) {
-          const p = u[d], L = a[p];
-          if (L?.isTexture === !0) {
-            const _ = L.userData?.associations?.textures;
-            if (_ == null) continue;
-            const I = s.parser.json.textures[_];
-            if (!I) {
-              console.warn("Texture data not found for texture index " + _);
+          const y = u[d], w = a[y];
+          if (w?.isTexture === !0) {
+            const L = w.userData?.associations?.textures;
+            if (L == null) continue;
+            const k = s.parser.json.textures[L];
+            if (!k) {
+              console.warn("Texture data not found for texture index " + L);
               continue;
             }
-            if (I?.extensions?.[F]) {
-              const G = I.extensions[F];
-              G && r && y.registerTexture(r, L, G.lods.length, _, G);
+            if (k?.extensions?.[W]) {
+              const v = k.extensions[W];
+              v && r && m.registerTexture(r, w, v.lods.length, L, v);
             }
           }
         }
@@ -1342,10 +1419,10 @@ class wt {
     const s = this.tryGetCurrentModelViewer(t), n = this.getUrl(s);
     if (!n)
       return;
-    const r = e.userData?.gltfExtensions?.[F];
+    const r = e.userData?.gltfExtensions?.[W];
     if (r && n) {
       const o = e.uuid;
-      y.registerMesh(n, o, e, 0, r.lods.length, r);
+      m.registerMesh(n, o, e, 0, r.lods.length, r);
     }
   }
 }
@@ -1364,14 +1441,14 @@ function Lt(...i) {
     default:
       throw new Error("Invalid arguments");
   }
-  we(e), Te(s), Ae(s, {
+  we(e), Pe(s), Ae(s, {
     progressive: !0,
     ...n?.hints
-  }), s.register((o) => new y(o));
+  }), s.register((o) => new m(o));
   const r = oe.get(e);
   return n?.enableLODsManager !== !1 && r.enable(), r;
 }
-ke();
+Ie();
 if (!nt) {
   const i = {
     gltfProgressive: {
@@ -1390,8 +1467,8 @@ if (!nt) {
 }
 export {
   oe as LODsManager,
-  y as NEEDLE_progressive,
-  Te as addDracoAndKTX2Loaders,
+  m as NEEDLE_progressive,
+  Pe as addDracoAndKTX2Loaders,
   Ae as configureLoader,
   we as createLoaders,
   Z as getRaycastMesh,