@needle-tools/gltf-progressive 3.6.0-alpha.2 → 3.6.0-alpha.3

package/gltf-progressive.js

@@ -1,53 +1,53 @@
-import { BufferGeometry as j, Mesh as K, Box3 as le, Vector3 as k, Sphere as Se, CompressedTexture as ze, Texture as G, Matrix3 as Ee, InterleavedBuffer as Ne, InterleavedBufferAttribute as Ve, BufferAttribute as Xe, TextureLoader as je, Color as Ce, Matrix4 as Pe, Clock as Ke } from "three";
-import { GLTFLoader as we } from "three/examples/jsm/loaders/GLTFLoader.js";
+import { BufferGeometry as j, Mesh as K, Box3 as ue, Vector3 as P, Sphere as Ce, CompressedTexture as ze, Texture as q, Matrix3 as Ee, InterleavedBuffer as Ne, InterleavedBufferAttribute as Ve, BufferAttribute as Xe, TextureLoader as je, Color as ke, Matrix4 as Pe, Clock as Ke } from "three";
+import { GLTFLoader as Le } from "three/examples/jsm/loaders/GLTFLoader.js";
 import { MeshoptDecoder as Ye } from "three/examples/jsm/libs/meshopt_decoder.module.js";
 import { DRACOLoader as He } from "three/examples/jsm/loaders/DRACOLoader.js";
 import { KTX2Loader as Qe } from "three/examples/jsm/loaders/KTX2Loader.js";
 const Je = "";
 globalThis.GLTF_PROGRESSIVE_VERSION = Je;
 console.debug("[gltf-progressive] version -");
