@needle-tools/engine 4.16.10 → 4.16.12

package/dist/{gltf-progressive-CzxjNmG6.js → gltf-progressive-DMK8kKVB.js}

@@ -1,10 +1,10 @@
-import { BufferGeometry as V, Mesh as X, Box3 as pe, Vector3 as A, Sphere as Te, CompressedTexture as Fe, Texture as F, Matrix3 as We, InterleavedBuffer as Ue, InterleavedBufferAttribute as ze, BufferAttribute as qe, TextureLoader as Ne, Matrix4 as ve, Clock as Ee, MeshStandardMaterial as Ve } from "./three.js";
+import { BufferGeometry as V, Mesh as X, Box3 as pe, Vector3 as R, Sphere as Te, CompressedTexture as Fe, Texture as F, Matrix3 as We, InterleavedBuffer as Ue, InterleavedBufferAttribute as ze, BufferAttribute as qe, TextureLoader as Ne, Matrix4 as ve, Clock as Ee, MeshStandardMaterial as Ve } from "./three.js";
 import { DRACOLoader as Xe, KTX2Loader as je, MeshoptDecoder as Ke, GLTFLoader as we } from "./three-examples.js";
 const Ye = "";
 globalThis.GLTF_PROGRESSIVE_VERSION = Ye;
 console.debug("[gltf-progressive] version -");