-let I = "https://www.gstatic.com/draco/versioned/decoders/1.5.7/", Y = "https://cdn.needle.tools/static/three/0.179.1/basis2/";
-const Ze = I, et = Y, ke = new URL(I + "draco_decoder.js");
-ke.searchParams.append("range", "true");
-fetch(ke, {
+let $ = "https://www.gstatic.com/draco/versioned/decoders/1.5.7/", Y = "https://cdn.needle.tools/static/three/0.179.1/basis2/";
+const Ze = $, et = Y, Re = new URL($ + "draco_decoder.js");
+Re.searchParams.append("range", "true");
+fetch(Re, {
   method: "GET",
   headers: {
     Range: "bytes=0-1"
   }
 }).catch((i) => {
-  console.debug(`Failed to fetch remote Draco decoder from ${I} (offline: ${typeof navigator < "u" ? navigator.onLine : "unknown"})`), I === Ze && st("./include/draco/"), Y === et && rt("./include/ktx2/");
+  console.debug(`Failed to fetch remote Draco decoder from ${$} (offline: ${typeof navigator < "u" ? navigator.onLine : "unknown"})`), $ === Ze && st("./include/draco/"), Y === et && rt("./include/ktx2/");
 }).finally(() => {
-  Re();
+  Ie();
 });
 const tt = () => ({
-  dracoDecoderPath: I,
+  dracoDecoderPath: $,
   ktx2TranscoderPath: Y
 });
 function st(i) {
-  I = i, P && P[me] != I ? (console.debug("Updating Draco decoder path to " + i), P[me] = I, P.setDecoderPath(I), P.preload()) : console.debug("Setting Draco decoder path to " + i);
+  $ = i, k && k[ye] != $ ? (console.debug("Updating Draco decoder path to " + i), k[ye] = $, k.setDecoderPath($), k.preload()) : console.debug("Setting Draco decoder path to " + i);
 }
 function rt(i) {
-  Y = i, $ && $.transcoderPath != Y ? (console.debug("Updating KTX2 transcoder path to " + i), $.setTranscoderPath(Y), $.init()) : console.debug("Setting KTX2 transcoder path to " + i);
+  Y = i, B && B.transcoderPath != Y ? (console.debug("Updating KTX2 transcoder path to " + i), B.setTranscoderPath(Y), B.init()) : console.debug("Setting KTX2 transcoder path to " + i);
 }
-function Le(i) {
-  return Re(), i ? $.detectSupport(i) : i !== null && console.warn("No renderer provided to detect ktx2 support - loading KTX2 textures might fail"), { dracoLoader: P, ktx2Loader: $, meshoptDecoder: ae };
+function ve(i) {
+  return Ie(), i ? B.detectSupport(i) : i !== null && console.warn("No renderer provided to detect ktx2 support - loading KTX2 textures might fail"), { dracoLoader: k, ktx2Loader: B, meshoptDecoder: le };
 }
 function Ae(i) {
-  i.dracoLoader || i.setDRACOLoader(P), i.ktx2Loader || i.setKTX2Loader($), i.meshoptDecoder || i.setMeshoptDecoder(ae);
+  i.dracoLoader || i.setDRACOLoader(k), i.ktx2Loader || i.setKTX2Loader(B), i.meshoptDecoder || i.setMeshoptDecoder(le);
 }
-const me = /* @__PURE__ */ Symbol("dracoDecoderPath");
-let P, ae, $;
-function Re() {
-  P || (P = new He(), P[me] = I, P.setDecoderPath(I), P.setDecoderConfig({ type: "js" }), P.preload()), $ || ($ = new Qe(), $.setTranscoderPath(Y), $.init()), ae || (ae = Ye);
+const ye = /* @__PURE__ */ Symbol("dracoDecoderPath");
+let k, le, B;
+function Ie() {
+  k || (k = new He(), k[ye] = $, k.setDecoderPath($), k.setDecoderConfig({ type: "js" }), k.preload()), B || (B = new Qe(), B.setTranscoderPath(Y), B.init()), le || (le = Ye);
 }
-const ye = /* @__PURE__ */ new WeakMap();
-function Ie(i, t) {
-  let e = ye.get(i);
-  e ? e = Object.assign(e, t) : e = t, ye.set(i, e);
+const xe = /* @__PURE__ */ new WeakMap();
+function $e(i, t) {
+  let e = xe.get(i);
+  e ? e = Object.assign(e, t) : e = t, xe.set(i, e);
 }
-const nt = we.prototype.load;
-function ot(...i) {
-  const t = ye.get(this);
+const nt = Le.prototype.load;
+function it(...i) {
+  const t = xe.get(this);
   let e = i[0];
   const s = new URL(e, window.location.href);
   if (s.hostname.endsWith("needle.tools")) {
@@ -56,14 +56,14 @@ function ot(...i) {
   }
   return i[0] = e, nt?.call(this, ...i);
 }
-we.prototype.load = ot;
+Le.prototype.load = it;
 N("debugprogressive");
 function N(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;
 }
-function it(i, t) {
+function ot(i, t) {
   if (t === void 0 || i === void 0 || t.startsWith("./") || t.startsWith("http") || t.startsWith("data:") || t.startsWith("blob:"))
     return t;
   const e = i.lastIndexOf("/");
@@ -74,11 +74,11 @@ function it(i, t) {
   }
   return t;
 }
-function ve() {
+function _e() {
   return Z !== void 0 || (Z = /iPhone|iPad|iPod|Android|IEMobile/i.test(navigator.userAgent), N("debugprogressive") && console.log("[glTF Progressive]: isMobileDevice", Z)), Z;
 }
 let Z;
-function $e() {
+function Be() {
   if (typeof window > "u") return !1;
   const i = new URL(window.location.href), t = i.hostname === "localhost" || /^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/.test(i.hostname);
   return i.hostname === "127.0.0.1" || t;
@@ -129,14 +129,14 @@ function ut(i) {
   const r = i.type;
   return r === 1009 || r === 1010 ? s = 1 : r === 1011 || r === 1012 ? s = 2 : r === 1013 || r === 1014 || r === 1015 ? s = 4 : r === 1016 && (s = 2), t * s;
 }
-const ct = typeof window > "u" && typeof document > "u", xe = /* @__PURE__ */ Symbol("needle:raycast-mesh");
+const ct = typeof window > "u" && typeof document > "u", we = /* @__PURE__ */ Symbol("needle:raycast-mesh");
 function ne(i) {
-  return i?.[xe] instanceof j ? i[xe] : null;
+  return i?.[we] instanceof j ? i[we] : null;
 }
 function dt(i, t) {
   if ((i.type === "Mesh" || i.type === "SkinnedMesh") && !ne(i)) {
     const s = ht(t);
-    s.userData = { isRaycastMesh: !0 }, i[xe] = s;
+    s.userData = { isRaycastMesh: !0 }, i[we] = s;
   }
 }
 function ft(i = !0) {
@@ -160,9 +160,9 @@ function ht(i) {
     t.setAttribute(e, i.getAttribute(e));
   return t.setIndex(i.getIndex()), t;
 }
-const E = new Array(), f = N("debugprogressive");
+const E = new Array(), h = N("debugprogressive");
 let re, X = -1;
-if (f) {
+if (h) {
   let i = function() {
     X += 1, X >= t && (X = -1), console.log(`Toggle LOD level [${X}]`);
   };
@@ -173,27 +173,27 @@ if (f) {
     !isNaN(s) && s >= 0 && (X = s, console.log(`Set LOD level to [${X}]`));
   });
 }
-function Be(i) {
-  if (f && re !== void 0)
+function Ge(i) {
+  if (h && re !== void 0)
     if (Array.isArray(i))
       for (const t of i)
-        Be(t);
+        Ge(t);
     else i && "wireframe" in i && (i.wireframe = re === !0);
 }
 const te = new Array();
 let gt = 0;
-const pt = ve() ? 2 : 10;
+const pt = _e() ? 2 : 10;
 function mt(i) {
   if (te.length < pt) {
     const s = te.length;
-    f && console.warn(`[Worker] Creating new worker #${s}`);
-    const r = _e.createWorker(i || {});
+    h && console.warn(`[Worker] Creating new worker #${s}`);
+    const r = De.createWorker(i || {});
     return te.push(r), r;
   }
   const t = gt++ % te.length;
   return te[t];
 }
-class _e {
+class De {
   constructor(t, e) {
     this.worker = t, this._debug = e.debug ?? !1, t.onmessage = (s) => {
       const r = s.data;
@@ -220,7 +220,7 @@ class _e {
     ), {
       type: "module"
     });
-    return new _e(e, t);
+    return new De(e, t);
   }
   _running = [];
   _webglRenderer = null;
@@ -228,22 +228,22 @@ class _e {
     const s = tt();
     let r = e?.renderer;
     r || (this._webglRenderer ??= (async () => {
-      const { WebGLRenderer: l } = await import("three");
-      return new l();
+      const { WebGLRenderer: u } = await import("three");
+      return new u();
     })(), r = await this._webglRenderer);
-    const u = Le(r).ktx2Loader.workerConfig;
+    const a = ve(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: u
+      ktx2LoaderConfig: a
     };
-    return this._debug && console.debug("[Worker] Sending load request", a), this.worker.postMessage(a), new Promise((l) => {
+    return this._debug && console.debug("[Worker] Sending load request", l), this.worker.postMessage(l), new Promise((u) => {
       this._running.push({
         url: t.toString(),
-        resolve: l
+        resolve: u
       });
     });
   }
@@ -254,27 +254,27 @@ function yt(i) {
     const e = t.geometry, s = new j();
     if (s.name = e.name || "", e.index) {
       const r = e.index;
-      s.setIndex(ce(r));
+      s.setIndex(de(r));
     }
     for (const r in e.attributes) {
-      const n = e.attributes[r], o = ce(n);
+      const n = e.attributes[r], o = de(n);
       s.setAttribute(r, o);
     }
     if (e.morphAttributes)
       for (const r in e.morphAttributes) {
-        const o = e.morphAttributes[r].map((u) => ce(u));
+        const o = e.morphAttributes[r].map((a) => de(a));
         s.morphAttributes[r] = o;
       }
-    if (s.morphTargetsRelative = e.morphTargetsRelative ?? !1, s.boundingBox = new le(), s.boundingBox.min = new k(
+    if (s.morphTargetsRelative = e.morphTargetsRelative ?? !1, s.boundingBox = new ue(), s.boundingBox.min = new P(
       e.boundingBox?.min.x,
       e.boundingBox?.min.y,
       e.boundingBox?.min.z
-    ), s.boundingBox.max = new k(
+    ), s.boundingBox.max = new P(
       e.boundingBox?.max.x,
       e.boundingBox?.max.y,
       e.boundingBox?.max.z
-    ), s.boundingSphere = new Se(
-      new k(
+    ), s.boundingSphere = new Ce(
+      new P(
         e.boundingSphere?.center.x,
         e.boundingSphere?.center.y,
         e.boundingSphere?.center.z
@@ -305,7 +305,7 @@ function yt(i) {
         e.colorSpace
       );
     } else
-      s = new G(
+      s = new q(
         e.image,
         e.mapping,
         e.wrapS,
@@ -325,7 +325,7 @@ function yt(i) {
   }
   return i;
 }
-function ce(i) {
+function de(i) {
   let t = i;
   if ("isInterleavedBufferAttribute" in i && i.isInterleavedBufferAttribute) {
     const e = i.data, s = e.array, r = new Ne(s, e.stride);
@@ -335,11 +335,11 @@ function ce(i) {
 }
 const xt = N("gltf-progressive-worker");
 N("gltf-progressive-reduce-mipmaps");
-const se = N("gltf-progressive-gc"), de = /* @__PURE__ */ Symbol("needle-progressive-texture"), F = "NEEDLE_progressive";
-class h {
+const se = N("gltf-progressive-gc"), fe = /* @__PURE__ */ Symbol("needle-progressive-texture"), U = "NEEDLE_progressive";
+class p {
   /** The name of the extension */
   get name() {
-    return F;
+    return U;
   }
   // #region PUBLIC API
   /**
@@ -381,33 +381,33 @@ class h {
       max_count: 0,
       lods: []
     }), Array.isArray(t)) {
-      for (const u of t)
-        this.getMaterialMinMaxLODsCount(u, 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 u = t;
-      for (const a of Object.keys(u.uniforms)) {
-        const l = u.uniforms[a].value;
-        l?.isTexture === !0 && o(l, e);
+    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 && o(u, e);
       }
     } else if (t.isMaterial)
-      for (const u of Object.keys(t)) {
-        const a = t[u];
-        a?.isTexture === !0 && o(a, e);
+      for (const a of Object.keys(t)) {
+        const l = t[a];
+        l?.isTexture === !0 && o(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 o(u, a) {
-      const l = s.getAssignedLODInformation(u);
-      if (l) {
-        const c = s.lodInfos.get(l.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 d = 0; d < c.lods.length; d++) {
-            const g = c.lods[d];
-            g.width && (a.lods[d] = a.lods[d] || { min_height: 1 / 0, max_height: 0 }, a.lods[d].min_height = Math.min(a.lods[d].min_height, g.height), a.lods[d].max_height = Math.max(a.lods[d].max_height, g.height));
+    function o(a, l) {
+      const u = s.getAssignedLODInformation(a);
+      if (u) {
+        const d = s.lodInfos.get(u.key);
+        if (d && d.lods) {
+          l.min_count = Math.min(l.min_count, d.lods.length), l.max_count = Math.max(l.max_count, d.lods.length);
+          for (let c = 0; c < d.lods.length; c++) {
+            const f = d.lods[c];
+            f.width && (l.lods[c] = l.lods[c] || { min_height: 1 / 0, max_height: 0 }, l.lods[c].min_height = Math.min(l.lods[c].min_height, f.height), l.lods[c].max_height = Math.max(l.lods[c].max_height, f.height));
           }
         }
       }
@@ -465,16 +465,21 @@ class h {
       const r = t.geometry, n = this.getAssignedLODInformation(r);
       if (!n)
         return Promise.resolve(null);
-      for (const o of E)
-        o.onBeforeGetLODMesh?.(t, e);
-      return t["LOD:requested level"] = e, h.getOrLoadLOD(r, e).then((o) => {
-        if (Array.isArray(o)) {
+      for (const a of E)
+        a.onBeforeGetLODMesh?.(t, e);
+      t["LOD:requested level"] = e;
+      const o = () => t["LOD:requested level"] === e || this.shouldApplyStaleMeshLOD(t, e);
+      return p.getOrLoadLOD(r, e, {
+        isCurrent: o
+      }).then((a) => {
+        if (Array.isArray(a)) {
           const u = n.index || 0;
-          o = o[u];
+          a = a[u];
         }
-        return t["LOD:requested level"] === e && (delete t["LOD:requested level"], o && r != o && (o?.isBufferGeometry ? typeof s?.apply == "function" ? s.apply(o, e, t) : s?.apply !== !1 && (t.geometry = o) : f && console.error("Invalid LOD geometry", o))), o;
-      }).catch((o) => (console.error("Error loading mesh LOD", t, o), null));
-    } else f && console.error("Invalid call to assignMeshLOD: Request mesh LOD but the object is not a mesh", t);
+        const l = t["LOD:requested level"] === e;
+        return (l || this.shouldApplyStaleMeshLOD(t, e)) && (l && delete t["LOD:requested level"], a && r != a && (a?.isBufferGeometry ? typeof s?.apply == "function" ? s.apply(a, e, t) : s?.apply !== !1 && (t.geometry = a) : h && console.error("Invalid LOD geometry", a))), a;
+      }).catch((a) => (console.error("Error loading mesh LOD", t, a), null));
+    } 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, s) {
@@ -484,48 +489,48 @@ class h {
       const n = t;
       if (Array.isArray(n.material)) {
         const o = new Array();
-        for (const u of n.material) {
-          const a = this.assignTextureLOD(u, e, s);
-          o.push(a);
+        for (const a of n.material) {
+          const l = this.assignTextureLOD(a, e, s);
+          o.push(l);
         }
-        return Promise.all(o).then((u) => {
-          const a = new Array();
-          for (const l of u)
-            Array.isArray(l) && a.push(...l);
-          return a;
+        return Promise.all(o).then((a) => {
+          const l = new Array();
+          for (const u of a)
+            Array.isArray(u) && l.push(...u);
+          return l;
         });
       } else
         return this.assignTextureLOD(n.material, e, s);
     }
     if (t.isMaterial === !0) {
-      const n = t, o = [], u = new Array();
+      const n = t, o = [], a = new Array();
       if (this.trackCurrentMaterialTextureSlots(n), n.uniforms && (n.isRawShaderMaterial || n.isShaderMaterial === !0)) {
-        const a = n;
-        for (const l of Object.keys(a.uniforms)) {
-          const c = a.uniforms[l].value;
-          if (c?.isTexture === !0) {
-            const d = this.assignTextureLODForSlot(c, e, n, l, r).then((g) => (g && a.uniforms[l].value != g && (a.uniforms[l].value = g, a.uniformsNeedUpdate = !0), g));
-            o.push(d), u.push(l);
+        const l = n;
+        for (const u of Object.keys(l.uniforms)) {
+          const d = l.uniforms[u].value;
+          if (d?.isTexture === !0) {
+            const c = this.assignTextureLODForSlot(d, e, n, u, r).then((f) => (f && l.uniforms[u].value != f && (l.uniforms[u].value = f, l.uniformsNeedUpdate = !0), f));
+            o.push(c), a.push(u);
           }
         }
       } else
-        for (const a of Object.keys(n)) {
-          const l = n[a];
-          if (l?.isTexture === !0) {
-            const c = this.assignTextureLODForSlot(l, e, n, a, r);
-            o.push(c), u.push(a);
+        for (const l of Object.keys(n)) {
+          const u = n[l];
+          if (u?.isTexture === !0) {
+            const d = this.assignTextureLODForSlot(u, e, n, l, r);
+            o.push(d), a.push(l);
           }
         }
-      return Promise.all(o).then((a) => {
-        const l = new Array();
-        for (let c = 0; c < a.length; c++) {
-          const d = a[c], g = u[c];
-          d && d.isTexture === !0 ? l.push({ material: n, slot: g, texture: d, level: e }) : l.push({ material: n, slot: g, texture: null, level: e });
+      return Promise.all(o).then((l) => {
+        const u = new Array();
+        for (let d = 0; d < l.length; d++) {
+          const c = l[d], f = a[d];
+          c && c.isTexture === !0 ? u.push({ material: n, slot: f, texture: c, level: e }) : u.push({ material: n, slot: f, texture: null, level: e });
         }
-        return l;
+        return u;
       });
     }
-    if (t instanceof G || t.isTexture === !0) {
+    if (t instanceof q || t.isTexture === !0) {
       const n = t;
       return this.assignTextureLODForSlot(n, e, null, null, r);
     }
@@ -536,10 +541,10 @@ class h {
    * @default 50 on desktop, 20 on mobile devices
    */
   static set maxConcurrentLoadingTasks(t) {
-    h.queue.maxConcurrent = t;
+    p.queue.maxConcurrent = t;
   }
   static get maxConcurrentLoadingTasks() {
-    return h.queue.maxConcurrent;
+    return p.queue.maxConcurrent;
   }
   // #region INTERNAL
   static assignTextureLODForSlot(t, e, s, r, n) {
@@ -551,33 +556,38 @@ class h {
     if (o && (o.level === e || !n && o.level < e))
       return Promise.resolve(t);
     if (s && r) {
-      const a = this.getPendingTextureSlotRequest(s, r);
-      if (a && a.level === e && a.force === n)
-        return a.promise;
+      const c = this.getPendingTextureSlotRequest(s, r);
+      if (c && c.level === e && c.force === n)
+        return c.promise;
     }
-    const u = h.getOrLoadLOD(t, e).then((a) => {
-      if (Array.isArray(a))
+    const a = s && r ? this.nextTextureSlotRequestId(s, r, e, n) : 0, l = () => !s || !r || this.getLatestTextureSlotRequest(s, r)?.id === a, u = () => l() || this.shouldApplyStaleTextureSlotLOD(s, r, e, n), d = p.getOrLoadLOD(t, e, {
+      isCurrent: u
+    }).then((c) => {
+      if (!l() && !this.shouldApplyStaleTextureSlotLOD(s, r, e, n)) return null;
+      if (Array.isArray(c))
         return console.warn("Progressive: Got an array of textures for a texture slot, this should not happen..."), null;
-      if (a?.isTexture === !0) {
-        if (a != t && s && r) {
-          const l = this.getMaterialTextureSlot(s, r) ?? t;
-          if (l && !n) {
-            const c = this.getAssignedLODInformation(l);
-            if (c && c?.level < e)
-              return f === "verbose" && console.warn("Assigned texture level is already higher: ", c.level, e, s, l, a), null;
+      if (c?.isTexture === !0) {
+        if (c != t && s && r) {
+          const f = this.getMaterialTextureSlot(s, r) ?? t;
+          if (f && !n) {
+            const g = this.getAssignedLODInformation(f);
+            if (g && g?.level < e)
+              return h === "verbose" && console.warn("Assigned texture level is already higher: ", g.level, e, s, f, c), null;
           }
-          this.assignTrackedTextureSlot(s, r, a);
+          this.assignTrackedTextureSlot(s, r, c);
         }
-        return a;
-      } else f == "verbose" && console.warn("No LOD found for", t, e);
+        return c;
+      } else h == "verbose" && console.warn("No LOD found for", t, e);
       return null;
-    }).catch((a) => (console.error("Error loading LOD", t, a), null));
-    return s && r && this.setPendingTextureSlotRequest(s, r, e, n, u), u;
+    }).catch((c) => (console.error("Error loading LOD", t, c), null));
+    return s && r && this.setPendingTextureSlotRequest(s, r, e, n, a, d), d;
   }
   // Track material slots, not just texture objects. A shared fallback texture can be
   // referenced by many slots and should only be disposed after every slot moved away.
   static trackedTextureSlots = /* @__PURE__ */ new WeakMap();
   static pendingTextureSlotRequests = /* @__PURE__ */ new WeakMap();
+  static latestTextureSlotRequests = /* @__PURE__ */ new WeakMap();
+  static textureSlotRequestId = 0;
   static trackCurrentMaterialTextureSlots(t) {
     if (t.uniforms && (t.isRawShaderMaterial || t.isShaderMaterial === !0)) {
       const e = t;
@@ -595,12 +605,32 @@ class h {
   static getPendingTextureSlotRequest(t, e) {
     return this.pendingTextureSlotRequests.get(t)?.get(e);
   }
-  static setPendingTextureSlotRequest(t, e, s, r, n) {
-    let o = this.pendingTextureSlotRequests.get(t);
-    o || (o = /* @__PURE__ */ new Map(), this.pendingTextureSlotRequests.set(t, o));
-    const u = { level: s, force: r, promise: n };
-    o.set(e, u), n.finally(() => {
-      o.get(e) === u && o.delete(e);
+  static nextTextureSlotRequestId(t, e, s, r) {
+    let n = this.latestTextureSlotRequests.get(t);
+    n || (n = /* @__PURE__ */ new Map(), this.latestTextureSlotRequests.set(t, n));
+    const o = ++this.textureSlotRequestId;
+    return n.set(e, { id: o, level: s, force: r }), o;
+  }
+  static getLatestTextureSlotRequest(t, e) {
+    return this.latestTextureSlotRequests.get(t)?.get(e);
+  }
+  static shouldApplyStaleTextureSlotLOD(t, e, s, r) {
+    if (!t || !e) return !1;
+    const n = this.getLatestTextureSlotRequest(t, e), o = this.getMaterialTextureSlot(t, e), a = this.getAssignedLODInformation(o)?.level ?? 1 / 0;
+    return s >= a ? !1 : r ? n ? s >= n.level : !1 : !0;
+  }
+  static shouldApplyStaleMeshLOD(t, e) {
+    const s = t["LOD:requested level"];
+    if (typeof s != "number") return !1;
+    const r = this.getAssignedLODInformation(t.geometry)?.level ?? 1 / 0;
+    return e < r && e >= s;
+  }
+  static setPendingTextureSlotRequest(t, e, s, r, n, o) {
+    let a = this.pendingTextureSlotRequests.get(t);
+    a || (a = /* @__PURE__ */ new Map(), this.pendingTextureSlotRequests.set(t, a));
+    const l = { level: s, force: r, id: n, promise: o };
+    a.set(e, l), o.finally(() => {
+      a.get(e)?.id === n && a.delete(e);
     });
   }
   static getMaterialTextureSlot(t, e) {
@@ -633,7 +663,7 @@ class h {
   }
   static releaseTrackedTextureSlot(t, e, s) {
     const r = this.trackedTextureSlots.get(t);
-    if (r?.get(e) === s && r.delete(e), this.untrackTextureUsage(s) && (f || se)) {
+    if (r?.get(e) === s && r.delete(e), this.untrackTextureUsage(s) && (h || se)) {
       const o = this.getAssignedLODInformation(s);
       console.log(`[gltf-progressive] Disposed old texture LOD ${o?.level ?? "?"} for ${t.name || t.type}.${e}`, s.uuid);
     }
@@ -642,13 +672,13 @@ class h {
   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?.[F];
-    return e ? (this._isLoadingMesh = !0, this.parser.getDependency("mesh", t).then((s) => (this._isLoadingMesh = !1, s && h.registerMesh(this.url, e.guid, s, e.lods?.length, 0, e), s))) : null;
+    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 && p.registerMesh(this.url, e.guid, s, e.lods?.length, 0, e), s))) : null;
   };
   // private _isLoadingTexture;
   // loadTexture = (textureIndex: number) => {
@@ -665,30 +695,30 @@ class h {
   //     });
   // }
   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[F];
+        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 n = !1;
           for (const o of this.parser.associations.keys())
-            o.isTexture === !0 && this.parser.associations.get(o)?.textures === s && (n = !0, h.registerTexture(this.url, o, r.lods?.length, s, r));
+            o.isTexture === !0 && this.parser.associations.get(o)?.textures === s && (n = !0, p.registerTexture(this.url, o, r.lods?.length, s, r));
           n || this.parser.getDependency("texture", s).then((o) => {
-            o && h.registerTexture(this.url, o, r.lods?.length, s, r);
+            o && p.registerTexture(this.url, o, r.lods?.length, s, r);
           });
         }
       }
     }), this.parser.json.meshes?.forEach((e, s) => {
       if (e?.extensions) {
-        const r = e?.extensions[F];
+        const r = e?.extensions[U];
         if (r && r.lods) {
           for (const n of this.parser.associations.keys())
             if (n.isMesh) {
               const o = this.parser.associations.get(n);
-              o?.meshes === s && h.registerMesh(this.url, r.guid, n, r.lods.length, o.primitives, r);
+              o?.meshes === s && p.registerMesh(this.url, r.guid, n, r.lods.length, o.primitives, r);
             }
         }
       }
@@ -707,16 +737,16 @@ class h {
    */
   static registerTexture = (t, e, s, r, n) => {
     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 u = 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: ${u}x${a}, Max: ${n.lods[0]?.width}x${n.lods[0]?.height}, uuid: ${e.uuid}`, n, 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: ${n.lods[0]?.width}x${n.lods[0]?.height}, uuid: ${e.uuid}`, n, e);
     }
-    e.source && (e.source[de] = n);
+    e.source && (e.source[fe] = n);
     const o = n.guid;
-    h.assignLODInformation(t, e, o, s, r), h.lodInfos.set(o, n), h.lowresCache.set(o, new WeakRef(e));
+    p.assignLODInformation(t, e, o, s, r), p.lodInfos.set(o, n), p.lowresCache.set(o, new WeakRef(e));
   };
   /**
    * Register a mesh with progressive LOD information. This associates the mesh geometry with its LOD extension data
@@ -732,16 +762,16 @@ class h {
    * @param ext - The parsed progressive mesh extension data containing all available LOD levels with vertex/index counts and densities.
    */
   static registerMesh = (t, e, s, r, n, o) => {
-    const u = s.geometry;
-    if (!u) {
-      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;
     }
-    u.userData || (u.userData = {}), f && console.log("> Progressive: register mesh " + s.name, { index: n, uuid: s.uuid }, o, s), h.assignLODInformation(t, u, e, r, n), h.lodInfos.set(e, o);
-    let l = h.lowresCache.get(e)?.deref();
-    l ? l.push(s.geometry) : l = [s.geometry], h.lowresCache.set(e, new WeakRef(l)), r > 0 && !ne(s) && dt(s, u);
-    for (const c of E)
-      c.onRegisteredNewMesh?.(s, o);
+    a.userData || (a.userData = {}), h && console.log("> Progressive: register mesh " + s.name, { index: n, uuid: s.uuid }, o, s), p.assignLODInformation(t, a, e, r, n), p.lodInfos.set(e, o);
+    let u = p.lowresCache.get(e)?.deref();
+    u ? u.push(s.geometry) : u = [s.geometry], p.lowresCache.set(e, new WeakRef(u)), r > 0 && !ne(s) && dt(s, a);
+    for (const d of E)
+      d.onRegisteredNewMesh?.(s, o);
   };
   /**
    * Dispose cached resources to free memory.
@@ -782,7 +812,7 @@ class h {
       this.lowresCache.clear();
       for (const [, e] of this.cache)
         this._disposeCacheEntry(e);
-      this.cache.clear(), this.textureRefCounts.clear(), this.trackedTextureSlots = /* @__PURE__ */ new WeakMap(), this.pendingTextureSlotRequests = /* @__PURE__ */ new WeakMap();
+      this.cache.clear(), this.textureRefCounts.clear(), this.trackedTextureSlots = /* @__PURE__ */ new WeakMap(), this.pendingTextureSlotRequests = /* @__PURE__ */ new WeakMap(), this.latestTextureSlotRequests = /* @__PURE__ */ new WeakMap(), this.textureSlotRequestId = 0;
     }
   }
   /** Dispose a single cache entry's three.js resource(s) to free GPU memory. */
@@ -814,16 +844,16 @@ class h {
    * The held value is the cache key string used in `previouslyLoaded`.
    */
   static _resourceRegistry = new FinalizationRegistry((t) => {
-    const e = h.cache.get(t);
-    (f || se) && console.debug(`[gltf-progressive] Memory: Resource GC'd
-${t}`), e instanceof WeakRef && (e.deref() || (h.cache.delete(t), (f || se) && console.log("[gltf-progressive] ↪ Cache entry deleted (GC)")));
+    const e = p.cache.get(t);
+    (h || se) && console.debug(`[gltf-progressive] Memory: Resource GC'd
+${t}`), e instanceof WeakRef && (e.deref() || (p.cache.delete(t), (h || se) && 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.
@@ -833,147 +863,154 @@ ${t}`), e instanceof WeakRef && (e.deref() || (h.cache.delete(t), (f || se) && c
   static untrackTextureUsage(t) {
     const e = t.uuid, s = this.textureRefCounts.get(e);
     if (!s)
-      return (f === "verbose" || se) && n("[gltf-progressive] Memory: Untrack untracked texture (dispose immediately)", 0), t.dispose(), !0;
+      return (h === "verbose" || se) && n("[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 || se) && n("[gltf-progressive] Memory: Dispose texture", r), t.dispose(), !0;
-    return this.textureRefCounts.set(e, r), f === "verbose" && n("[gltf-progressive] Memory: Untrack texture", r), !1;
-    function n(o, u) {
-      const a = t.image?.width || t.source?.data?.width || 0, l = t.image?.height || t.source?.data?.height || 0, c = a && l ? `${a}x${l}` : "N/A";
-      let d = "N/A";
-      a && l && (d = `~${(lt(t) / (1024 * 1024)).toFixed(2)} MB`), console.log(`${o} — ${t.name} ${c} (${d}), refCount: ${s} → ${u}
+      return this.textureRefCounts.delete(e), (h || se) && n("[gltf-progressive] Memory: Dispose texture", r), t.dispose(), !0;
+    return this.textureRefCounts.set(e, r), h === "verbose" && n("[gltf-progressive] Memory: Untrack texture", r), !1;
+    function n(o, a) {
+      const l = t.image?.width || t.source?.data?.width || 0, u = t.image?.height || t.source?.data?.height || 0, d = l && u ? `${l}x${u}` : "N/A";
+      let c = "N/A";
+      l && u && (c = `~${(lt(t) / (1024 * 1024)).toFixed(2)} MB`), console.log(`${o} — ${t.name} ${d} (${c}), refCount: ${s} → ${a}
 ${e}`);
     }
   }
   static workers = [];
   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 n = r?.key;
-    let o;
+  static async getOrLoadLOD(t, e, s) {
+    const r = h == "verbose", n = this.getAssignedLODInformation(t);
+    if (!n)
+      return h && console.warn(`[gltf-progressive] No LOD information found: ${t.name}, uuid: ${t.uuid}, type: ${t.type}`, t), null;
+    const o = n?.key;
+    let a;
     if (t.isTexture === !0) {
-      const a = t;
-      a.source && a.source[de] && (o = a.source[de]);
+      const u = t;
+      u.source && u.source[fe] && (a = u.source[fe]);
     }
-    if (o || (o = h.lodInfos.get(n)), !o)
-      f && console.warn(`Can not load LOD ${e}: no LOD info found for "${n}" ${t.name}`, t.type, h.lodInfos);
+    if (a || (a = p.lodInfos.get(o)), !a)
+      h && console.warn(`Can not load LOD ${e}: no LOD info found for "${o}" ${t.name}`, t.type, p.lodInfos);
     else {
       if (e > 0) {
         let c = !1;
-        const d = Array.isArray(o.lods);
-        if (d && e >= o.lods.length ? c = !0 : d || (c = !0), c) {
-          const g = this.lowresCache.get(n);
+        const f = Array.isArray(a.lods);
+        if (f && e >= a.lods.length ? c = !0 : f || (c = !0), c) {
+          const g = this.lowresCache.get(o);
           if (g) {
-            const m = g.deref();
-            if (m) return m;
-            this.lowresCache.delete(n), f && console.log(`[gltf-progressive] Lowres cache entry was GC'd: ${n}`);
+            const O = g.deref();
+            if (O) return O;
+            this.lowresCache.delete(o), h && console.log(`[gltf-progressive] Lowres cache entry was GC'd: ${o}`);
           }
           return null;
         }
       }
-      const a = Array.isArray(o.lods) ? o.lods[e]?.path : o.lods;
-      if (!a)
-        return f && !o["missing:uri"] && (o["missing:uri"] = !0, console.warn("Missing uri for progressive asset for LOD " + e, o)), null;
-      const l = it(r.url, a);
-      if (l.endsWith(".glb") || l.endsWith(".gltf")) {
-        if (!o.guid)
-          return console.warn("missing pointer for glb/gltf texture", o), null;
-        const c = l + "_" + o.guid, d = await this.tryResolveLODCacheEntry(this.cache.get(c), c, l, t, e, s);
-        if (d.found) return d.value;
-        const g = await this.queue.slot(l), m = await this.tryResolveLODCacheEntry(this.cache.get(c), c, l, t, e, s);
-        if (m.found) return m.value;
+      const u = Array.isArray(a.lods) ? a.lods[e]?.path : a.lods;
+      if (!u)
+        return h && !a["missing:uri"] && (a["missing:uri"] = !0, console.warn("Missing uri for progressive asset for LOD " + e, a)), null;
+      const d = ot(n.url, u);
+      if (d.endsWith(".glb") || d.endsWith(".gltf")) {
+        if (!a.guid)
+          return console.warn("missing pointer for glb/gltf texture", a), null;
+        const c = d + "_" + a.guid, f = await this.tryResolveLODCacheEntry(this.cache.get(c), c, d, t, e, r);
+        if (f.found) return f.value;
+        if (s?.isCurrent?.() === !1)
+          return r && console.log(`Skipping stale LOD ${e} request before queue: ${d}`), null;
+        const g = await this.queue.slot(d);
+        if (s?.isCurrent?.() === !1)
+          return r && console.log(`Skipping stale LOD ${e} request after queue: ${d}`), null;
+        const O = await this.tryResolveLODCacheEntry(this.cache.get(c), c, d, t, e, r);
+        if (O.found) return O.value;
         if (!g.use)
-          return f && console.log(`LOD ${e} was aborted: ${l}`), null;
-        const x = o, v = new Promise(async (_, C) => {
+          return h && console.log(`LOD ${e} was aborted: ${d}`), null;
+        const y = a, x = new Promise(async (L, V) => {
           if (xt) {
-            const y = await (await mt({})).load(l);
-            if (y.textures.length > 0)
-              for (const M of y.textures) {
-                let b = M.texture;
-                return h.assignLODInformation(r.url, b, n, e, void 0), t instanceof G && (b = this.copySettings(t, b)), b && (b.guid = x.guid), _(b);
+            const m = await (await mt({})).load(d);
+            if (m.textures.length > 0)
+              for (const D of m.textures) {
+                let M = D.texture;
+                return p.assignLODInformation(n.url, M, o, e, void 0), t instanceof q && (M = this.copySettings(t, M)), M && (M.guid = y.guid), L(M);
               }
-            if (y.geometries.length > 0) {
-              const M = new Array();
-              for (const b of y.geometries) {
-                const B = b.geometry;
-                h.assignLODInformation(r.url, B, n, e, b.primitiveIndex), M.push(B);
+            if (m.geometries.length > 0) {
+              const D = new Array();
+              for (const M of m.geometries) {
+                const G = M.geometry;
+                p.assignLODInformation(n.url, G, o, e, M.primitiveIndex), D.push(G);
               }
-              return _(M);
+              return L(D);
             }
-            return _(null);
+            return L(null);
           }
-          const W = new we();
-          Ae(W), f && (await new Promise((D) => setTimeout(D, 1e3)), s && console.warn("Start loading (delayed) " + l, x.guid));
-          let L = l;
-          if (x && Array.isArray(x.lods)) {
-            const D = x.lods[e];
-            D.hash && (L += "?v=" + D.hash);
+          const w = new Le();
+          Ae(w), h && (await new Promise((b) => setTimeout(b, 1e3)), r && console.warn("Start loading (delayed) " + d, y.guid));
+          let S = d;
+          if (y && Array.isArray(y.lods)) {
+            const b = y.lods[e];
+            b.hash && (S += "?v=" + b.hash);
           }
-          const w = await W.loadAsync(L).catch((D) => (console.error(`Error loading LOD ${e} from ${l}
-`, D), _(null)));
-          if (!w)
-            return _(null);
-          const S = w.parser;
-          s && console.log("Loading finished " + l, x.guid);
-          let O = 0;
-          if (w.parser.json.textures) {
-            let D = !1;
-            for (const y of w.parser.json.textures) {
-              if (y?.extensions) {
-                const M = y?.extensions[F];
-                if (M?.guid && M.guid === x.guid) {
-                  D = !0;
+          const _ = await w.loadAsync(S).catch((b) => (console.error(`Error loading LOD ${e} from ${d}
+`, b), L(null)));
+          if (!_)
+            return L(null);
+          const R = _.parser;
+          r && console.log("Loading finished " + d, y.guid);
+          let C = 0;
+          if (_.parser.json.textures) {
+            let b = !1;
+            for (const m of _.parser.json.textures) {
+              if (m?.extensions) {
+                const D = m?.extensions[U];
+                if (D?.guid && D.guid === y.guid) {
+                  b = !0;
                   break;
                 }
               }
-              O++;
+              C++;
             }
-            if (D) {
-              let y = await S.getDependency("texture", O);
-              return y && h.assignLODInformation(r.url, y, n, e, void 0), s && console.log('change "' + t.name + '" → "' + y.name + '"', l, O, y, c), t instanceof G && (y = this.copySettings(t, y)), y && (y.guid = x.guid), _(y);
-            } else f && console.warn("Could not find texture with guid", x.guid, w.parser.json);
+            if (b) {
+              let m = await R.getDependency("texture", C);
+              return m && p.assignLODInformation(n.url, m, o, e, void 0), r && console.log('change "' + t.name + '" → "' + m.name + '"', d, C, m, c), t instanceof q && (m = this.copySettings(t, m)), m && (m.guid = y.guid), L(m);
+            } else h && console.warn("Could not find texture with guid", y.guid, _.parser.json);
           }
-          if (O = 0, w.parser.json.meshes) {
-            let D = !1;
-            for (const y of w.parser.json.meshes) {
-              if (y?.extensions) {
-                const M = y?.extensions[F];
-                if (M?.guid && M.guid === x.guid) {
-                  D = !0;
+          if (C = 0, _.parser.json.meshes) {
+            let b = !1;
+            for (const m of _.parser.json.meshes) {
+              if (m?.extensions) {
+                const D = m?.extensions[U];
+                if (D?.guid && D.guid === y.guid) {
+                  b = !0;
                   break;
                 }
               }
-              O++;
+              C++;
             }
-            if (D) {
-              const y = await S.getDependency("mesh", O);
-              if (s && console.log(`Loaded Mesh "${y.name}"`, l, O, y, c), y.isMesh === !0) {
-                const M = y.geometry;
-                return h.assignLODInformation(r.url, M, n, e, 0), _(M);
+            if (b) {
+              const m = await R.getDependency("mesh", C);
+              if (r && console.log(`Loaded Mesh "${m.name}"`, d, C, m, c), m.isMesh === !0) {
+                const D = m.geometry;
+                return p.assignLODInformation(n.url, D, o, e, 0), L(D);
               } else {
-                const M = new Array();
-                for (let b = 0; b < y.children.length; b++) {
-                  const B = y.children[b];
-                  if (B.isMesh === !0) {
-                    const V = B.geometry;
-                    h.assignLODInformation(r.url, V, n, e, b), M.push(V);
+                const D = new Array();
+                for (let M = 0; M < m.children.length; M++) {
+                  const G = m.children[M];
+                  if (G.isMesh === !0) {
+                    const ie = G.geometry;
+                    p.assignLODInformation(n.url, ie, o, e, M), D.push(ie);
                   }
                 }
-                return _(M);
+                return L(D);
               }
-            } else f && console.warn("Could not find mesh with guid", x.guid, w.parser.json);
+            } else h && console.warn("Could not find mesh with guid", y.guid, _.parser.json);
           }
-          return _(null);
+          return L(null);
         });
-        this.cache.set(c, v), g.use(v);
-        const p = await v;
-        return p != null ? p instanceof G ? (this.cache.set(c, new WeakRef(p)), h._resourceRegistry.register(p, c)) : Array.isArray(p) ? this.cache.set(c, Promise.resolve(p)) : this.cache.set(c, Promise.resolve(p)) : this.cache.set(c, Promise.resolve(null)), p;
-      } else if (t instanceof G) {
-        s && console.log("Load texture from uri: " + l);
-        const d = await new je().loadAsync(l);
-        return d ? (d.guid = o.guid, d.flipY = !1, d.needsUpdate = !0, d.colorSpace = t.colorSpace, s && console.log(o, d)) : f && console.warn("failed loading", l), d;
+        this.cache.set(c, x), g.use(x);
+        const v = await x;
+        return v != null ? v instanceof q ? (this.cache.set(c, new WeakRef(v)), p._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;
+      } else if (t instanceof q) {
+        if (s?.isCurrent?.() === !1)
+          return r && console.log(`Skipping stale texture LOD ${e} request: ${d}`), null;
+        r && console.log("Load texture from uri: " + d);
+        const f = await new je().loadAsync(d);
+        return s?.isCurrent?.() === !1 ? (f?.dispose(), null) : (f ? (f.guid = a.guid, f.flipY = !1, f.needsUpdate = !0, f.colorSpace = t.colorSpace, r && console.log(a, f)) : h && console.warn("failed loading", d), f);
       }
     }
     return null;
@@ -982,21 +1019,21 @@ ${e}`);
     if (t === void 0)
       return { found: !1 };
     if (o && console.log(`LOD ${n} was already loading/loaded: ${e}`), t instanceof WeakRef) {
-      const l = t.deref();
-      if (l) {
-        let c = l, d = !1;
-        if (c instanceof G && r instanceof G ? c.image?.data || c.source?.data ? c = this.copySettings(r, c) : d = !0 : c instanceof j && r instanceof j && (c.attributes.position?.array || (d = !0)), !d)
-          return { found: !0, value: c };
+      const u = t.deref();
+      if (u) {
+        let d = u, c = !1;
+        if (d instanceof q && r instanceof q ? d.image?.data || d.source?.data ? d = this.copySettings(r, d) : c = !0 : d instanceof j && r instanceof j && (d.attributes.position?.array || (c = !0)), !c)
+          return { found: !0, value: d };
       }
-      return this.cache.delete(e), f && console.log(`[gltf-progressive] Re-loading GC'd/disposed resource: ${e}`), { found: !1 };
+      return this.cache.delete(e), h && console.log(`[gltf-progressive] Re-loading GC'd/disposed resource: ${e}`), { found: !1 };
     }
-    let u = await t.catch((l) => (console.error(`Error loading LOD ${n} from ${s}
-`, l), null)), a = !1;
-    return u == null || (u instanceof G && r instanceof G ? u.image?.data || u.source?.data ? u = this.copySettings(r, u) : (a = !0, this.cache.delete(e)) : u instanceof j && r instanceof j && (u.attributes.position?.array || (a = !0, this.cache.delete(e)))), a ? { found: !1 } : { found: !0, value: u };
+    let a = await t.catch((u) => (console.error(`Error loading LOD ${n} from ${s}
+`, u), null)), l = !1;
+    return a == null || (a instanceof q && r instanceof q ? a.image?.data || a.source?.data ? a = this.copySettings(r, a) : (l = !0, this.cache.delete(e)) : a instanceof j && r instanceof j && (a.attributes.position?.array || (l = !0, this.cache.delete(e)))), l ? { found: !1 } : { found: !0, value: a };
   }
   static _queue;
   static get queue() {
-    return this._queue ??= new at(ve() ? 20 : 50, { debug: f != !1 });
+    return this._queue ??= new at(_e() ? 20 : 50, { debug: h != !1 });
   }
   static assignLODInformation(t, e, s, r, n) {
     if (!e) return;
@@ -1009,7 +1046,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;
   }
@@ -1074,7 +1111,7 @@ class oe {
   _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)) {
@@ -1082,7 +1119,7 @@ class oe {
         if (this._seen.has(e)) {
           const 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);
@@ -1101,7 +1138,7 @@ class oe {
     });
   }
 }
-const A = N("debugprogressive"), Lt = A === "colors", vt = N("noprogressive"), fe = /* @__PURE__ */ Symbol("Needle:LODSManager"), he = /* @__PURE__ */ Symbol("Needle:LODState"), q = /* @__PURE__ */ Symbol("Needle:CurrentLOD"), T = { mesh_lod: -1, texture_lod: -1 }, _t = new Ce(), Me = [
+const A = N("debugprogressive"), Lt = A === "colors", vt = N("noprogressive"), he = /* @__PURE__ */ Symbol("Needle:LODSManager"), ge = /* @__PURE__ */ Symbol("Needle:LODState"), F = /* @__PURE__ */ Symbol("Needle:CurrentLOD"), T = { mesh_lod: -1, texture_lod: -1 }, _t = new ke(), Me = [
   3526751,
   11065402,
   15978811,
@@ -1134,12 +1171,12 @@ const A = N("debugprogressive"), Lt = A === "colors", vt = N("noprogressive"), f
   15817653,
   5083278,
   5592405
-], ge = new le(), z = new le(), De = new le(), Mt = new k(), Dt = new k(), bt = new Pe(), U = new k(), H = new k(), Q = new k(), J = new k();
-function Ot(i, t) {
+], pe = new ue(), z = new ue(), Oe = new ue(), Dt = new P(), Mt = new P(), Ot = new Pe(), W = new P(), H = new P(), Q = new P(), J = new P();
+function St(i, t) {
   const e = i.min, s = i.max, r = (e.x + s.x) * 0.5, n = (e.y + s.y) * 0.5;
-  return U.set(r, n, e.z).applyMatrix4(t).z < 0;
+  return W.set(r, n, e.z).applyMatrix4(t).z < 0;
 }
-function Tt(i) {
+function bt(i) {
   const {
     geometry: t,
     matrixWorld: e,
@@ -1147,59 +1184,59 @@ function Tt(i) {
     projectionScreenMatrix: r,
     desiredDensity: n,
     canvasHeight: o = 0,
-    currentLevel: u = -1,
-    xrEnabled: a = !1,
-    debugDrawLine: l,
-    warnMissingPrimitiveDensities: c = !1
-  } = i, d = h.getMeshLODExtension(t)?.lods, g = h.getPrimitiveIndex(t), m = i.target ?? {
-    level: u,
-    primitiveIndex: g,
+    currentLevel: a = -1,
+    xrEnabled: l = !1,
+    debugDrawLine: u,
+    warnMissingPrimitiveDensities: d = !1
+  } = i, c = p.getMeshLODExtension(t)?.lods, f = p.getPrimitiveIndex(t), g = i.target ?? {
+    level: a,
+    primitiveIndex: f,
     screenCoverage: 0,
-    screenspaceVolume: new k(),
+    screenspaceVolume: new P(),
     centrality: 1
   };
-  if (m.level = u, m.primitiveIndex = g, m.screenCoverage = 0, m.screenspaceVolume.set(0, 0, 0), m.centrality = 1, !d?.length) return m;
-  let x = i.boundingBox ?? t.boundingBox;
-  if (x || (t.computeBoundingBox(), x = t.boundingBox), !x) return m;
-  if (ge.copy(x).applyMatrix4(e), s.isPerspectiveCamera && Ot(ge, r))
-    return m.level = 0, m.screenCoverage = 1 / 0, m.screenspaceVolume.set(1 / 0, 1 / 0, 1 / 0), m;
-  if (z.copy(ge).applyMatrix4(r), a && s.isPerspectiveCamera && s.fov > 70) {
-    const L = z.min, w = z.max;
-    let S = L.x, O = L.y, D = w.x, y = w.y;
-    const M = 2, b = 1.5, B = (L.x + w.x) * 0.5, V = (L.y + w.y) * 0.5;
-    S = (S - B) * M + B, O = (O - V) * M + V, D = (D - B) * M + B, y = (y - V) * M + V;
-    const Fe = S < 0 && D > 0 ? 0 : Math.min(Math.abs(L.x), Math.abs(w.x)), qe = O < 0 && y > 0 ? 0 : Math.min(Math.abs(L.y), Math.abs(w.y)), ue = Math.max(Fe, qe);
-    m.centrality = (b - ue) * (b - ue) * (b - ue);
-  }
-  const v = z.getSize(Mt);
-  v.multiplyScalar(0.5), globalThis.screen?.availHeight > 0 && o > 0 && v.multiplyScalar(o / globalThis.screen.availHeight), s.isPerspectiveCamera && (v.x *= s.aspect), De.copy(x).applyMatrix4(e).applyMatrix4(s.matrixWorldInverse);
-  const p = De.getSize(Dt), _ = Math.max(v.x, v.y), C = Math.max(p.x, p.y);
-  _ !== 0 && C !== 0 && (v.z = p.z / C * _);
-  const W = Math.max(v.x, v.y, v.z) * m.centrality;
-  if (m.screenCoverage = W, m.screenspaceVolume.copy(v), W <= 0) return m;
-  if (l) {
-    const L = bt.copy(r);
-    L.invert(), U.copy(z.min), H.copy(z.max), H.x = U.x, Q.copy(z.max), Q.y = U.y, J.copy(z.max);
-    const w = (U.z + J.z) * 0.5;
-    U.z = H.z = Q.z = J.z = w, U.applyMatrix4(L), H.applyMatrix4(L), Q.applyMatrix4(L), J.applyMatrix4(L), l(U, H, 255), l(U, Q, 255), l(H, J, 255), l(Q, J, 255);
-  }
-  for (let L = 0; L < d.length; L++) {
-    const w = d[L], S = w.densities?.[g] || w.density || 1e-5;
-    if (g > 0 && c && $e() && !w.densities && !globalThis["NEEDLE:MISSING_LOD_PRIMITIVE_DENSITIES"] && (globalThis["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 / W < n) {
-      m.level = L;
+  if (g.level = a, g.primitiveIndex = f, g.screenCoverage = 0, g.screenspaceVolume.set(0, 0, 0), g.centrality = 1, !c?.length) return g;
+  let O = i.boundingBox ?? t.boundingBox;
+  if (O || (t.computeBoundingBox(), O = t.boundingBox), !O) return g;
+  if (pe.copy(O).applyMatrix4(e), s.isPerspectiveCamera && St(pe, r))
+    return g.level = 0, g.screenCoverage = 1 / 0, g.screenspaceVolume.set(1 / 0, 1 / 0, 1 / 0), g;
+  if (z.copy(pe).applyMatrix4(r), l && s.isPerspectiveCamera && s.fov > 70) {
+    const w = z.min, S = z.max;
+    let _ = w.x, R = w.y, C = S.x, b = S.y;
+    const m = 2, D = 1.5, M = (w.x + S.x) * 0.5, G = (w.y + S.y) * 0.5;
+    _ = (_ - M) * m + M, R = (R - G) * m + G, C = (C - M) * m + M, b = (b - G) * m + G;
+    const ie = _ < 0 && C > 0 ? 0 : Math.min(Math.abs(w.x), Math.abs(S.x)), Fe = R < 0 && b > 0 ? 0 : Math.min(Math.abs(w.y), Math.abs(S.y)), ce = Math.max(ie, Fe);
+    g.centrality = (D - ce) * (D - ce) * (D - ce);
+  }
+  const y = z.getSize(Dt);
+  y.multiplyScalar(0.5), globalThis.screen?.availHeight > 0 && o > 0 && y.multiplyScalar(o / globalThis.screen.availHeight), s.isPerspectiveCamera && (y.x *= s.aspect), Oe.copy(O).applyMatrix4(e).applyMatrix4(s.matrixWorldInverse);
+  const x = Oe.getSize(Mt), v = Math.max(y.x, y.y), L = Math.max(x.x, x.y);
+  v !== 0 && L !== 0 && (y.z = x.z / L * v);
+  const V = Math.max(y.x, y.y, y.z) * g.centrality;
+  if (g.screenCoverage = V, g.screenspaceVolume.copy(y), V <= 0) return g;
+  if (u) {
+    const w = Ot.copy(r);
+    w.invert(), W.copy(z.min), H.copy(z.max), H.x = W.x, Q.copy(z.max), Q.y = W.y, J.copy(z.max);
+    const S = (W.z + J.z) * 0.5;
+    W.z = H.z = Q.z = J.z = S, W.applyMatrix4(w), H.applyMatrix4(w), Q.applyMatrix4(w), J.applyMatrix4(w), u(W, H, 255), u(W, Q, 255), u(H, J, 255), u(Q, J, 255);
+  }
+  for (let w = 0; w < c.length; w++) {
+    const S = c[w], _ = S.densities?.[f] || S.density || 1e-5;
+    if (f > 0 && d && Be() && !S.densities && !globalThis["NEEDLE:MISSING_LOD_PRIMITIVE_DENSITIES"] && (globalThis["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.")), _ / V < n) {
+      g.level = w;
       break;
     }
   }
-  return m;
+  return g;
 }
-class R {
+class I {
   /** 
    * 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.
    */
   static debugDrawLine;
   /** @internal */
   static getObjectLODState(t) {
-    return t[he];
+    return t[ge];
   }
   static addPlugin(t) {
     E.push(t);
@@ -1214,13 +1251,13 @@ class R {
    * @returns The LODsManager instance.
    */
   static get(t, e) {
-    if (t[fe])
-      return console.debug("[gltf-progressive] LODsManager already exists for this renderer"), t[fe];
-    const s = new R(t, {
+    if (t[he])
+      return console.debug("[gltf-progressive] LODsManager already exists for this renderer"), t[he];
+    const s = new I(t, {
       engine: "unknown",
       ...e
     });
-    return t[fe] = s, s;
+    return t[he] = s, s;
   }
   renderer;
   context;
@@ -1297,7 +1334,7 @@ class R {
     const r = performance.now();
     return s.ready.finally(() => {
       const n = this._newPromiseGroups.indexOf(s);
-      n >= 0 && (this._newPromiseGroups.splice(n, 1), $e() && performance.measure("LODsManager:awaitLoading", {
+      n >= 0 && (this._newPromiseGroups.splice(n, 1), Be() && performance.measure("LODsManager:awaitLoading", {
         start: r,
         detail: { id: e, name: t?.name, awaited: s.awaitedCount, resolved: s.resolvedCount }
       }));
@@ -1353,10 +1390,10 @@ class R {
     this.renderer = t, this.context = { ...e };
   }
   #t;
-  #o = new Ke();
+  #i = new Ke();
   #r = 0;
   #n = 0;
-  #i = 0;
+  #o = 0;
   #s = 0;
   _fpsBuffer = [60, 60, 60, 60, 60];
   /**
@@ -1368,9 +1405,9 @@ class R {
     let t = 0;
     this.#t = this.renderer.render;
     const e = this;
-    Le(this.renderer), this.renderer.render = function(s, r) {
+    ve(this.renderer), this.renderer.render = function(s, r) {
       const n = e.renderer.getRenderTarget();
-      (n == null || "isXRRenderTarget" in n && n.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((u, a) => u + a) / e._fpsBuffer.length, A && e.#r % 200 === 0 && console.log("FPS", Math.round(e.#s), "Interval:", e.#e));
+      (n == null || "isXRRenderTarget" in n && n.isXRRenderTarget) && (t = 0, e.#r += 1, e.#n = e.#i.getDelta(), e.#o += e.#n, e._fpsBuffer.shift(), e._fpsBuffer.push(1 / e.#n), e.#s = e._fpsBuffer.reduce((a, l) => a + l) / e._fpsBuffer.length, A && e.#r % 200 === 0 && console.log("FPS", Math.round(e.#s), "Interval:", e.#e));
       const o = t++;
       e.#t.call(this, s, r), e.onAfterRender(s, r, o);
     };
@@ -1401,8 +1438,8 @@ class R {
     const n = this.renderer.renderLists.get(t, 0).opaque;
     let o = !0;
     if (n.length === 1) {
-      const u = n[0].material;
-      (u.name === "EffectMaterial" || u.name === "CopyShader") && (o = !1);
+      const a = n[0].material;
+      (a.name === "EffectMaterial" || a.name === "CopyShader") && (o = !1);
     }
     if ((e.parent && e.parent.type === "CubeCamera" || s >= 1 && e.type === "OrthographicCamera") && (o = !1), o) {
       if (vt || (this.updateInterval === "auto" ? this.#s < 40 && this.#e < 10 ? (this.#e += 1, A && console.warn("↓ Reducing LOD updates", this.#e, this.#s.toFixed(0))) : this.#s >= 60 && this.#e > 1 && (this.#e -= 1, A && console.warn("↑ Increasing LOD updates", this.#e, this.#s.toFixed(0))) : this.#e = this.updateInterval, this.#e > 0 && this.#r % this.#e != 0))
@@ -1417,12 +1454,12 @@ class R {
     const s = this.renderer.renderLists.get(t, 0), r = s.opaque;
     this.projectionScreenMatrix.multiplyMatrices(e.projectionMatrix, e.matrixWorldInverse);
     const n = 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")) {
-        A && (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")) {
+        A && (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":
@@ -1431,32 +1468,32 @@ class R {
         case "MeshDepthMaterial":
           continue;
       }
-      const l = a.object;
-      (l instanceof K || l.isMesh) && this.updateLODs(t, e, l, n);
+      const u = l.object;
+      (u instanceof K || u.isMesh) && this.updateLODs(t, e, u, n);
     }
     const o = s.transparent;
-    for (const a of o) {
-      const l = a.object;
-      (l instanceof K || l.isMesh) && this.updateLODs(t, e, l, n);
+    for (const l of o) {
+      const u = l.object;
+      (u instanceof K || u.isMesh) && this.updateLODs(t, e, u, n);
     }
-    const u = s.transmissive;
-    for (const a of u) {
-      const l = a.object;
-      (l instanceof K || l.isMesh) && this.updateLODs(t, e, l, n);
+    const a = s.transmissive;
+    for (const l of a) {
+      const u = l.object;
+      (u instanceof K || u.isMesh) && this.updateLODs(t, e, u, n);
     }
   }
   /** Update the LOD levels for the renderer. */
   updateLODs(t, e, s, r) {
     s.userData || (s.userData = {});
-    let n = s[he];
-    if (n || (n = new St(), s[he] = n), n.frames++ < 2)
+    let n = s[ge];
+    if (n || (n = new Tt(), s[ge] = n), n.frames++ < 2)
       return;
-    for (const u of E)
-      u.onBeforeUpdateLOD?.(this.renderer, t, e, s);
+    for (const a of E)
+      a.onBeforeUpdateLOD?.(this.renderer, t, e, s);
     const o = this.overrideLodLevel !== void 0 ? this.overrideLodLevel : X;
-    o >= 0 ? (T.mesh_lod = o, T.texture_lod = o) : (this.calculateLodLevel(e, s, n, 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, o), f && s.material && !s.isGizmo && Be(s.material), Lt && s.material && !s.isGizmo && !s.isBatchedMesh && Ge(s.material, T.mesh_lod);
-    for (const u of E)
-      u.onAfterUpdatedLOD?.(this.renderer, t, e, s, T);
+    o >= 0 ? (T.mesh_lod = o, T.texture_lod = o) : (this.calculateLodLevel(e, s, n, 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, o), h && s.material && !s.isGizmo && Ge(s.material), Lt && s.material && !s.isGizmo && !s.isBatchedMesh && qe(s.material, T.mesh_lod);
+    for (const a of E)
+      a.onAfterUpdatedLOD?.(this.renderer, t, e, s, T);
     n.lastLodLevel_Mesh = T.mesh_lod, n.lastLodLevel_Texture = T.texture_lod;
   }
   /** Load progressive textures for the given material
@@ -1472,14 +1509,14 @@ class R {
       return;
     }
     let r = !1;
-    (t[q] === void 0 || e < t[q]) && (r = !0);
+    (t[F] === void 0 || e < t[F]) && (r = !0);
     const n = s !== void 0 && s >= 0;
-    if (n && (r = t[q] != s, e = s), r) {
-      t[q] = e;
-      const o = n ? { force: !0 } : void 0, u = h.assignTextureLOD(t, e, o).then((a) => {
-        this._lodchangedlisteners.forEach((l) => l({ type: "texture", level: e, object: t }));
+    if (n && (r = t[F] != s, e = s), r) {
+      t[F] = e;
+      const o = n ? { force: !0 } : void 0, a = p.assignTextureLOD(t, e, o).then((l) => {
+        this._lodchangedlisteners.forEach((u) => u({ type: "texture", level: e, object: t }));
       });
-      oe.addPromise("texture", t, u, this._newPromiseGroups);
+      oe.addPromise("texture", t, a, this._newPromiseGroups);
     }
   }
   /** Load progressive meshes for the given mesh
@@ -1490,18 +1527,18 @@ class R {
    */
   loadProgressiveMeshes(t, e) {
     if (!t) return Promise.resolve(null);
-    let s = t[q] !== e;
+    let s = t[F] !== e;
     const r = t["DEBUG:LOD"];
-    if (r != null && (s = t[q] != r, e = r), s) {
-      t[q] = e;
-      const n = t.geometry, o = h.assignMeshLOD(t, e).then((u) => (u && t[q] == e && n != t.geometry && this._lodchangedlisteners.forEach((a) => a({ type: "mesh", level: e, object: t })), u));
+    if (r != null && (s = t[F] != r, e = r), s) {
+      t[F] = e;
+      const n = t.geometry, o = p.assignMeshLOD(t, e).then((a) => (a && t[F] == e && n != t.geometry && this._lodchangedlisteners.forEach((l) => l({ type: "mesh", level: e, object: t })), a));
       return oe.addPromise("mesh", t, o, this._newPromiseGroups), o;
     }
     return Promise.resolve(null);
   }
   // private testIfLODLevelsAreAvailable() {
-  _sphere = new Se();
-  _tempWorldPosition = new k();
+  _sphere = new Ce();
+  _tempWorldPosition = new P();
   static skinnedMeshBoundsFrameOffsetCounter = 0;
   static $skinnedMeshBoundsOffset = /* @__PURE__ */ Symbol("gltf-progressive-skinnedMeshBoundsOffset");
   // #region calculateLodLevel
@@ -1514,86 +1551,86 @@ class R {
       n.mesh_lod = -1, n.texture_lod = -1;
       return;
     }
-    let u = 10 + 1, a = !1;
+    let a = 10 + 1, l = !1;
     if (A && e["DEBUG:LOD"] != null)
       return e["DEBUG:LOD"];
-    const l = h.getMeshLODExtension(e.geometry)?.lods, c = h.getPrimitiveIndex(e.geometry), d = l && l.length > 0, g = h.getMaterialMinMaxLODsCount(e.material), m = g.min_count !== 1 / 0 && g.min_count >= 0 && g.max_count >= 0;
-    if (!d && !m) {
+    const u = p.getMeshLODExtension(e.geometry)?.lods, d = p.getPrimitiveIndex(e.geometry), c = u && u.length > 0, f = p.getMaterialMinMaxLODsCount(e.material), g = f.min_count !== 1 / 0 && f.min_count >= 0 && f.max_count >= 0;
+    if (!c && !g) {
       n.mesh_lod = 0, n.texture_lod = 0;
       return;
     }
-    d || (a = !0, u = 0);
-    const x = this.renderer.domElement.clientHeight || this.renderer.domElement.height;
-    let v = e.geometry.boundingBox;
+    c || (l = !0, a = 0);
+    const O = this.renderer.domElement.clientHeight || this.renderer.domElement.height;
+    let y = e.geometry.boundingBox;
     if (e.type === "SkinnedMesh") {
-      const p = e;
-      if (!p.boundingBox)
-        p.computeBoundingBox();
+      const x = e;
+      if (!x.boundingBox)
+        x.computeBoundingBox();
       else if (this.skinnedMeshAutoUpdateBoundsInterval > 0) {
-        if (!p[R.$skinnedMeshBoundsOffset]) {
-          const C = R.skinnedMeshBoundsFrameOffsetCounter++;
-          p[R.$skinnedMeshBoundsOffset] = C;
+        if (!x[I.$skinnedMeshBoundsOffset]) {
+          const L = I.skinnedMeshBoundsFrameOffsetCounter++;
+          x[I.$skinnedMeshBoundsOffset] = L;
         }
-        const _ = p[R.$skinnedMeshBoundsOffset];
-        if ((s.frames + _) % this.skinnedMeshAutoUpdateBoundsInterval === 0) {
-          const C = ne(p), W = p.geometry;
-          C && (p.geometry = C), p.computeBoundingBox(), p.geometry = W;
+        const v = x[I.$skinnedMeshBoundsOffset];
+        if ((s.frames + v) % this.skinnedMeshAutoUpdateBoundsInterval === 0) {
+          const L = ne(x), V = x.geometry;
+          L && (x.geometry = L), x.computeBoundingBox(), x.geometry = V;
         }
       }
-      v = p.boundingBox;
+      y = x.boundingBox;
     }
-    if (v) {
+    if (y) {
       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 C = t.getWorldPosition(this._tempWorldPosition);
-        if (this._sphere.containsPoint(C)) {
+        const L = t.getWorldPosition(this._tempWorldPosition);
+        if (this._sphere.containsPoint(L)) {
           n.mesh_lod = 0, n.texture_lod = 0;
           return;
         }
       }
-      const p = Tt({
+      const x = bt({
         geometry: e.geometry,
         matrixWorld: e.matrixWorld,
         camera: t,
         projectionScreenMatrix: this.projectionScreenMatrix,
         desiredDensity: r,
-        canvasHeight: x,
+        canvasHeight: O,
         currentLevel: s.lastLodLevel_Mesh,
-        boundingBox: v,
+        boundingBox: y,
         xrEnabled: this.renderer.xr.enabled,
-        debugDrawLine: A ? R.debugDrawLine : void 0,
+        debugDrawLine: A ? I.debugDrawLine : void 0,
         warnMissingPrimitiveDensities: !0
       });
-      if (s.lastCentrality = p.centrality, s.lastScreenCoverage = p.screenCoverage, s.lastScreenspaceVolume.copy(p.screenspaceVolume), p.screenCoverage === 1 / 0) {
+      if (s.lastCentrality = x.centrality, s.lastScreenCoverage = x.screenCoverage, s.lastScreenspaceVolume.copy(x.screenspaceVolume), x.screenCoverage === 1 / 0) {
         n.mesh_lod = 0, n.texture_lod = 0;
         return;
       }
-      p.level >= 0 && p.level < u && (u = p.level, a = !0);
+      x.level >= 0 && x.level < a && (a = x.level, l = !0);
     }
-    if (a ? n.mesh_lod = u : n.mesh_lod = s.lastLodLevel_Mesh, A && n.mesh_lod != s.lastLodLevel_Mesh) {
-      const _ = l?.[n.mesh_lod];
-      _ && console.log(`Mesh LOD changed: ${s.lastLodLevel_Mesh} → ${n.mesh_lod} (density: ${_.densities?.[c].toFixed(0)}) | ${e.name}`);
+    if (l ? n.mesh_lod = a : n.mesh_lod = s.lastLodLevel_Mesh, A && n.mesh_lod != s.lastLodLevel_Mesh) {
+      const v = u?.[n.mesh_lod];
+      v && console.log(`Mesh LOD changed: ${s.lastLodLevel_Mesh} → ${n.mesh_lod} (density: ${v.densities?.[d].toFixed(0)}) | ${e.name}`);
     }
-    if (m) {
-      const p = "saveData" in globalThis.navigator && globalThis.navigator.saveData === !0;
+    if (g) {
+      const x = "saveData" in globalThis.navigator && globalThis.navigator.saveData === !0;
       if (s.lastLodLevel_Texture < 0) {
-        if (n.texture_lod = g.max_count - 1, A) {
-          const _ = g.lods[g.max_count - 1];
-          A && console.log(`First Texture LOD ${n.texture_lod} (${_.max_height}px) - ${e.name}`);
+        if (n.texture_lod = f.max_count - 1, A) {
+          const v = f.lods[f.max_count - 1];
+          A && console.log(`First Texture LOD ${n.texture_lod} (${v.max_height}px) - ${e.name}`);
         }
       } else {
-        const _ = s.lastScreenspaceVolume.x + s.lastScreenspaceVolume.y + s.lastScreenspaceVolume.z;
-        let C = s.lastScreenCoverage * 4;
-        this.context?.engine === "model-viewer" && (C *= 1.5);
-        const L = x / window.devicePixelRatio * C;
-        let w = !1;
-        for (let S = g.lods.length - 1; S >= 0; S--) {
-          const O = g.lods[S];
-          if (!(p && O.max_height >= 2048) && !(ve() && O.max_height > 4096) && (O.max_height > L || !w && S === 0)) {
-            if (w = !0, n.texture_lod = S, A && n.texture_lod < s.lastLodLevel_Texture) {
-              const D = O.max_height;
-              console.log(`Texture LOD changed: ${s.lastLodLevel_Texture} → ${n.texture_lod} = ${D}px 
-Screensize: ${L.toFixed(0)}px, Coverage: ${(100 * s.lastScreenCoverage).toFixed(2)}%, Volume ${_.toFixed(1)} 
+        const v = s.lastScreenspaceVolume.x + s.lastScreenspaceVolume.y + s.lastScreenspaceVolume.z;
+        let L = s.lastScreenCoverage * 4;
+        this.context?.engine === "model-viewer" && (L *= 1.5);
+        const w = O / window.devicePixelRatio * L;
+        let S = !1;
+        for (let _ = f.lods.length - 1; _ >= 0; _--) {
+          const R = f.lods[_];
+          if (!(x && R.max_height >= 2048) && !(_e() && R.max_height > 4096) && (R.max_height > w || !S && _ === 0)) {
+            if (S = !0, n.texture_lod = _, A && n.texture_lod < s.lastLodLevel_Texture) {
+              const C = R.max_height;
+              console.log(`Texture LOD changed: ${s.lastLodLevel_Texture} → ${n.texture_lod} = ${C}px 
+Screensize: ${w.toFixed(0)}px, Coverage: ${(100 * s.lastScreenCoverage).toFixed(2)}%, Volume ${v.toFixed(1)} 
 ${e.name}`);
             }
             break;
@@ -1604,74 +1641,74 @@ ${e.name}`);
       n.texture_lod = 0;
   }
 }
-class St {
+class Tt {
   frames = 0;
   lastLodLevel_Mesh = -1;
   lastLodLevel_Texture = -1;
   lastScreenCoverage = 0;
-  lastScreenspaceVolume = new k();
+  lastScreenspaceVolume = new P();
   lastCentrality = 0;
 }
-function Ge(i, t) {
+function qe(i, t) {
   if (!(t < 0)) {
     if (Array.isArray(i)) {
       for (const e of i)
-        Ge(e, t);
+        qe(e, t);
       return;
     }
-    "color" in i && i.color instanceof Ce && (i.color.copy(Ct(t, _t)), i.needsUpdate = !0);
+    "color" in i && i.color instanceof ke && (i.color.copy(Ct(t, _t)), i.needsUpdate = !0);
   }
 }
 function Ct(i, t) {
   const e = Math.max(0, Math.min(Me.length - 1, Math.floor(i)));
   return t.setHex(Me[e]);
 }
-const be = /* @__PURE__ */ Symbol("NEEDLE_mesh_lod"), ie = /* @__PURE__ */ Symbol("NEEDLE_texture_lod");
-let pe = null;
+const Se = /* @__PURE__ */ Symbol("NEEDLE_mesh_lod"), ae = /* @__PURE__ */ Symbol("NEEDLE_texture_lod");
+let me = null;
 function We() {
-  const i = Pt();
+  const i = kt();
   i && (i.mapURLs(function(t) {
-    return Oe(), t;
-  }), Oe(), pe?.disconnect(), pe = new MutationObserver((t) => {
+    return be(), t;
+  }), be(), me?.disconnect(), me = new MutationObserver((t) => {
     t.forEach((e) => {
       e.addedNodes.forEach((s) => {
         s instanceof HTMLElement && s.tagName.toLowerCase() === "model-viewer" && Ue(s);
       });
     });
-  }), pe.observe(document, { childList: !0, subtree: !0 }));
+  }), me.observe(document, { childList: !0, subtree: !0 }));
 }
-function Pt() {
+function kt() {
   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"), We();
   }), null);
 }
-function Oe() {
+function be() {
   if (typeof document > "u") return;
   document.querySelectorAll("model-viewer").forEach((t) => {
     Ue(t);
   });
 }
 const Te = /* @__PURE__ */ new WeakSet();
-let kt = 0;
+let Pt = 0;
 function Ue(i) {
   if (!i || Te.has(i))
     return null;
-  Te.add(i), console.debug("[gltf-progressive] found new model-viewer..." + ++kt + `
+  Te.add(i), console.debug("[gltf-progressive] found new model-viewer..." + ++Pt + `
 `, i.getAttribute("src"));
   let t = null, e = null, s = null;
   for (let r = i; r != null; r = Object.getPrototypeOf(r)) {
-    const n = Object.getOwnPropertySymbols(r), o = n.find((l) => l.toString() == "Symbol(renderer)"), u = n.find((l) => l.toString() == "Symbol(scene)"), a = n.find((l) => l.toString() == "Symbol(needsRender)");
-    !t && o != null && (t = i[o].threeRenderer), !e && u != null && (e = i[u]), !s && a != null && (s = i[a]);
+    const n = Object.getOwnPropertySymbols(r), o = n.find((u) => u.toString() == "Symbol(renderer)"), a = n.find((u) => u.toString() == "Symbol(scene)"), l = n.find((u) => u.toString() == "Symbol(needsRender)");
+    !t && o != null && (t = i[o].threeRenderer), !e && a != null && (e = i[a]), !s && l != null && (s = i[l]);
   }
   if (t && e) {
     let r = function() {
       if (s) {
         let o = 0;
-        const u = setInterval(() => {
+        const a = setInterval(() => {
           if (o++ > 5) {
-            clearInterval(u);
+            clearInterval(a);
             return;
           }
           s?.call(i);
@@ -1679,8 +1716,8 @@ function Ue(i) {
       }
     };
     console.debug("[gltf-progressive] setup model-viewer");
-    const n = R.get(t, { engine: "model-viewer" });
-    return R.addPlugin(new At()), n.enable(), n.addEventListener("changed", () => {
+    const n = I.get(t, { engine: "model-viewer" });
+    return I.addPlugin(new Rt()), n.enable(), n.addEventListener("changed", () => {
       s?.call(i);
     }), i.addEventListener("model-visibility", (o) => {
       o.detail.visible && s?.call(i);
@@ -1692,7 +1729,7 @@ function Ue(i) {
   }
   return null;
 }
-class At {
+class Rt {
   _didWarnAboutMissingUrl = !1;
   onBeforeUpdateLOD(t, e, s, r) {
     this.tryParseMeshLOD(e, r), this.tryParseTextureLOD(e, r);
@@ -1710,50 +1747,50 @@ class At {
     return t.element;
   }
   tryParseTextureLOD(t, e) {
-    if (e[ie] == !0) return;
-    e[ie] = !0;
+    if (e[ae] == !0) return;
+    e[ae] = !0;
     const s = this.tryGetCurrentGLTF(t), r = this.tryGetCurrentModelViewer(t), n = this.getUrl(r);
     if (n && s && e.material) {
-      let o = function(a) {
-        if (a[ie] == !0) return;
-        a[ie] = !0, a.userData && (a.userData.LOD = -1);
-        const l = Object.keys(a);
-        for (let c = 0; c < l.length; c++) {
-          const d = l[c], g = a[d];
-          if (g?.isTexture === !0) {
-            const m = g.userData?.associations?.textures;
-            if (m == null) continue;
-            const x = s.parser.json.textures[m];
-            if (!x) {
-              console.warn("Texture data not found for texture index " + m);
+      let o = function(l) {
+        if (l[ae] == !0) return;
+        l[ae] = !0, l.userData && (l.userData.LOD = -1);
+        const u = Object.keys(l);
+        for (let d = 0; d < u.length; d++) {
+          const c = u[d], f = l[c];
+          if (f?.isTexture === !0) {
+            const g = f.userData?.associations?.textures;
+            if (g == null) continue;
+            const O = s.parser.json.textures[g];
+            if (!O) {
+              console.warn("Texture data not found for texture index " + g);
               continue;
             }
-            if (x?.extensions?.[F]) {
-              const v = x.extensions[F];
-              v && n && h.registerTexture(n, g, v.lods.length, m, v);
+            if (O?.extensions?.[U]) {
+              const y = O.extensions[U];
+              y && n && p.registerTexture(n, f, y.lods.length, g, y);
             }
           }
         }
       };
-      const u = e.material;
-      if (Array.isArray(u)) for (const a of u) o(a);
-      else o(u);
+      const a = e.material;
+      if (Array.isArray(a)) for (const l of a) o(l);
+      else o(a);
     }
   }
   tryParseMeshLOD(t, e) {
-    if (e[be] == !0) return;
-    e[be] = !0;
+    if (e[Se] == !0) return;
+    e[Se] = !0;
     const s = this.tryGetCurrentModelViewer(t), r = this.getUrl(s);
     if (!r)
       return;
-    const n = e.userData?.gltfExtensions?.[F];
+    const n = e.userData?.gltfExtensions?.[U];
     if (n && r) {
       const o = e.uuid;
-      h.registerMesh(r, o, e, 0, n.lods.length, n);
+      p.registerMesh(r, o, e, 0, n.lods.length, n);
     }
   }
 }
-function Rt(...i) {
+function At(...i) {
   let t, e, s, r;
   switch (i.length) {
     case 2:
@@ -1768,20 +1805,20 @@ function Rt(...i) {
     default:
       throw new Error("Invalid arguments");
   }
-  Le(e), Ae(s), Ie(s, {
+  ve(e), Ae(s), $e(s, {
     progressive: !0,
     ...r?.hints
-  }), s.register((o) => new h(o));
-  const n = R.get(e);
+  }), s.register((o) => new p(o));
+  const n = I.get(e);
   return r?.enableLODsManager !== !1 && n.enable(), n;
 }
 We();
 if (!ct) {
   const i = {
     gltfProgressive: {
-      useNeedleProgressive: Rt,
-      LODsManager: R,
-      configureLoader: Ie,
+      useNeedleProgressive: At,
+      LODsManager: I,
+      configureLoader: $e,
       getRaycastMesh: ne,
       useRaycastMeshes: ft
     }
@@ -1793,14 +1830,14 @@ if (!ct) {
       globalThis.Needle[t] = i[t];
 }
 export {
-  F as EXTENSION_NAME,
-  R as LODsManager,
-  h as NEEDLE_progressive,
+  U as EXTENSION_NAME,
+  I as LODsManager,
+  p as NEEDLE_progressive,
   Je as VERSION,
   Ae as addDracoAndKTX2Loaders,
-  Tt as calculateMeshLODLevel,
-  Ie as configureLoader,
-  Le as createLoaders,
+  bt as calculateMeshLODLevel,
+  $e as configureLoader,
+  ve as createLoaders,
   Ct as getLODColor,
   ne as getRaycastMesh,
   Me as lodDebugColors,
@@ -1808,6 +1845,6 @@ export {
   dt as registerRaycastMesh,
   st as setDracoDecoderLocation,
   rt as setKTX2TranscoderLocation,
-  Rt as useNeedleProgressive,
+  At as useNeedleProgressive,
   ft as useRaycastMeshes
 };