-let I = "https://www.gstatic.com/draco/versioned/decoders/1.5.7/", j = "https://cdn.needle.tools/static/three/0.179.1/basis2/";
-const He = I, Qe = j, Pe = new URL(I + "draco_decoder.js");
+let B = "https://www.gstatic.com/draco/versioned/decoders/1.5.7/", j = "https://cdn.needle.tools/static/three/0.179.1/basis2/";
+const He = B, Qe = j, Pe = new URL(B + "draco_decoder.js");
 Pe.searchParams.append("range", "true");
 fetch(Pe, {
   method: "GET",
@@ -12,30 +12,30 @@ fetch(Pe, {
     Range: "bytes=0-1"
   }
 }).catch((o) => {
-  console.debug(`Failed to fetch remote Draco decoder from ${I} (offline: ${typeof navigator < "u" ? navigator.onLine : "unknown"})`), I === He && Ze("./include/draco/"), j === Qe && et("./include/ktx2/");
+  console.debug(`Failed to fetch remote Draco decoder from ${B} (offline: ${typeof navigator < "u" ? navigator.onLine : "unknown"})`), B === He && Ze("./include/draco/"), j === Qe && et("./include/ktx2/");
 }).finally(() => {
   Ae();
 });
 const Je = () => ({
-  dracoDecoderPath: I,
+  dracoDecoderPath: B,
   ktx2TranscoderPath: j
 });
 function Ze(o) {
-  I = o, C && C[me] != I ? (console.debug("Updating Draco decoder path to " + o), C[me] = I, C.setDecoderPath(I), C.preload()) : console.debug("Setting Draco decoder path to " + o);
+  B = o, k && k[me] != B ? (console.debug("Updating Draco decoder path to " + o), k[me] = B, k.setDecoderPath(B), k.preload()) : console.debug("Setting Draco decoder path to " + o);
 }
 function et(o) {
-  j = o, $ && $.transcoderPath != j ? (console.debug("Updating KTX2 transcoder path to " + o), $.setTranscoderPath(j), $.init()) : console.debug("Setting KTX2 transcoder path to " + o);
+  j = o, G && G.transcoderPath != j ? (console.debug("Updating KTX2 transcoder path to " + o), G.setTranscoderPath(j), G.init()) : console.debug("Setting KTX2 transcoder path to " + o);
 }
 function Le(o) {
-  return Ae(), o ? $.detectSupport(o) : o !== null && console.warn("No renderer provided to detect ktx2 support - loading KTX2 textures might fail"), { dracoLoader: C, ktx2Loader: $, meshoptDecoder: ne };
+  return Ae(), o ? G.detectSupport(o) : o !== null && console.warn("No renderer provided to detect ktx2 support - loading KTX2 textures might fail"), { dracoLoader: k, ktx2Loader: G, meshoptDecoder: ne };
 }
 function Ce(o) {
-  o.dracoLoader || o.setDRACOLoader(C), o.ktx2Loader || o.setKTX2Loader($), o.meshoptDecoder || o.setMeshoptDecoder(ne);
+  o.dracoLoader || o.setDRACOLoader(k), o.ktx2Loader || o.setKTX2Loader(G), o.meshoptDecoder || o.setMeshoptDecoder(ne);
 }
 const me = /* @__PURE__ */ Symbol("dracoDecoderPath");
-let C, ne, $;
+let k, ne, G;
 function Ae() {
-  C || (C = new Xe(), C[me] = I, C.setDecoderPath(I), C.setDecoderConfig({ type: "js" }), C.preload()), $ || ($ = new je(), $.setTranscoderPath(j), $.init()), ne || (ne = Ke);
+  k || (k = new Xe(), k[me] = B, k.setDecoderPath(B), k.setDecoderConfig({ type: "js" }), k.preload()), G || (G = new je(), G.setTranscoderPath(j), G.init()), ne || (ne = Ke);
 }
 const ye = /* @__PURE__ */ new WeakMap();
 function ke(o, t) {
@@ -54,8 +54,8 @@ function st(...o) {
   return o[0] = e, tt?.call(this, ...o);
 }
 we.prototype.load = st;
-q("debugprogressive");
-function q(o) {
+N("debugprogressive");
+function N(o) {
   if (typeof window > "u") return !1;
   const e = new URL(window.location.href).searchParams.get(o);
   return e == null || e === "0" || e === "false" ? !1 : e === "" ? !0 : e;
@@ -72,7 +72,7 @@ function rt(o, t) {
   return t;
 }
 function _e() {
-  return H !== void 0 || (H = /iPhone|iPad|iPod|Android|IEMobile/i.test(navigator.userAgent), q("debugprogressive") && console.log("[glTF Progressive]: isMobileDevice", H)), H;
+  return H !== void 0 || (H = /iPhone|iPad|iPod|Android|IEMobile/i.test(navigator.userAgent), N("debugprogressive") && console.log("[glTF Progressive]: isMobileDevice", H)), H;
 }
 let H;
 function De() {
@@ -157,9 +157,9 @@ function ct(o) {
     t.setAttribute(e, o.getAttribute(e));
   return t.setIndex(o.getIndex()), t;
 }
-const z = new Array(), f = q("debugprogressive");
+const q = new Array(), h = N("debugprogressive");
 let Z, E = -1;
-if (f) {
+if (h) {
   let o = function() {
     E += 1, E >= t && (E = -1), console.log(`Toggle LOD level [${E}]`);
   }, t = 6;
@@ -170,7 +170,7 @@ if (f) {
   });
 }
 function Re(o) {
-  if (f && Z !== void 0)
+  if (h && Z !== void 0)
     if (Array.isArray(o))
       for (const t of o)
         Re(t);
@@ -182,7 +182,7 @@ const ft = _e() ? 2 : 10;
 function ht(o) {
   if (J.length < ft) {
     const s = J.length;
-    f && console.warn(`[Worker] Creating new worker #${s}`);
+    h && console.warn(`[Worker] Creating new worker #${s}`);
     const r = Me.createWorker(o || {});
     return J.push(r), r;
   }
@@ -223,16 +223,16 @@ class Me {
       const { WebGLRenderer: u } = await import("./three.js").then((c) => c.THREE);
       return new u();
     })(), r = await this._webglRenderer);
-    const l = Le(r).ktx2Loader.workerConfig;
+    const a = Le(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
@@ -254,19 +254,19 @@ function gt(o) {
     }
     if (e.morphAttributes)
       for (const r in e.morphAttributes) {
-        const n = e.morphAttributes[r].map((l) => ue(l));
+        const n = e.morphAttributes[r].map((a) => ue(a));
         s.morphAttributes[r] = n;
       }
-    if (s.morphTargetsRelative = e.morphTargetsRelative ?? !1, s.boundingBox = new pe(), s.boundingBox.min = new A(
+    if (s.morphTargetsRelative = e.morphTargetsRelative ?? !1, s.boundingBox = new pe(), s.boundingBox.min = new R(
       e.boundingBox?.min.x,
       e.boundingBox?.min.y,
       e.boundingBox?.min.z
-    ), s.boundingBox.max = new A(
+    ), s.boundingBox.max = new R(
       e.boundingBox?.max.x,
       e.boundingBox?.max.y,
       e.boundingBox?.max.z
     ), s.boundingSphere = new Te(
-      new A(
+      new R(
         e.boundingSphere?.center.x,
         e.boundingSphere?.center.y,
         e.boundingSphere?.center.z
@@ -325,13 +325,13 @@ function ue(o) {
   } else "isBufferAttribute" in o && o.isBufferAttribute && (t = new qe(o.array, o.itemSize, o.normalized), t.usage = o.usage, t.gpuType = o.gpuType, t.updateRanges = o.updateRanges);
   return t;
 }
-const pt = q("gltf-progressive-worker");
-q("gltf-progressive-reduce-mipmaps");
-const K = q("gltf-progressive-gc"), ce = /* @__PURE__ */ Symbol("needle-progressive-texture"), W = "NEEDLE_progressive";
+const pt = N("gltf-progressive-worker");
+N("gltf-progressive-reduce-mipmaps");
+const K = N("gltf-progressive-gc"), ce = /* @__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) {
@@ -350,33 +350,33 @@ class m {
       max_count: 0,
       lods: []
     }), Array.isArray(t)) {
-      for (const l of t)
-        this.getMaterialMinMaxLODsCount(l, e);
+      for (const a of t)
+        this.getMaterialMinMaxLODsCount(a, e);
       return t[r] = e, e;
     }
-    if (f === "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;
+    if (h === "verbose" && console.log("getMaterialMinMaxLODsCount", t), t.type === "ShaderMaterial" || t.type === "RawShaderMaterial") {
+      const a = t;
+      for (const l of Object.keys(a.uniforms)) {
+        const u = a.uniforms[l].value;
         u?.isTexture === !0 && n(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 && n(l, e);
       }
     else
-      f && console.warn(`[getMaterialMinMaxLODsCount] Unsupported material type: ${t.type}`);
+      h && console.warn(`[getMaterialMinMaxLODsCount] Unsupported material type: ${t.type}`);
     return t[r] = e, e;
-    function n(l, a) {
-      const u = s.getAssignedLODInformation(l);
+    function n(a, l) {
+      const u = s.getAssignedLODInformation(a);
       if (u) {
         const c = s.lodInfos.get(u.key);
         if (c && c.lods) {
-          a.min_count = Math.min(a.min_count, c.lods.length), a.max_count = Math.max(a.max_count, c.lods.length);
-          for (let y = 0; y < c.lods.length; y++) {
-            const w = c.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, c.lods.length), l.max_count = Math.max(l.max_count, c.lods.length);
+          for (let g = 0; g < c.lods.length; g++) {
+            const y = c.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));
           }
         }
       }
@@ -434,16 +434,16 @@ class m {
       const s = t.geometry, r = this.getAssignedLODInformation(s);
       if (!r)
         return Promise.resolve(null);
-      for (const i of z)
+      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 n = r.index || 0;
           i = i[n];
         }
-        return t["LOD:requested level"] === e && (delete t["LOD:requested level"], i && s != i && (i?.isBufferGeometry ? t.geometry = i : f && console.error("Invalid LOD geometry", i))), i;
+        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 f && 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) {
@@ -458,8 +458,8 @@ class m {
         }
         return Promise.all(r).then((i) => {
           const n = new Array();
-          for (const l of i)
-            Array.isArray(l) && n.push(...l);
+          for (const a of i)
+            Array.isArray(a) && n.push(...a);
           return n;
         });
       } else
@@ -469,28 +469,28 @@ class m {
       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((c) => (c && n.uniforms[l].value != c && (n.uniforms[l].value = c, n.uniformsNeedUpdate = !0), c));
-            r.push(u), i.push(l);
+        for (const a of Object.keys(n.uniforms)) {
+          const l = n.uniforms[a].value;
+          if (l?.isTexture === !0) {
+            const u = this.assignTextureLODForSlot(l, e, s, a).then((c) => (c && n.uniforms[a].value != c && (n.uniforms[a].value = c, n.uniformsNeedUpdate = !0), c));
+            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);
-            r.push(a), i.push(n);
+          const a = s[n];
+          if (a?.isTexture === !0) {
+            const l = this.assignTextureLODForSlot(a, e, s, n);
+            r.push(l), i.push(n);
           }
         }
       return Promise.all(r).then((n) => {
-        const l = new Array();
-        for (let a = 0; a < n.length; a++) {
-          const u = n[a], c = i[a];
-          u && u.isTexture === !0 ? l.push({ material: s, slot: c, texture: u, level: e }) : l.push({ material: s, slot: c, texture: null, level: e });
+        const a = new Array();
+        for (let l = 0; l < n.length; l++) {
+          const u = n[l], c = i[l];
+          u && u.isTexture === !0 ? a.push({ material: s, slot: c, texture: u, level: e }) : a.push({ material: s, slot: c, texture: null, level: e });
         }
-        return l;
+        return a;
       });
     }
     if (t instanceof F || t.isTexture === !0) {
@@ -517,19 +517,19 @@ class m {
       if (i?.isTexture === !0) {
         if (i != t && s && r) {
           const n = s[r];
-          if (n && !f) {
-            const l = this.getAssignedLODInformation(n);
-            if (l && l?.level < e)
-              return f === "verbose" && console.warn("Assigned texture level is already higher: ", l.level, e, s, n, i), i && i !== n && ((f || K) && console.log(`[gltf-progressive] Disposing rejected lower-quality texture LOD ${e} (assigned is ${l.level})`, i.uuid), i.dispose()), null;
-          }
-          if (this.trackTextureUsage(i), n && n !== i && this.untrackTextureUsage(n) && (f || K)) {
+          if (n && !h) {
             const a = this.getAssignedLODInformation(n);
-            console.log(`[gltf-progressive] Disposed old texture LOD ${a?.level ?? "?"} → ${e} for ${s.name || s.type}.${r}`, n.uuid);
+            if (a && a?.level < e)
+              return h === "verbose" && console.warn("Assigned texture level is already higher: ", a.level, e, s, n, i), i && i !== n && ((h || K) && console.log(`[gltf-progressive] Disposing rejected lower-quality texture LOD ${e} (assigned is ${a.level})`, i.uuid), i.dispose()), null;
+          }
+          if (this.trackTextureUsage(i), n && n !== i && this.untrackTextureUsage(n) && (h || K)) {
+            const l = this.getAssignedLODInformation(n);
+            console.log(`[gltf-progressive] Disposed old texture LOD ${l?.level ?? "?"} → ${e} for ${s.name || s.type}.${r}`, n.uuid);
           }
           s[r] = i;
         }
         return i;
-      } else f == "verbose" && console.warn("No LOD found for", t, e);
+      } else h == "verbose" && console.warn("No LOD found for", t, e);
       return null;
     }).catch((i) => (console.error("Error loading LOD", t, i), null));
   }
@@ -537,12 +537,12 @@ class m {
   url;
   constructor(t) {
     const e = t.options.path;
-    f && 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?.[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;
@@ -560,12 +560,12 @@ class m {
   //     });
   // }
   afterRoot(t) {
-    return f && 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 r = e?.extensions[W];
+        const r = e?.extensions[U];
         if (r) {
           if (!r.lods) {
-            f && console.warn("Texture has no LODs", r);
+            h && console.warn("Texture has no LODs", r);
             return;
           }
           let i = !1;
@@ -578,7 +578,7 @@ class m {
       }
     }), this.parser.json.meshes?.forEach((e, s) => {
       if (e?.extensions) {
-        const r = e?.extensions[W];
+        const r = e?.extensions[U];
         if (r && r.lods) {
           for (const i of this.parser.associations.keys())
             if (i.isMesh) {
@@ -594,12 +594,12 @@ class m {
    */
   static registerTexture = (t, e, s, r, i) => {
     if (!e) {
-      f && console.error("!! gltf-progressive: Called register texture without texture");
+      h && console.error("!! gltf-progressive: Called register texture without texture");
       return;
     }
-    if (f) {
-      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[${r}] "${e.name || e.uuid}", Current: ${l}x${a}, Max: ${i.lods[0]?.width}x${i.lods[0]?.height}, uuid: ${e.uuid}`, i, e);
+    if (h) {
+      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[ce] = i);
     const n = i.guid;
@@ -609,15 +609,15 @@ class m {
    * Register a mesh with LOD information
    */
   static registerMesh = (t, e, s, r, i, n) => {
-    const l = s.geometry;
-    if (!l) {
-      f && console.warn("gltf-progressive: Register mesh without geometry");
+    const a = s.geometry;
+    if (!a) {
+      h && console.warn("gltf-progressive: Register mesh without geometry");
       return;
     }
-    l.userData || (l.userData = {}), f && console.log("> Progressive: register mesh " + s.name, { index: i, uuid: s.uuid }, n, s), m.assignLODInformation(t, l, e, r, i), m.lodInfos.set(e, n);
+    a.userData || (a.userData = {}), h && console.log("> Progressive: register mesh " + s.name, { index: i, uuid: s.uuid }, n, s), m.assignLODInformation(t, a, e, r, i), m.lodInfos.set(e, n);
     let u = m.lowresCache.get(e)?.deref();
-    u ? u.push(s.geometry) : u = [s.geometry], m.lowresCache.set(e, new WeakRef(u)), r > 0 && !ee(s) && lt(s, l);
-    for (const c of z)
+    u ? u.push(s.geometry) : u = [s.geometry], m.lowresCache.set(e, new WeakRef(u)), r > 0 && !ee(s) && lt(s, a);
+    for (const c of q)
       c.onRegisteredNewMesh?.(s, n);
   };
   /**
@@ -645,7 +645,7 @@ class m {
       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) {
@@ -668,7 +668,7 @@ class m {
       const e = t.deref();
       e && (e.isTexture && this.textureRefCounts.delete(e.uuid), e.dispose());
     } else
-      t.then((e) => {
+      this.disposedRequests.add(t), t.then((e) => {
         if (e)
           if (Array.isArray(e))
             for (const s of e) s.dispose();
@@ -692,15 +692,15 @@ class m {
    */
   static _resourceRegistry = new FinalizationRegistry((t) => {
     const e = m.cache.get(t);
-    (f || K) && console.debug(`[gltf-progressive] Memory: Resource GC'd
-${t}`), e instanceof WeakRef && (e.deref() || (m.cache.delete(t), (f || K) && console.log("[gltf-progressive] ↪ Cache entry deleted (GC)")));
+    (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), f === "verbose" && console.log(`[gltf-progressive] Track texture ${e}, refCount: ${s} → ${s + 1}`);
+    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.
@@ -710,165 +710,171 @@ ${t}`), e instanceof WeakRef && (e.deref() || (m.cache.delete(t), (f || K) && co
   static untrackTextureUsage(t) {
     const e = t.uuid, s = this.textureRefCounts.get(e);
     if (!s)
-      return (f === "verbose" || K) && i("[gltf-progressive] Memory: Untrack untracked texture (dispose immediately)", 0), t.dispose(), !0;
+      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), (f || K) && i("[gltf-progressive] Memory: Dispose texture", r), t.dispose(), !0;
-    return this.textureRefCounts.set(e, r), f === "verbose" && i("[gltf-progressive] Memory: Untrack texture", r), !1;
-    function i(n, l) {
-      let a = t.image?.width || t.source?.data?.width || 0, u = t.image?.height || t.source?.data?.height || 0;
-      const c = a && u ? `${a}x${u}` : "N/A";
-      let y = "N/A";
-      a && u && (y = `~${(nt(t) / (1024 * 1024)).toFixed(2)} MB`), console.log(`${n} — ${t.name} ${c} (${y}), refCount: ${s} → ${l}
+      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(n, a) {
+      let l = t.image?.width || t.source?.data?.width || 0, u = t.image?.height || t.source?.data?.height || 0;
+      const c = l && u ? `${l}x${u}` : "N/A";
+      let g = "N/A";
+      l && u && (g = `~${(nt(t) / (1024 * 1024)).toFixed(2)} MB`), console.log(`${n} — ${t.name} ${c} (${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 = f == "verbose", r = this.getAssignedLODInformation(t);
-    if (!r)
-      return f && console.warn(`[gltf-progressive] No LOD information found: ${t.name}, uuid: ${t.uuid}, type: ${t.type}`, t), null;
-    const i = r?.key;
-    let n;
+    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 n = i?.key;
+    let a;
     if (t.isTexture === !0) {
-      const a = t;
-      a.source && a.source[ce] && (n = a.source[ce]);
+      const u = t;
+      u.source && u.source[ce] && (a = u.source[ce]);
     }
-    if (n || (n = m.lodInfos.get(i)), !n)
-      f && console.warn(`Can not load LOD ${e}: no LOD info found for "${i}" ${t.name}`, t.type, m.lodInfos);
+    if (a || (a = m.lodInfos.get(n)), !a)
+      h && console.warn(`Can not load LOD ${e}: no LOD info found for "${n}" ${t.name}`, t.type, m.lodInfos);
     else {
       if (e > 0) {
-        let c = !1;
-        const y = Array.isArray(n.lods);
-        if (y && e >= n.lods.length ? c = !0 : y || (c = !0), c) {
-          const w = this.lowresCache.get(i);
-          if (w) {
-            const L = w.deref();
-            if (L) return L;
-            this.lowresCache.delete(i), f && console.log(`[gltf-progressive] Lowres cache entry was GC'd: ${i}`);
+        let g = !1;
+        const y = Array.isArray(a.lods);
+        if (y && e >= a.lods.length ? g = !0 : y || (g = !0), g) {
+          const v = this.lowresCache.get(n);
+          if (v) {
+            const _ = v.deref();
+            if (_) return _;
+            this.lowresCache.delete(n), h && console.log(`[gltf-progressive] Lowres cache entry was GC'd: ${n}`);
           }
           return null;
         }
       }
-      const a = Array.isArray(n.lods) ? n.lods[e]?.path : n.lods;
-      if (!a)
-        return f && !n["missing:uri"] && (n["missing:uri"] = !0, console.warn("Missing uri for progressive asset for LOD " + e, n)), null;
-      const u = rt(r.url, a);
-      if (u.endsWith(".glb") || u.endsWith(".gltf")) {
-        if (!n.guid)
-          return console.warn("missing pointer for glb/gltf texture", n), null;
-        const c = u + "_" + n.guid, y = await this.queue.slot(u), w = this.cache.get(c);
-        if (w !== void 0)
-          if (s && console.log(`LOD ${e} was already loading/loaded: ${c}`), w instanceof WeakRef) {
-            const d = w.deref();
-            if (d) {
-              let g = d, M = !1;
-              if (g instanceof F && t instanceof F ? g.image?.data || g.source?.data ? g = this.copySettings(t, g) : M = !0 : g instanceof V && t instanceof V && (g.attributes.position?.array || (M = !0)), !M)
-                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 c = rt(i.url, u);
+      if (c.endsWith(".glb") || c.endsWith(".gltf")) {
+        if (!a.guid)
+          return console.warn("missing pointer for glb/gltf texture", a), null;
+        const g = c + "_" + a.guid, y = await this.queue.slot(c);
+        if (s !== this.cacheGeneration) return null;
+        const v = this.cache.get(g);
+        if (v !== void 0)
+          if (r && console.log(`LOD ${e} was already loading/loaded: ${g}`), v instanceof WeakRef) {
+            const f = v.deref();
+            if (f) {
+              let L = f, D = !1;
+              if (L instanceof F && t instanceof F ? L.image?.data || L.source?.data ? L = this.copySettings(t, L) : D = !0 : L instanceof V && t instanceof V && (L.attributes.position?.array || (D = !0)), !D)
+                return L;
             }
-            this.cache.delete(c), f && console.log(`[gltf-progressive] Re-loading GC'd/disposed resource: ${c}`);
+            this.cache.delete(g), h && console.log(`[gltf-progressive] Re-loading GC'd/disposed resource: ${g}`);
           } else {
-            let d = await w.catch((M) => (console.error(`Error loading LOD ${e} from ${u}
-`, M), null)), g = !1;
-            if (d == null || (d instanceof F && t instanceof F ? d.image?.data || d.source?.data ? d = this.copySettings(t, d) : (g = !0, this.cache.delete(c)) : d instanceof V && t instanceof V && (d.attributes.position?.array || (g = !0, this.cache.delete(c)))), !g)
-              return d;
+            let f = await v.catch((D) => (console.error(`Error loading LOD ${e} from ${c}
+`, D), null));
+            if (s !== this.cacheGeneration || this.disposedRequests.has(v)) return null;
+            let L = !1;
+            if (f == null || (f instanceof F && t instanceof F ? f.image?.data || f.source?.data ? f = this.copySettings(t, f) : (L = !0, this.cache.delete(g)) : f instanceof V && t instanceof V && (f.attributes.position?.array || (L = !0, this.cache.delete(g)))), !L)
+              return f;
           }
         if (!y.use)
-          return f && console.log(`LOD ${e} was aborted: ${u}`), null;
-        const L = n, k = new Promise(async (d, g) => {
+          return h && console.log(`LOD ${e} was aborted: ${c}`), null;
+        const _ = a, P = new Promise(async (f, L) => {
           if (pt) {
-            const x = await (await ht({})).load(u);
-            if (x.textures.length > 0)
-              for (const h of x.textures) {
-                let p = h.texture;
-                return m.assignLODInformation(r.url, p, i, e, void 0), t instanceof F && (p = this.copySettings(t, p)), p && (p.guid = L.guid), d(p);
+            const d = await (await ht({})).load(c);
+            if (d.textures.length > 0)
+              for (const p of d.textures) {
+                let w = p.texture;
+                return m.assignLODInformation(i.url, w, n, e, void 0), t instanceof F && (w = this.copySettings(t, w)), w && (w.guid = _.guid), f(w);
               }
-            if (x.geometries.length > 0) {
-              const h = new Array();
-              for (const p of x.geometries) {
-                const b = p.geometry;
-                m.assignLODInformation(r.url, b, i, e, p.primitiveIndex), h.push(b);
+            if (d.geometries.length > 0) {
+              const p = new Array();
+              for (const w of d.geometries) {
+                const M = w.geometry;
+                m.assignLODInformation(i.url, M, n, e, w.primitiveIndex), p.push(M);
               }
-              return d(h);
+              return f(p);
             }
-            return d(null);
+            return f(null);
           }
-          const M = new we();
-          Ce(M), f && (await new Promise((_) => setTimeout(_, 1e3)), s && console.warn("Start loading (delayed) " + u, L.guid));
-          let B = u;
-          if (L && Array.isArray(L.lods)) {
-            const _ = L.lods[e];
-            _.hash && (B += "?v=" + _.hash);
+          const D = new we();
+          Ce(D), h && (await new Promise((O) => setTimeout(O, 1e3)), r && console.warn("Start loading (delayed) " + c, _.guid));
+          let I = c;
+          if (_ && Array.isArray(_.lods)) {
+            const O = _.lods[e];
+            O.hash && (I += "?v=" + O.hash);
           }
-          const D = await M.loadAsync(B).catch((_) => (console.error(`Error loading LOD ${e} from ${u}
-`, _), d(null)));
-          if (!D)
-            return d(null);
-          const N = D.parser;
-          s && console.log("Loading finished " + u, L.guid);
-          let T = 0;
-          if (D.parser.json.textures) {
-            let _ = !1;
-            for (const x of D.parser.json.textures) {
-              if (x?.extensions) {
-                const h = x?.extensions[W];
-                if (h?.guid && h.guid === L.guid) {
-                  _ = !0;
+          const C = await D.loadAsync(I).catch((O) => (console.error(`Error loading LOD ${e} from ${c}
+`, O), f(null)));
+          if (!C)
+            return f(null);
+          const W = C.parser;
+          r && console.log("Loading finished " + c, _.guid);
+          let b = 0;
+          if (C.parser.json.textures) {
+            let O = !1;
+            for (const d of C.parser.json.textures) {
+              if (d?.extensions) {
+                const p = d?.extensions[U];
+                if (p?.guid && p.guid === _.guid) {
+                  O = !0;
                   break;
                 }
               }
-              T++;
+              b++;
             }
-            if (_) {
-              let x = await N.getDependency("texture", T);
-              return x && m.assignLODInformation(r.url, x, i, e, void 0), s && console.log('change "' + t.name + '" → "' + x.name + '"', u, T, x, c), t instanceof F && (x = this.copySettings(t, x)), x && (x.guid = L.guid), d(x);
-            } else f && console.warn("Could not find texture with guid", L.guid, D.parser.json);
+            if (O) {
+              let d = await W.getDependency("texture", b);
+              return d && m.assignLODInformation(i.url, d, n, e, void 0), r && console.log('change "' + t.name + '" → "' + d.name + '"', c, b, d, g), t instanceof F && (d = this.copySettings(t, d)), d && (d.guid = _.guid), f(d);
+            } else h && console.warn("Could not find texture with guid", _.guid, C.parser.json);
           }
-          if (T = 0, D.parser.json.meshes) {
-            let _ = !1;
-            for (const x of D.parser.json.meshes) {
-              if (x?.extensions) {
-                const h = x?.extensions[W];
-                if (h?.guid && h.guid === L.guid) {
-                  _ = !0;
+          if (b = 0, C.parser.json.meshes) {
+            let O = !1;
+            for (const d of C.parser.json.meshes) {
+              if (d?.extensions) {
+                const p = d?.extensions[U];
+                if (p?.guid && p.guid === _.guid) {
+                  O = !0;
                   break;
                 }
               }
-              T++;
+              b++;
             }
-            if (_) {
-              const x = await N.getDependency("mesh", T);
-              if (s && console.log(`Loaded Mesh "${x.name}"`, u, T, x, c), x.isMesh === !0) {
-                const h = x.geometry;
-                return m.assignLODInformation(r.url, h, i, e, 0), d(h);
+            if (O) {
+              const d = await W.getDependency("mesh", b);
+              if (r && console.log(`Loaded Mesh "${d.name}"`, c, b, d, g), d.isMesh === !0) {
+                const p = d.geometry;
+                return m.assignLODInformation(i.url, p, n, e, 0), f(p);
               } else {
-                const h = new Array();
-                for (let p = 0; p < x.children.length; p++) {
-                  const b = x.children[p];
-                  if (b.isMesh === !0) {
-                    const S = b.geometry;
-                    m.assignLODInformation(r.url, S, i, e, p), h.push(S);
+                const p = new Array();
+                for (let w = 0; w < d.children.length; w++) {
+                  const M = d.children[w];
+                  if (M.isMesh === !0) {
+                    const A = M.geometry;
+                    m.assignLODInformation(i.url, A, n, e, w), p.push(A);
                   }
                 }
-                return d(h);
+                return f(p);
               }
-            } else f && console.warn("Could not find mesh with guid", L.guid, D.parser.json);
+            } else h && console.warn("Could not find mesh with guid", _.guid, C.parser.json);
           }
-          return d(null);
+          return f(null);
         });
-        this.cache.set(c, k), y.use(k);
-        const v = await k;
-        return v != null ? v instanceof F ? (this.cache.set(c, new WeakRef(v)), m._resourceRegistry.register(v, c)) : Array.isArray(v) ? this.cache.set(c, Promise.resolve(v)) : this.cache.set(c, Promise.resolve(v)) : this.cache.set(c, Promise.resolve(null)), v;
+        this.cache.set(g, P), y.use(P);
+        const x = await P;
+        return s !== this.cacheGeneration || this.cache.get(g) !== P ? 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 Ne().loadAsync(u);
-        return y ? (y.guid = n.guid, y.flipY = !1, y.needsUpdate = !0, y.colorSpace = t.colorSpace, s && console.log(n, y)) : f && console.warn("failed loading", u), y;
+        r && console.log("Load texture from uri: " + c);
+        const y = await new Ne().loadAsync(c);
+        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", c), y);
       }
     }
     return null;
   }
-  static queue = new it(_e() ? 20 : 50, { debug: f != !1 });
+  static queue = new it(_e() ? 20 : 50, { debug: h != !1 });
   static assignLODInformation(t, e, s, r, i) {
     if (!e) return;
     e.userData || (e.userData = {});
@@ -880,7 +886,7 @@ ${e}`);
   }
   // private static readonly _copiedTextures: WeakMap<Texture, Texture> = new Map();
   static copySettings(t, e) {
-    return e ? (f === "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;
   }
@@ -945,7 +951,7 @@ class de {
   _seen = /* @__PURE__ */ new WeakMap();
   add(t, e, s) {
     if (this._resolved) {
-      f && 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)) {
@@ -953,7 +959,7 @@ class de {
         if (this._seen.has(e)) {
           let r = this._seen.get(e);
           if (r >= this._maxPromisesPerObject) {
-            f && 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, r + 1);
@@ -972,8 +978,8 @@ class de {
     });
   }
 }
-const R = q("debugprogressive"), yt = q("noprogressive"), fe = /* @__PURE__ */ Symbol("Needle:LODSManager"), he = /* @__PURE__ */ Symbol("Needle:LODState"), U = /* @__PURE__ */ Symbol("Needle:CurrentLOD"), P = { mesh_lod: -1, texture_lod: -1 };
-let oe = class O {
+const $ = N("debugprogressive"), yt = N("noprogressive"), fe = /* @__PURE__ */ Symbol("Needle:LODSManager"), he = /* @__PURE__ */ Symbol("Needle:LODState"), z = /* @__PURE__ */ Symbol("Needle:CurrentLOD"), T = { mesh_lod: -1, texture_lod: -1 };
+let oe = class S {
   /** 
    * 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.
    */
@@ -983,11 +989,11 @@ let oe = class O {
     return t[he];
   }
   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.  
@@ -997,7 +1003,7 @@ let oe = class O {
   static get(t, e) {
     if (t[fe])
       return console.debug("[gltf-progressive] LODsManager already exists for this renderer"), t[fe];
-    const s = new O(t, {
+    const s = new S(t, {
       engine: "unknown",
       ...e
     });
@@ -1008,7 +1014,7 @@ let oe = class O {
   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
@@ -1097,7 +1103,7 @@ let oe = class O {
     const e = this;
     Le(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.#n.getDelta(), e.#o += e.#i, e._fpsBuffer.shift(), e._fpsBuffer.push(1 / e.#i), e.#s = e._fpsBuffer.reduce((l, a) => l + a) / e._fpsBuffer.length, R && e.#r % 200 === 0 && console.log("FPS", Math.round(e.#s), "Interval:", e.#e));
+      (i == null || "isXRRenderTarget" in i && i.isXRRenderTarget) && (t = 0, e.#r += 1, e.#i = e.#n.getDelta(), e.#o += 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 n = t++;
       e.#t.call(this, s, r), e.onAfterRender(s, r, n);
     };
@@ -1113,11 +1119,11 @@ let oe = class O {
     const i = this.renderer.renderLists.get(t, 0).opaque;
     let n = !0;
     if (i.length === 1) {
-      const l = i[0].material;
-      (l.name === "EffectMaterial" || l.name === "CopyShader") && (n = !1);
+      const a = i[0].material;
+      (a.name === "EffectMaterial" || a.name === "CopyShader") && (n = !1);
     }
     if ((e.parent && e.parent.type === "CubeCamera" || s >= 1 && e.type === "OrthographicCamera") && (n = !1), n) {
-      if (yt || (this.updateInterval === "auto" ? this.#s < 40 && this.#e < 10 ? (this.#e += 1, R && console.warn("↓ Reducing LOD updates", this.#e, this.#s.toFixed(0))) : this.#s >= 60 && this.#e > 1 && (this.#e -= 1, R && console.warn("↑ Increasing LOD updates", this.#e, this.#s.toFixed(0))) : this.#e = this.updateInterval, this.#e > 0 && this.#r % this.#e != 0))
+      if (yt || (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();
     }
@@ -1129,12 +1135,12 @@ let oe = class O {
     const s = this.renderer.renderLists.get(t, 0), r = s.opaque;
     this.projectionScreenMatrix.multiplyMatrices(e.projectionMatrix, e.matrixWorldInverse);
     const i = this.targetTriangleDensity;
-    for (const a of r) {
-      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")) {
-        R && (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)));
+    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":
@@ -1143,22 +1149,22 @@ let oe = class O {
         case "MeshDepthMaterial":
           continue;
       }
-      if (R === "color" && a.material && !a.object.progressive_debug_color) {
-        a.object.progressive_debug_color = !0;
-        const c = Math.random() * 16777215, y = new Ve({ color: c });
-        a.object.material = y;
+      if ($ === "color" && l.material && !l.object.progressive_debug_color) {
+        l.object.progressive_debug_color = !0;
+        const c = Math.random() * 16777215, g = new Ve({ color: c });
+        l.object.material = g;
       }
-      const u = a.object;
+      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;
+    for (const l of n) {
+      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;
+    const a = s.transmissive;
+    for (const l of a) {
+      const u = l.object;
       (u instanceof X || u.isMesh) && this.updateLODs(t, e, u, i);
     }
   }
@@ -1168,13 +1174,13 @@ let oe = class O {
     let i = s[he];
     if (i || (i = new xt(), s[he] = i), i.frames++ < 2)
       return;
-    for (const l of z)
-      l.onBeforeUpdateLOD?.(this.renderer, t, e, s);
+    for (const a of q)
+      a.onBeforeUpdateLOD?.(this.renderer, t, e, s);
     const n = this.overrideLodLevel !== void 0 ? this.overrideLodLevel : E;
-    n >= 0 ? (P.mesh_lod = n, P.texture_lod = n) : (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, n), f && s.material && !s.isGizmo && Re(s.material);
-    for (const l of z)
-      l.onAfterUpdatedLOD?.(this.renderer, t, e, s, P);
-    i.lastLodLevel_Mesh = P.mesh_lod, i.lastLodLevel_Texture = P.texture_lod;
+    n >= 0 ? (T.mesh_lod = n, T.texture_lod = n) : (this.calculateLodLevel(e, s, i, r, 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 && Re(s.material);
+    for (const a of q)
+      a.onAfterUpdatedLOD?.(this.renderer, t, e, s, T);
+    i.lastLodLevel_Mesh = T.mesh_lod, i.lastLodLevel_Texture = T.texture_lod;
   }
   /** Load progressive textures for the given material
    * @param material the material to load the textures for
@@ -1189,10 +1195,10 @@ let oe = class O {
       return;
     }
     let r = !1;
-    if ((t[U] === void 0 || e < t[U]) && (r = !0), s !== void 0 && s >= 0 && (r = t[U] != s, e = s), r) {
-      t[U] = e;
+    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((n) => {
-        this._lodchangedlisteners.forEach((l) => l({ type: "texture", level: e, object: t }));
+        this._lodchangedlisteners.forEach((a) => a({ type: "texture", level: e, object: t }));
       });
       de.addPromise("texture", t, i, this._newPromiseGroups);
     }
@@ -1205,11 +1211,11 @@ let oe = class O {
    */
   loadProgressiveMeshes(t, e) {
     if (!t) return Promise.resolve(null);
-    let s = t[U] !== e;
+    let s = t[z] !== e;
     const r = t["DEBUG:LOD"];
-    if (r != null && (s = t[U] != r, e = r), s) {
-      t[U] = e;
-      const i = t.geometry, n = m.assignMeshLOD(t, e).then((l) => (l && t[U] == e && i != t.geometry && this._lodchangedlisteners.forEach((a) => a({ type: "mesh", level: e, object: t })), l));
+    if (r != null && (s = t[z] != r, e = r), s) {
+      t[z] = e;
+      const i = t.geometry, n = 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 de.addPromise("mesh", t, n, this._newPromiseGroups), n;
     }
     return Promise.resolve(null);
@@ -1219,14 +1225,14 @@ let oe = class O {
   _tempBox = new pe();
   _tempBox2 = new pe();
   tempMatrix = new ve();
-  _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 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, r = t.max, i = (s.x + r.x) * 0.5, n = (s.y + r.y) * 0.5;
     return this._tempPtInside.set(i, n, s.z).applyMatrix4(e).z < 0;
@@ -1243,105 +1249,105 @@ let oe = class O {
       i.mesh_lod = -1, i.texture_lod = -1;
       return;
     }
-    let l = 10 + 1, a = !1;
-    if (R && 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, c = 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) {
+    const u = m.getMeshLODExtension(e.geometry)?.lods, c = m.getPrimitiveIndex(e.geometry), g = u && u.length > 0, y = m.getMaterialMinMaxLODsCount(e.material), v = y.min_count !== 1 / 0 && y.min_count >= 0 && y.max_count >= 0;
+    if (!g && !v) {
       i.mesh_lod = 0, i.texture_lod = 0;
       return;
     }
-    y || (a = !0, l = 0);
-    const k = this.renderer.domElement.clientHeight || this.renderer.domElement.height;
-    let v = e.geometry.boundingBox;
+    g || (l = !0, a = 0);
+    const _ = this.renderer.domElement.clientHeight || this.renderer.domElement.height;
+    let P = e.geometry.boundingBox;
     if (e.type === "SkinnedMesh") {
-      const d = e;
-      if (!d.boundingBox)
-        d.computeBoundingBox();
+      const x = e;
+      if (!x.boundingBox)
+        x.computeBoundingBox();
       else if (this.skinnedMeshAutoUpdateBoundsInterval > 0) {
-        if (!d[O.$skinnedMeshBoundsOffset]) {
-          const M = O.skinnedMeshBoundsFrameOffsetCounter++;
-          d[O.$skinnedMeshBoundsOffset] = M;
+        if (!x[S.$skinnedMeshBoundsOffset]) {
+          const L = S.skinnedMeshBoundsFrameOffsetCounter++;
+          x[S.$skinnedMeshBoundsOffset] = L;
         }
-        const g = d[O.$skinnedMeshBoundsOffset];
-        if ((s.frames + g) % this.skinnedMeshAutoUpdateBoundsInterval === 0) {
-          const M = ee(d), B = d.geometry;
-          M && (d.geometry = M), d.computeBoundingBox(), d.geometry = B;
+        const f = x[S.$skinnedMeshBoundsOffset];
+        if ((s.frames + f) % this.skinnedMeshAutoUpdateBoundsInterval === 0) {
+          const L = ee(x), D = x.geometry;
+          L && (x.geometry = L), x.computeBoundingBox(), x.geometry = D;
         }
       }
-      v = d.boundingBox;
+      P = x.boundingBox;
     }
-    if (v) {
-      const d = t;
+    if (P) {
+      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 h = t.getWorldPosition(this._tempWorldPosition);
-        if (this._sphere.containsPoint(h)) {
+        const d = t.getWorldPosition(this._tempWorldPosition);
+        if (this._sphere.containsPoint(d)) {
           i.mesh_lod = 0, i.texture_lod = 0;
           return;
         }
       }
-      if (this._tempBox.copy(v), this._tempBox.applyMatrix4(e.matrixWorld), d.isPerspectiveCamera && O.isInside(this._tempBox, this.projectionScreenMatrix)) {
+      if (this._tempBox.copy(P), this._tempBox.applyMatrix4(e.matrixWorld), x.isPerspectiveCamera && S.isInside(this._tempBox, this.projectionScreenMatrix)) {
         i.mesh_lod = 0, i.texture_lod = 0;
         return;
       }
-      if (this._tempBox.applyMatrix4(this.projectionScreenMatrix), this.renderer.xr.enabled && d.isPerspectiveCamera && d.fov > 70) {
-        const h = this._tempBox.min, p = this._tempBox.max;
-        let b = h.x, S = h.y, G = p.x, Y = p.y;
-        const te = 2, ae = 1.5, se = (h.x + p.x) * 0.5, re = (h.y + p.y) * 0.5;
-        b = (b - se) * te + se, S = (S - re) * te + re, G = (G - se) * te + se, Y = (Y - re) * te + re;
-        const Be = b < 0 && G > 0 ? 0 : Math.min(Math.abs(h.x), Math.abs(p.x)), Ge = S < 0 && Y > 0 ? 0 : Math.min(Math.abs(h.y), Math.abs(p.y)), le = Math.max(Be, Ge);
+      if (this._tempBox.applyMatrix4(this.projectionScreenMatrix), this.renderer.xr.enabled && x.isPerspectiveCamera && x.fov > 70) {
+        const d = this._tempBox.min, p = this._tempBox.max;
+        let w = d.x, M = d.y, A = p.x, Y = p.y;
+        const te = 2, ae = 1.5, se = (d.x + p.x) * 0.5, re = (d.y + p.y) * 0.5;
+        w = (w - se) * te + se, M = (M - re) * te + re, A = (A - se) * te + se, Y = (Y - re) * te + re;
+        const Be = w < 0 && A > 0 ? 0 : Math.min(Math.abs(d.x), Math.abs(p.x)), Ge = M < 0 && Y > 0 ? 0 : Math.min(Math.abs(d.y), Math.abs(p.y)), le = Math.max(Be, Ge);
         s.lastCentrality = (ae - le) * (ae - le) * (ae - le);
       } else
         s.lastCentrality = 1;
-      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 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, R && O.debugDrawLine) {
-        const h = this.tempMatrix.copy(this.projectionScreenMatrix);
-        h.invert();
-        const p = O.corner0, b = O.corner1, S = O.corner2, G = O.corner3;
-        p.copy(this._tempBox.min), b.copy(this._tempBox.max), b.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 = b.z = S.z = G.z = Y, p.applyMatrix4(h), b.applyMatrix4(h), S.applyMatrix4(h), G.applyMatrix4(h), O.debugDrawLine(p, b, 255), O.debugDrawLine(p, S, 255), O.debugDrawLine(b, G, 255), O.debugDrawLine(S, G, 255);
+      const f = this._tempBox.getSize(this._tempBoxSize);
+      f.multiplyScalar(0.5), screen.availHeight > 0 && _ > 0 && f.multiplyScalar(_ / screen.availHeight), t.isPerspectiveCamera ? f.x *= t.aspect : t.isOrthographicCamera;
+      const L = t.matrixWorldInverse, D = this._tempBox2;
+      D.copy(P), D.applyMatrix4(e.matrixWorld), D.applyMatrix4(L);
+      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, $ && S.debugDrawLine) {
+        const d = this.tempMatrix.copy(this.projectionScreenMatrix);
+        d.invert();
+        const p = S.corner0, w = S.corner1, M = S.corner2, A = S.corner3;
+        p.copy(this._tempBox.min), w.copy(this._tempBox.max), w.x = p.x, M.copy(this._tempBox.max), M.y = p.y, A.copy(this._tempBox.max);
+        const Y = (p.z + A.z) * 0.5;
+        p.z = w.z = M.z = A.z = Y, p.applyMatrix4(d), w.applyMatrix4(d), M.applyMatrix4(d), A.applyMatrix4(d), S.debugDrawLine(p, w, 255), S.debugDrawLine(p, M, 255), S.debugDrawLine(w, A, 255), S.debugDrawLine(M, A, 255);
       }
-      let _ = 999;
+      let b = 999;
       if (u && s.lastScreenCoverage > 0)
-        for (let h = 0; h < u.length; h++) {
-          const p = u[h], S = (p.densities?.[c] || p.density || 1e-5) / s.lastScreenCoverage;
-          if (c > 0 && De() && !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 < r) {
-            _ = h;
+        for (let d = 0; d < u.length; d++) {
+          const p = u[d], M = (p.densities?.[c] || p.density || 1e-5) / s.lastScreenCoverage;
+          if (c > 0 && De() && !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.")), M < r) {
+            b = d;
             break;
           }
         }
-      _ < l && (l = _, a = !0);
+      b < a && (a = b, l = !0);
     }
-    if (a ? i.mesh_lod = l : i.mesh_lod = s.lastLodLevel_Mesh, R && i.mesh_lod != s.lastLodLevel_Mesh) {
-      const g = u?.[i.mesh_lod];
-      g && console.log(`Mesh LOD changed: ${s.lastLodLevel_Mesh} → ${i.mesh_lod} (density: ${g.densities?.[c].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?.[c].toFixed(0)}) | ${e.name}`);
     }
-    if (L) {
-      const d = "saveData" in globalThis.navigator && globalThis.navigator.saveData === !0;
+    if (v) {
+      const x = "saveData" in globalThis.navigator && globalThis.navigator.saveData === !0;
       if (s.lastLodLevel_Texture < 0) {
-        if (i.texture_lod = w.max_count - 1, R) {
-          const g = w.lods[w.max_count - 1];
-          R && console.log(`First Texture LOD ${i.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 M = s.lastScreenCoverage * 4;
-        this.context?.engine === "model-viewer" && (M *= 1.5);
-        const D = k / window.devicePixelRatio * M;
-        let N = !1;
-        for (let T = w.lods.length - 1; T >= 0; T--) {
-          const _ = w.lods[T];
-          if (!(d && _.max_height >= 2048) && !(_e() && _.max_height > 4096) && (_.max_height > D || !N && T === 0)) {
-            if (N = !0, i.texture_lod = T, R && i.texture_lod < s.lastLodLevel_Texture) {
-              const x = _.max_height;
-              console.log(`Texture LOD changed: ${s.lastLodLevel_Texture} → ${i.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 L = s.lastScreenCoverage * 4;
+        this.context?.engine === "model-viewer" && (L *= 1.5);
+        const I = _ / window.devicePixelRatio * L;
+        let C = !1;
+        for (let W = y.lods.length - 1; W >= 0; W--) {
+          const b = y.lods[W];
+          if (!(x && b.max_height >= 2048) && !(_e() && b.max_height > 4096) && (b.max_height > I || !C && W === 0)) {
+            if (C = !0, i.texture_lod = W, $ && i.texture_lod < s.lastLodLevel_Texture) {
+              const O = b.max_height;
+              console.log(`Texture LOD changed: ${s.lastLodLevel_Texture} → ${i.texture_lod} = ${O}px 
+Screensize: ${I.toFixed(0)}px, Coverage: ${(100 * s.lastScreenCoverage).toFixed(2)}%, Volume ${f.toFixed(1)} 
 ${e.name}`);
             }
             break;
@@ -1357,7 +1363,7 @@ class xt {
   lastLodLevel_Mesh = -1;
   lastLodLevel_Texture = -1;
   lastScreenCoverage = 0;
-  lastScreenspaceVolume = new A();
+  lastScreenspaceVolume = new R();
   lastCentrality = 0;
 }
 const be = /* @__PURE__ */ Symbol("NEEDLE_mesh_lod"), ie = /* @__PURE__ */ Symbol("NEEDLE_texture_lod");
@@ -1396,15 +1402,15 @@ function $e(o) {
 `, o.getAttribute("src"));
   let t = null, e = null, s = null;
   for (let r = o; r != null; r = Object.getPrototypeOf(r)) {
-    const i = Object.getOwnPropertySymbols(r), n = i.find((u) => u.toString() == "Symbol(renderer)"), l = i.find((u) => u.toString() == "Symbol(scene)"), a = i.find((u) => u.toString() == "Symbol(needsRender)");
-    !t && n != null && (t = o[n].threeRenderer), !e && l != null && (e = o[l]), !s && a != null && (s = o[a]);
+    const i = Object.getOwnPropertySymbols(r), n = i.find((u) => u.toString() == "Symbol(renderer)"), a = i.find((u) => u.toString() == "Symbol(scene)"), l = i.find((u) => u.toString() == "Symbol(needsRender)");
+    !t && n != null && (t = o[n].threeRenderer), !e && a != null && (e = o[a]), !s && l != null && (s = o[l]);
   }
   if (t && e) {
     let r = function() {
       if (s) {
-        let n = 0, l = setInterval(() => {
+        let n = 0, a = setInterval(() => {
           if (n++ > 5) {
-            clearInterval(l);
+            clearInterval(a);
             return;
           }
           s?.call(o);
@@ -1447,30 +1453,30 @@ class _t {
     e[ie] = !0;
     const s = this.tryGetCurrentGLTF(t), r = this.tryGetCurrentModelViewer(t), i = this.getUrl(r);
     if (i && s && e.material) {
-      let n = function(a) {
-        if (a[ie] == !0) return;
-        a[ie] = !0, a.userData && (a.userData.LOD = -1);
-        const u = Object.keys(a);
+      let n = function(l) {
+        if (l[ie] == !0) return;
+        l[ie] = !0, l.userData && (l.userData.LOD = -1);
+        const u = Object.keys(l);
         for (let c = 0; c < u.length; c++) {
-          const y = u[c], 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);
+          const g = u[c], y = l[g];
+          if (y?.isTexture === !0) {
+            const v = y.userData?.associations?.textures;
+            if (v == null) continue;
+            const _ = s.parser.json.textures[v];
+            if (!_) {
+              console.warn("Texture data not found for texture index " + v);
               continue;
             }
-            if (k?.extensions?.[W]) {
-              const v = k.extensions[W];
-              v && i && m.registerTexture(i, w, v.lods.length, L, v);
+            if (_?.extensions?.[U]) {
+              const P = _.extensions[U];
+              P && i && m.registerTexture(i, y, P.lods.length, v, P);
             }
           }
         }
       };
-      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) n(l);
+      else n(a);
     }
   }
   tryParseMeshLOD(t, e) {
@@ -1479,7 +1485,7 @@ class _t {
     const s = this.tryGetCurrentModelViewer(t), r = this.getUrl(s);
     if (!r)
       return;
-    const i = e.userData?.gltfExtensions?.[W];
+    const i = e.userData?.gltfExtensions?.[U];
     if (i && r) {
       const n = e.uuid;
       m.registerMesh(r, n, e, 0, i.lods.length, i);