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

package/gltf-progressive.js

@@ -1,69 +1,69 @@
-import { BufferGeometry as V, Mesh as X, Box3 as ge, Vector3 as P, Sphere as Oe, CompressedTexture as Ue, Texture as W, Matrix3 as ze, InterleavedBuffer as qe, InterleavedBufferAttribute as Ne, BufferAttribute as Ee, TextureLoader as Ve, Color as ke, Matrix4 as ve, Clock as Xe } from "three";
-import { GLTFLoader as xe } from "three/examples/jsm/loaders/GLTFLoader.js";
-import { MeshoptDecoder as Ke } from "three/examples/jsm/libs/meshopt_decoder.module.js";
-import { DRACOLoader as Ye } from "three/examples/jsm/loaders/DRACOLoader.js";
-import { KTX2Loader as je } from "three/examples/jsm/loaders/KTX2Loader.js";
-const He = "";
-globalThis.GLTF_PROGRESSIVE_VERSION = He;
+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 { 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/", K = "https://cdn.needle.tools/static/three/0.179.1/basis2/";
-const Qe = I, Je = K, Ce = new URL(I + "draco_decoder.js");
-Ce.searchParams.append("range", "true");
-fetch(Ce, {
+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, {
   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 === Qe && et("./include/draco/"), K === Je && tt("./include/ktx2/");
+  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/");
 }).finally(() => {
-  Ae();
+  Re();
 });
-const Ze = () => ({
+const tt = () => ({
   dracoDecoderPath: I,
-  ktx2TranscoderPath: K
+  ktx2TranscoderPath: Y
 });
-function et(i) {
-  I = i, k && k[pe] != I ? (console.debug("Updating Draco decoder path to " + i), k[pe] = I, k.setDecoderPath(I), k.preload()) : console.debug("Setting Draco decoder path to " + i);
+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);
 }
-function tt(i) {
-  K = i, $ && $.transcoderPath != K ? (console.debug("Updating KTX2 transcoder path to " + i), $.setTranscoderPath(K), $.init()) : console.debug("Setting KTX2 transcoder 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);
 }
-function we(i) {
-  return Ae(), i ? $.detectSupport(i) : i !== null && console.warn("No renderer provided to detect ktx2 support - loading KTX2 textures might fail"), { dracoLoader: k, ktx2Loader: $, meshoptDecoder: oe };
+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 Pe(i) {
-  i.dracoLoader || i.setDRACOLoader(k), i.ktx2Loader || i.setKTX2Loader($), i.meshoptDecoder || i.setMeshoptDecoder(oe);
+function Ae(i) {
+  i.dracoLoader || i.setDRACOLoader(P), i.ktx2Loader || i.setKTX2Loader($), i.meshoptDecoder || i.setMeshoptDecoder(ae);
 }
-const pe = /* @__PURE__ */ Symbol("dracoDecoderPath");
-let k, oe, $;
-function Ae() {
-  k || (k = new Ye(), k[pe] = I, k.setDecoderPath(I), k.setDecoderConfig({ type: "js" }), k.preload()), $ || ($ = new je(), $.setTranscoderPath(K), $.init()), oe || (oe = Ke);
+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 me = /* @__PURE__ */ new WeakMap();
-function Re(i, t) {
-  let e = me.get(i);
-  e ? e = Object.assign(e, t) : e = t, me.set(i, e);
+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 st = xe.prototype.load;
-function rt(...i) {
-  const t = me.get(this);
+const nt = we.prototype.load;
+function ot(...i) {
+  const t = ye.get(this);
   let e = i[0];
   const s = new URL(e, window.location.href);
   if (s.hostname.endsWith("needle.tools")) {
     const n = t?.progressive !== void 0 ? t.progressive : !0, o = t?.usecase ? t.usecase : "default";
     n ? this.requestHeader.Accept = `*/*;progressive=allowed;usecase=${o}` : this.requestHeader.Accept = `*/*;usecase=${o}`, e = s.toString();
   }
-  return i[0] = e, st?.call(this, ...i);
+  return i[0] = e, nt?.call(this, ...i);
 }
-xe.prototype.load = rt;
+we.prototype.load = ot;
 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 nt(i, t) {
+function it(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,16 +74,16 @@ function nt(i, t) {
   }
   return t;
 }
-function Le() {
-  return j !== void 0 || (j = /iPhone|iPad|iPod|Android|IEMobile/i.test(navigator.userAgent), N("debugprogressive") && console.log("[glTF Progressive]: isMobileDevice", j)), j;
+function ve() {
+  return Z !== void 0 || (Z = /iPhone|iPad|iPod|Android|IEMobile/i.test(navigator.userAgent), N("debugprogressive") && console.log("[glTF Progressive]: isMobileDevice", Z)), Z;
 }
-let j;
-function Me() {
+let Z;
+function $e() {
   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;
 }
-class ot {
+class at {
   constructor(t, e = {}) {
     this.maxConcurrent = t, this.debug = e.debug ?? !1, typeof window < "u" && window.requestAnimationFrame(this.tick);
   }
@@ -117,11 +117,11 @@ class ot {
     }
   }
 }
-function it(i) {
-  const t = i.image?.width ?? 0, e = i.image?.height ?? 0, s = i.image?.depth ?? 1, r = Math.floor(Math.log2(Math.max(t, e, s))) + 1, n = at(i);
+function lt(i) {
+  const t = i.image?.width ?? 0, e = i.image?.height ?? 0, s = i.image?.depth ?? 1, r = Math.floor(Math.log2(Math.max(t, e, s))) + 1, n = ut(i);
   return t * e * s * n * (1 - Math.pow(0.25, r)) / (1 - 0.25);
 }
-function at(i) {
+function ut(i) {
   let t = 4;
   const e = i.format;
   e === 1024 || e === 1025 ? t = 1 : e === 1026 || e === 1027 ? t = 2 : e === 1022 || e === 1029 ? t = 3 : (e === 1023 || e === 1033) && (t = 4);
@@ -129,69 +129,69 @@ function at(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 lt = typeof window > "u" && typeof document > "u", ye = /* @__PURE__ */ Symbol("needle:raycast-mesh");
-function ee(i) {
-  return i?.[ye] instanceof V ? i[ye] : null;
+const ct = typeof window > "u" && typeof document > "u", xe = /* @__PURE__ */ Symbol("needle:raycast-mesh");
+function ne(i) {
+  return i?.[xe] instanceof j ? i[xe] : null;
 }
-function ut(i, t) {
-  if ((i.type === "Mesh" || i.type === "SkinnedMesh") && !ee(i)) {
-    const s = dt(t);
-    s.userData = { isRaycastMesh: !0 }, i[ye] = s;
+function dt(i, t) {
+  if ((i.type === "Mesh" || i.type === "SkinnedMesh") && !ne(i)) {
+    const s = ht(t);
+    s.userData = { isRaycastMesh: !0 }, i[xe] = s;
   }
 }
-function ct(i = !0) {
+function ft(i = !0) {
   if (i) {
-    if (H) return;
-    const t = H = X.prototype.raycast;
-    X.prototype.raycast = function(e, s) {
-      const r = this, n = ee(r);
+    if (ee) return;
+    const t = ee = K.prototype.raycast;
+    K.prototype.raycast = function(e, s) {
+      const r = this, n = ne(r);
       let o;
       n && r.isMesh && (o = r.geometry, r.geometry = n), t.call(this, e, s), o && (r.geometry = o);
     };
   } else {
-    if (!H) return;
-    X.prototype.raycast = H, H = null;
+    if (!ee) return;
+    K.prototype.raycast = ee, ee = null;
   }
 }
-let H = null;
-function dt(i) {
-  const t = new V();
+let ee = null;
+function ht(i) {
+  const t = new j();
   for (const e in i.attributes)
     t.setAttribute(e, i.getAttribute(e));
   return t.setIndex(i.getIndex()), t;
 }
-const q = new Array(), h = N("debugprogressive");
-let Z, E = -1;
-if (h) {
+const E = new Array(), f = N("debugprogressive");
+let re, X = -1;
+if (f) {
   let i = function() {
-    E += 1, E >= t && (E = -1), console.log(`Toggle LOD level [${E}]`);
+    X += 1, X >= t && (X = -1), console.log(`Toggle LOD level [${X}]`);
   };
   const t = 6;
   window.addEventListener("keyup", (e) => {
-    e.key === "p" && i(), e.key === "w" && (Z = !Z, console.log(`Toggle wireframe [${Z}]`));
+    e.key === "p" && i(), e.key === "w" && (re = !re, console.log(`Toggle wireframe [${re}]`));
     const s = parseInt(e.key);
-    !isNaN(s) && s >= 0 && (E = s, console.log(`Set LOD level to [${E}]`));
+    !isNaN(s) && s >= 0 && (X = s, console.log(`Set LOD level to [${X}]`));
   });
 }
-function Ie(i) {
-  if (h && Z !== void 0)
+function Be(i) {
+  if (f && re !== void 0)
     if (Array.isArray(i))
       for (const t of i)
-        Ie(t);
-    else i && "wireframe" in i && (i.wireframe = Z === !0);
+        Be(t);
+    else i && "wireframe" in i && (i.wireframe = re === !0);
 }
-const Q = new Array();
-let ft = 0;
-const ht = Le() ? 2 : 10;
-function gt(i) {
-  if (Q.length < ht) {
-    const s = Q.length;
-    h && console.warn(`[Worker] Creating new worker #${s}`);
+const te = new Array();
+let gt = 0;
+const pt = ve() ? 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 || {});
-    return Q.push(r), r;
+    return te.push(r), r;
   }
-  const t = ft++ % Q.length;
-  return Q[t];
+  const t = gt++ % te.length;
+  return te[t];
 }
 class _e {
   constructor(t, e) {
@@ -201,7 +201,7 @@ class _e {
         case "loaded-gltf":
           for (const n of this._running)
             if (n.url === r.result.url) {
-              pt(r.result), n.resolve(r.result);
+              yt(r.result), n.resolve(r.result);
               const o = n.url;
               o.startsWith("blob:") && URL.revokeObjectURL(o);
             }
@@ -225,13 +225,13 @@ class _e {
   _running = [];
   _webglRenderer = null;
   async load(t, e) {
-    const s = Ze();
+    const s = tt();
     let r = e?.renderer;
     r || (this._webglRenderer ??= (async () => {
       const { WebGLRenderer: l } = await import("three");
       return new l();
     })(), r = await this._webglRenderer);
-    const u = we(r).ktx2Loader.workerConfig;
+    const u = 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 = {
       type: "load",
@@ -249,32 +249,32 @@ class _e {
   }
   _debug = !1;
 }
-function pt(i) {
+function yt(i) {
   for (const t of i.geometries) {
-    const e = t.geometry, s = new V();
+    const e = t.geometry, s = new j();
     if (s.name = e.name || "", e.index) {
       const r = e.index;
-      s.setIndex(le(r));
+      s.setIndex(ce(r));
     }
     for (const r in e.attributes) {
-      const n = e.attributes[r], o = le(n);
+      const n = e.attributes[r], o = ce(n);
       s.setAttribute(r, o);
     }
     if (e.morphAttributes)
       for (const r in e.morphAttributes) {
-        const o = e.morphAttributes[r].map((u) => le(u));
+        const o = e.morphAttributes[r].map((u) => ce(u));
         s.morphAttributes[r] = o;
       }
-    if (s.morphTargetsRelative = e.morphTargetsRelative ?? !1, s.boundingBox = new ge(), s.boundingBox.min = new P(
+    if (s.morphTargetsRelative = e.morphTargetsRelative ?? !1, s.boundingBox = new le(), s.boundingBox.min = new k(
       e.boundingBox?.min.x,
       e.boundingBox?.min.y,
       e.boundingBox?.min.z
-    ), s.boundingBox.max = new P(
+    ), s.boundingBox.max = new k(
       e.boundingBox?.max.x,
       e.boundingBox?.max.y,
       e.boundingBox?.max.z
-    ), s.boundingSphere = new Oe(
-      new P(
+    ), s.boundingSphere = new Se(
+      new k(
         e.boundingSphere?.center.x,
         e.boundingSphere?.center.y,
         e.boundingSphere?.center.z
@@ -290,7 +290,7 @@ function pt(i) {
     let s = null;
     if (e.isCompressedTexture) {
       const r = e.mipmaps, n = e.image?.width || e.source?.data?.width || -1, o = e.image?.height || e.source?.data?.height || -1;
-      s = new Ue(
+      s = new ze(
         r,
         n,
         o,
@@ -305,7 +305,7 @@ function pt(i) {
         e.colorSpace
       );
     } else
-      s = new W(
+      s = new G(
         e.image,
         e.mapping,
         e.wrapS,
@@ -316,7 +316,7 @@ function pt(i) {
         e.type,
         e.anisotropy,
         e.colorSpace
-      ), s.mipmaps = e.mipmaps, s.channel = e.channel, s.source.data = e.source.data, s.flipY = e.flipY, s.premultiplyAlpha = e.premultiplyAlpha, s.unpackAlignment = e.unpackAlignment, s.matrix = new ze(...e.matrix.elements);
+      ), s.mipmaps = e.mipmaps, s.channel = e.channel, s.source.data = e.source.data, s.flipY = e.flipY, s.premultiplyAlpha = e.premultiplyAlpha, s.unpackAlignment = e.unpackAlignment, s.matrix = new Ee(...e.matrix.elements);
     if (!s) {
       console.error("[Worker] Failed to create new texture from received data. Texture is not a CompressedTexture or Texture.");
       continue;
@@ -325,21 +325,21 @@ function pt(i) {
   }
   return i;
 }
-function le(i) {
+function ce(i) {
   let t = i;
   if ("isInterleavedBufferAttribute" in i && i.isInterleavedBufferAttribute) {
-    const e = i.data, s = e.array, r = new qe(s, e.stride);
-    t = new Ne(r, i.itemSize, s.byteOffset, i.normalized), t.offset = i.offset;
-  } else "isBufferAttribute" in i && i.isBufferAttribute && (t = new Ee(i.array, i.itemSize, i.normalized), t.usage = i.usage, t.gpuType = i.gpuType, t.updateRanges = i.updateRanges);
+    const e = i.data, s = e.array, r = new Ne(s, e.stride);
+    t = new Ve(r, i.itemSize, s.byteOffset, i.normalized), t.offset = i.offset;
+  } else "isBufferAttribute" in i && i.isBufferAttribute && (t = new Xe(i.array, i.itemSize, i.normalized), t.usage = i.usage, t.gpuType = i.gpuType, t.updateRanges = i.updateRanges);
   return t;
 }
-const mt = N("gltf-progressive-worker");
+const xt = N("gltf-progressive-worker");
 N("gltf-progressive-reduce-mipmaps");
-const J = N("gltf-progressive-gc"), ue = /* @__PURE__ */ Symbol("needle-progressive-texture"), U = "NEEDLE_progressive";
-class p {
+const se = N("gltf-progressive-gc"), de = /* @__PURE__ */ Symbol("needle-progressive-texture"), F = "NEEDLE_progressive";
+class h {
   /** The name of the extension */
   get name() {
-    return U;
+    return F;
   }
   // #region PUBLIC API
   /**
@@ -385,7 +385,7 @@ class p {
         this.getMaterialMinMaxLODsCount(u, e);
       return t[r] = e, e;
     }
-    if (h === "verbose" && console.log("getMaterialMinMaxLODsCount", t), t.type === "ShaderMaterial" || t.type === "RawShaderMaterial") {
+    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;
@@ -397,7 +397,7 @@ class p {
         a?.isTexture === !0 && o(a, e);
       }
     else
-      h && console.warn(`[getMaterialMinMaxLODsCount] Unsupported material type: ${t.type}`);
+      f && console.warn(`[getMaterialMinMaxLODsCount] Unsupported material type: ${t.type}`);
     return t[r] = e, e;
     function o(u, a) {
       const l = s.getAssignedLODInformation(u);
@@ -405,9 +405,9 @@ class p {
         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 f = 0; f < c.lods.length; f++) {
-            const y = c.lods[f];
-            y.width && (a.lods[f] = a.lods[f] || { min_height: 1 / 0, max_height: 0 }, a.lods[f].min_height = Math.min(a.lods[f].min_height, y.height), a.lods[f].max_height = Math.max(a.lods[f].max_height, y.height));
+          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));
           }
         }
       }
@@ -459,22 +459,22 @@ class p {
    * });
    * ```
    */
-  static assignMeshLOD(t, e) {
+  static assignMeshLOD(t, e, s) {
     if (!t) return Promise.resolve(null);
-    if (t instanceof X || t.isMesh === !0) {
-      const s = t.geometry, r = this.getAssignedLODInformation(s);
-      if (!r)
+    if (t instanceof K || t.isMesh === !0) {
+      const r = t.geometry, n = this.getAssignedLODInformation(r);
+      if (!n)
         return Promise.resolve(null);
-      for (const n of q)
-        n.onBeforeGetLODMesh?.(t, e);
-      return t["LOD:requested level"] = e, p.getOrLoadLOD(s, e).then((n) => {
-        if (Array.isArray(n)) {
-          const o = r.index || 0;
-          n = n[o];
+      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)) {
+          const u = n.index || 0;
+          o = o[u];
         }
-        return t["LOD:requested level"] === e && (delete t["LOD:requested level"], n && s != n && (n?.isBufferGeometry ? t.geometry = n : h && console.error("Invalid LOD geometry", n))), n;
-      }).catch((n) => (console.error("Error loading mesh LOD", t, n), null));
-    } else h && console.error("Invalid call to assignMeshLOD: Request mesh LOD but the object is not a mesh", t);
+        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);
     return Promise.resolve(null);
   }
   static assignTextureLOD(t, e = 0, s) {
@@ -504,8 +504,8 @@ class p {
         for (const l of Object.keys(a.uniforms)) {
           const c = a.uniforms[l].value;
           if (c?.isTexture === !0) {
-            const f = this.assignTextureLODForSlot(c, e, n, l, r).then((y) => (y && a.uniforms[l].value != y && (a.uniforms[l].value = y, a.uniformsNeedUpdate = !0), y));
-            o.push(f), u.push(l);
+            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);
           }
         }
       } else
@@ -519,13 +519,13 @@ class p {
       return Promise.all(o).then((a) => {
         const l = new Array();
         for (let c = 0; c < a.length; c++) {
-          const f = a[c], y = u[c];
-          f && f.isTexture === !0 ? l.push({ material: n, slot: y, texture: f, level: e }) : l.push({ material: n, slot: y, texture: null, level: e });
+          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 l;
       });
     }
-    if (t instanceof W || t.isTexture === !0) {
+    if (t instanceof G || t.isTexture === !0) {
       const n = t;
       return this.assignTextureLODForSlot(n, e, null, null, r);
     }
@@ -536,10 +536,10 @@ class p {
    * @default 50 on desktop, 20 on mobile devices
    */
   static set maxConcurrentLoadingTasks(t) {
-    p.queue.maxConcurrent = t;
+    h.queue.maxConcurrent = t;
   }
   static get maxConcurrentLoadingTasks() {
-    return p.queue.maxConcurrent;
+    return h.queue.maxConcurrent;
   }
   // #region INTERNAL
   static assignTextureLODForSlot(t, e, s, r, n) {
@@ -555,7 +555,7 @@ class p {
       if (a && a.level === e && a.force === n)
         return a.promise;
     }
-    const u = p.getOrLoadLOD(t, e).then((a) => {
+    const u = h.getOrLoadLOD(t, e).then((a) => {
       if (Array.isArray(a))
         return console.warn("Progressive: Got an array of textures for a texture slot, this should not happen..."), null;
       if (a?.isTexture === !0) {
@@ -564,12 +564,12 @@ class p {
           if (l && !n) {
             const c = this.getAssignedLODInformation(l);
             if (c && c?.level < e)
-              return h === "verbose" && console.warn("Assigned texture level is already higher: ", c.level, e, s, l, a), null;
+              return f === "verbose" && console.warn("Assigned texture level is already higher: ", c.level, e, s, l, a), null;
           }
           this.assignTrackedTextureSlot(s, r, a);
         }
         return a;
-      } else h == "verbose" && console.warn("No LOD found for", t, e);
+      } else f == "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;
@@ -633,7 +633,7 @@ class p {
   }
   static releaseTrackedTextureSlot(t, e, s) {
     const r = this.trackedTextureSlots.get(t);
-    if (r?.get(e) === s && r.delete(e), this.untrackTextureUsage(s) && (h || J)) {
+    if (r?.get(e) === s && r.delete(e), this.untrackTextureUsage(s) && (f || 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 +642,13 @@ class p {
   url;
   constructor(t) {
     const e = t.options.path;
-    h && console.log("Progressive extension registered for", e), this.parser = t, this.url = e;
+    f && 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?.[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;
+    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;
   };
   // private _isLoadingTexture;
   // loadTexture = (textureIndex: number) => {
@@ -665,30 +665,30 @@ class p {
   //     });
   // }
   afterRoot(t) {
-    return h && console.log("AFTER", this.url, t), this.parser.json.textures?.forEach((e, s) => {
+    return f && console.log("AFTER", this.url, t), this.parser.json.textures?.forEach((e, s) => {
       if (e?.extensions) {
-        const r = e?.extensions[U];
+        const r = e?.extensions[F];
         if (r) {
           if (!r.lods) {
-            h && console.warn("Texture has no LODs", r);
+            f && 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, p.registerTexture(this.url, o, r.lods?.length, s, r));
+            o.isTexture === !0 && this.parser.associations.get(o)?.textures === s && (n = !0, h.registerTexture(this.url, o, r.lods?.length, s, r));
           n || this.parser.getDependency("texture", s).then((o) => {
-            o && p.registerTexture(this.url, o, r.lods?.length, s, r);
+            o && h.registerTexture(this.url, o, r.lods?.length, s, r);
           });
         }
       }
     }), this.parser.json.meshes?.forEach((e, s) => {
       if (e?.extensions) {
-        const r = e?.extensions[U];
+        const r = e?.extensions[F];
         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 && p.registerMesh(this.url, r.guid, n, r.lods.length, o.primitives, r);
+              o?.meshes === s && h.registerMesh(this.url, r.guid, n, r.lods.length, o.primitives, r);
             }
         }
       }
@@ -707,16 +707,16 @@ class p {
    */
   static registerTexture = (t, e, s, r, n) => {
     if (!e) {
-      h && console.error("!! gltf-progressive: Called register texture without texture");
+      f && console.error("!! gltf-progressive: Called register texture without texture");
       return;
     }
-    if (h) {
+    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);
     }
-    e.source && (e.source[ue] = n);
+    e.source && (e.source[de] = n);
     const o = n.guid;
-    p.assignLODInformation(t, e, o, s, r), p.lodInfos.set(o, n), p.lowresCache.set(o, new WeakRef(e));
+    h.assignLODInformation(t, e, o, s, r), h.lodInfos.set(o, n), h.lowresCache.set(o, new WeakRef(e));
   };
   /**
    * Register a mesh with progressive LOD information. This associates the mesh geometry with its LOD extension data
@@ -734,13 +734,13 @@ class p {
   static registerMesh = (t, e, s, r, n, o) => {
     const u = s.geometry;
     if (!u) {
-      h && console.warn("gltf-progressive: Register mesh without geometry");
+      f && console.warn("gltf-progressive: Register mesh without geometry");
       return;
     }
-    u.userData || (u.userData = {}), h && console.log("> Progressive: register mesh " + s.name, { index: n, uuid: s.uuid }, o, s), p.assignLODInformation(t, u, e, r, n), p.lodInfos.set(e, o);
-    let l = p.lowresCache.get(e)?.deref();
-    l ? l.push(s.geometry) : l = [s.geometry], p.lowresCache.set(e, new WeakRef(l)), r > 0 && !ee(s) && ut(s, u);
-    for (const c of q)
+    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);
   };
   /**
@@ -814,16 +814,16 @@ class p {
    * The held value is the cache key string used in `previouslyLoaded`.
    */
   static _resourceRegistry = new FinalizationRegistry((t) => {
-    const e = p.cache.get(t);
-    (h || J) && console.debug(`[gltf-progressive] Memory: Resource GC'd
-${t}`), e instanceof WeakRef && (e.deref() || (p.cache.delete(t), (h || J) && console.log("[gltf-progressive] ↪ Cache entry deleted (GC)")));
+    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)")));
   });
   /**
    * Track texture usage by incrementing reference count
    */
   static trackTextureUsage(t) {
     const e = t.uuid, s = this.textureRefCounts.get(e) || 0;
-    this.textureRefCounts.set(e, s + 1), h === "verbose" && console.log(`[gltf-progressive] Track texture ${e}, refCount: ${s} → ${s + 1}`);
+    this.textureRefCounts.set(e, s + 1), f === "verbose" && console.log(`[gltf-progressive] Track texture ${e}, refCount: ${s} → ${s + 1}`);
   }
   /**
    * Untrack texture usage by decrementing reference count.
@@ -833,147 +833,147 @@ ${t}`), e instanceof WeakRef && (e.deref() || (p.cache.delete(t), (h || J) && co
   static untrackTextureUsage(t) {
     const e = t.uuid, s = this.textureRefCounts.get(e);
     if (!s)
-      return (h === "verbose" || J) && n("[gltf-progressive] Memory: Untrack untracked texture (dispose immediately)", 0), t.dispose(), !0;
+      return (f === "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), (h || J) && 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;
+      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 f = "N/A";
-      a && l && (f = `~${(it(t) / (1024 * 1024)).toFixed(2)} MB`), console.log(`${o} — ${t.name} ${c} (${f}), refCount: ${s} → ${u}
+      let d = "N/A";
+      a && l && (d = `~${(lt(t) / (1024 * 1024)).toFixed(2)} MB`), console.log(`${o} — ${t.name} ${c} (${d}), refCount: ${s} → ${u}
 ${e}`);
     }
   }
   static workers = [];
   static _workersIndex = 0;
   static async getOrLoadLOD(t, e) {
-    const s = h == "verbose", r = this.getAssignedLODInformation(t);
+    const s = f == "verbose", r = this.getAssignedLODInformation(t);
     if (!r)
-      return h && console.warn(`[gltf-progressive] No LOD information found: ${t.name}, uuid: ${t.uuid}, type: ${t.type}`, t), null;
+      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;
     if (t.isTexture === !0) {
       const a = t;
-      a.source && a.source[ue] && (o = a.source[ue]);
+      a.source && a.source[de] && (o = a.source[de]);
     }
-    if (o || (o = p.lodInfos.get(n)), !o)
-      h && console.warn(`Can not load LOD ${e}: no LOD info found for "${n}" ${t.name}`, t.type, p.lodInfos);
+    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);
     else {
       if (e > 0) {
         let c = !1;
-        const f = Array.isArray(o.lods);
-        if (f && e >= o.lods.length ? c = !0 : f || (c = !0), c) {
-          const y = this.lowresCache.get(n);
-          if (y) {
-            const T = y.deref();
-            if (T) return T;
-            this.lowresCache.delete(n), h && console.log(`[gltf-progressive] Lowres cache entry was GC'd: ${n}`);
+        const d = Array.isArray(o.lods);
+        if (d && e >= o.lods.length ? c = !0 : d || (c = !0), c) {
+          const g = this.lowresCache.get(n);
+          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}`);
           }
           return null;
         }
       }
       const a = Array.isArray(o.lods) ? o.lods[e]?.path : o.lods;
       if (!a)
-        return h && !o["missing:uri"] && (o["missing:uri"] = !0, console.warn("Missing uri for progressive asset for LOD " + e, o)), null;
-      const l = nt(r.url, 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, f = await this.tryResolveLODCacheEntry(this.cache.get(c), c, l, t, e, s);
-        if (f.found) return f.value;
-        const y = await this.queue.slot(l), T = await this.tryResolveLODCacheEntry(this.cache.get(c), c, l, t, e, s);
-        if (T.found) return T.value;
-        if (!y.use)
-          return h && console.log(`LOD ${e} was aborted: ${l}`), null;
-        const _ = o, C = new Promise(async (m, B) => {
-          if (mt) {
-            const d = await (await gt({})).load(l);
-            if (d.textures.length > 0)
-              for (const g of d.textures) {
-                let w = g.texture;
-                return p.assignLODInformation(r.url, w, n, e, void 0), t instanceof W && (w = this.copySettings(t, w)), w && (w.guid = _.guid), m(w);
+        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;
+        if (!g.use)
+          return f && console.log(`LOD ${e} was aborted: ${l}`), null;
+        const x = o, v = new Promise(async (_, C) => {
+          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);
               }
-            if (d.geometries.length > 0) {
-              const g = new Array();
-              for (const w of d.geometries) {
-                const v = w.geometry;
-                p.assignLODInformation(r.url, v, n, e, w.primitiveIndex), g.push(v);
+            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);
               }
-              return m(g);
+              return _(M);
             }
-            return m(null);
+            return _(null);
           }
-          const G = new xe();
-          Pe(G), h && (await new Promise((b) => setTimeout(b, 1e3)), s && console.warn("Start loading (delayed) " + l, _.guid));
-          let A = l;
-          if (_ && Array.isArray(_.lods)) {
-            const b = _.lods[e];
-            b.hash && (A += "?v=" + b.hash);
+          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 S = await G.loadAsync(A).catch((b) => (console.error(`Error loading LOD ${e} from ${l}
-`, b), m(null)));
-          if (!S)
-            return m(null);
-          const F = S.parser;
-          s && console.log("Loading finished " + l, _.guid);
-          let M = 0;
-          if (S.parser.json.textures) {
-            let b = !1;
-            for (const d of S.parser.json.textures) {
-              if (d?.extensions) {
-                const g = d?.extensions[U];
-                if (g?.guid && g.guid === _.guid) {
-                  b = !0;
+          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;
                   break;
                 }
               }
-              M++;
+              O++;
             }
-            if (b) {
-              let d = await F.getDependency("texture", M);
-              return d && p.assignLODInformation(r.url, d, n, e, void 0), s && console.log('change "' + t.name + '" → "' + d.name + '"', l, M, d, c), t instanceof W && (d = this.copySettings(t, d)), d && (d.guid = _.guid), m(d);
-            } else h && console.warn("Could not find texture with guid", _.guid, S.parser.json);
+            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 (M = 0, S.parser.json.meshes) {
-            let b = !1;
-            for (const d of S.parser.json.meshes) {
-              if (d?.extensions) {
-                const g = d?.extensions[U];
-                if (g?.guid && g.guid === _.guid) {
-                  b = !0;
+          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;
                   break;
                 }
               }
-              M++;
+              O++;
             }
-            if (b) {
-              const d = await F.getDependency("mesh", M);
-              if (s && console.log(`Loaded Mesh "${d.name}"`, l, M, d, c), d.isMesh === !0) {
-                const g = d.geometry;
-                return p.assignLODInformation(r.url, g, n, e, 0), m(g);
+            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);
               } else {
-                const g = new Array();
-                for (let w = 0; w < d.children.length; w++) {
-                  const v = d.children[w];
-                  if (v.isMesh === !0) {
-                    const O = v.geometry;
-                    p.assignLODInformation(r.url, O, n, e, w), g.push(O);
+                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);
                   }
                 }
-                return m(g);
+                return _(M);
               }
-            } else h && console.warn("Could not find mesh with guid", _.guid, S.parser.json);
+            } else f && console.warn("Could not find mesh with guid", x.guid, w.parser.json);
           }
-          return m(null);
+          return _(null);
         });
-        this.cache.set(c, C), y.use(C);
-        const x = await C;
-        return x != null ? x instanceof W ? (this.cache.set(c, new WeakRef(x)), p._resourceRegistry.register(x, c)) : Array.isArray(x) ? this.cache.set(c, Promise.resolve(x)) : this.cache.set(c, Promise.resolve(x)) : this.cache.set(c, Promise.resolve(null)), x;
-      } else if (t instanceof W) {
+        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 f = await new Ve().loadAsync(l);
-        return f ? (f.guid = o.guid, f.flipY = !1, f.needsUpdate = !0, f.colorSpace = t.colorSpace, s && console.log(o, f)) : h && console.warn("failed loading", l), f;
+        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;
       }
     }
     return null;
@@ -984,24 +984,24 @@ ${e}`);
     if (o && console.log(`LOD ${n} was already loading/loaded: ${e}`), t instanceof WeakRef) {
       const l = t.deref();
       if (l) {
-        let c = l, f = !1;
-        if (c instanceof W && r instanceof W ? c.image?.data || c.source?.data ? c = this.copySettings(r, c) : f = !0 : c instanceof V && r instanceof V && (c.attributes.position?.array || (f = !0)), !f)
+        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 };
       }
-      return this.cache.delete(e), h && console.log(`[gltf-progressive] Re-loading GC'd/disposed resource: ${e}`), { found: !1 };
+      return this.cache.delete(e), f && 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 W && r instanceof W ? u.image?.data || u.source?.data ? u = this.copySettings(r, u) : (a = !0, this.cache.delete(e)) : u instanceof V && r instanceof V && (u.attributes.position?.array || (a = !0, this.cache.delete(e)))), a ? { found: !1 } : { found: !0, value: u };
+    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 };
   }
   static _queue;
   static get queue() {
-    return this._queue ??= new ot(Le() ? 20 : 50, { debug: h != !1 });
+    return this._queue ??= new at(ve() ? 20 : 50, { debug: f != !1 });
   }
   static assignLODInformation(t, e, s, r, n) {
     if (!e) return;
     e.userData || (e.userData = {});
-    const o = new yt(t, s, r, n);
+    const o = new wt(t, s, r, n);
     e.userData.LODS = o, "source" in e && typeof e.source == "object" && (e.source.LODS = o);
   }
   static getAssignedLODInformation(t) {
@@ -1009,12 +1009,12 @@ ${e}`);
   }
   // private static readonly _copiedTextures: WeakMap<Texture, Texture> = new Map();
   static copySettings(t, e) {
-    return e ? (h === "verbose" && console.debug(`Copy texture settings
+    return e ? (f === "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;
   }
 }
-class yt {
+class wt {
   url;
   /** the key to lookup the LOD information */
   key;
@@ -1025,7 +1025,7 @@ class yt {
     this.url = t, this.key = e, this.level = s, r != null && (this.index = r);
   }
 }
-class ce {
+class oe {
   static addPromise = (t, e, s, r) => {
     r.forEach((n) => {
       n.add(t, e, s);
@@ -1074,7 +1074,7 @@ class ce {
   _seen = /* @__PURE__ */ new WeakMap();
   add(t, e, s) {
     if (this._resolved) {
-      h && console.warn("PromiseGroup: Trying to add a promise to a resolved group, ignoring.");
+      f && 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 +1082,7 @@ class ce {
         if (this._seen.has(e)) {
           const r = this._seen.get(e);
           if (r >= this._maxPromisesPerObject) {
-            h && console.warn("PromiseGroup: Already awaiting object ignoring new promise for it.");
+            f && console.warn("PromiseGroup: Already awaiting object ignoring new promise for it.");
             return;
           }
           this._seen.set(e, r + 1);
@@ -1101,7 +1101,7 @@ class ce {
     });
   }
 }
-const R = N("debugprogressive"), xt = R === "colors", wt = N("noprogressive"), de = /* @__PURE__ */ Symbol("Needle:LODSManager"), fe = /* @__PURE__ */ Symbol("Needle:LODState"), z = /* @__PURE__ */ Symbol("Needle:CurrentLOD"), D = { mesh_lod: -1, texture_lod: -1 }, Lt = new ke(), be = [
+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 = [
   3526751,
   11065402,
   15978811,
@@ -1134,22 +1134,79 @@ const R = N("debugprogressive"), xt = R === "colors", wt = N("noprogressive"), d
   15817653,
   5083278,
   5592405
-];
-class L {
+], 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) {
+  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;
+}
+function Tt(i) {
+  const {
+    geometry: t,
+    matrixWorld: e,
+    camera: s,
+    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,
+    screenCoverage: 0,
+    screenspaceVolume: new k(),
+    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;
+      break;
+    }
+  }
+  return m;
+}
+class R {
   /** 
    * 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[fe];
+    return t[he];
   }
   static addPlugin(t) {
-    q.push(t);
+    E.push(t);
   }
   static removePlugin(t) {
-    const e = q.indexOf(t);
-    e >= 0 && q.splice(e, 1);
+    const e = E.indexOf(t);
+    e >= 0 && E.splice(e, 1);
   }
   /**
    * Gets the LODsManager for the given renderer. If the LODsManager does not exist yet, it will be created.  
@@ -1157,20 +1214,20 @@ class L {
    * @returns The LODsManager instance.
    */
   static get(t, e) {
-    if (t[de])
-      return console.debug("[gltf-progressive] LODsManager already exists for this renderer"), t[de];
-    const s = new L(t, {
+    if (t[fe])
+      return console.debug("[gltf-progressive] LODsManager already exists for this renderer"), t[fe];
+    const s = new R(t, {
       engine: "unknown",
       ...e
     });
-    return t[de] = s, s;
+    return t[fe] = s, s;
   }
   renderer;
   context;
-  projectionScreenMatrix = new ve();
+  projectionScreenMatrix = new Pe();
   /** @deprecated use static `LODsManager.addPlugin()` method. This getter will be removed in later versions */
   get plugins() {
-    return q;
+    return E;
   }
   /**
    * Force override the LOD level for all objects (meshes + textures) rendered in the scene
@@ -1235,17 +1292,21 @@ class L {
    * ```
    */
   awaitLoading(t) {
-    const e = this._promiseGroupIds++, s = new ce(this.#r, { ...t });
+    const e = this._promiseGroupIds++, s = new oe(this.#r, { ...t });
     this._newPromiseGroups.push(s);
     const r = performance.now();
     return s.ready.finally(() => {
       const n = this._newPromiseGroups.indexOf(s);
-      n >= 0 && (this._newPromiseGroups.splice(n, 1), Me() && performance.measure("LODsManager:awaitLoading", {
+      n >= 0 && (this._newPromiseGroups.splice(n, 1), $e() && performance.measure("LODsManager:awaitLoading", {
         start: r,
         detail: { id: e, name: t?.name, awaited: s.awaitedCount, resolved: s.resolvedCount }
       }));
     }), s.ready;
   }
+  /** Track LOD work started outside this manager so {@link awaitLoading} waits for it too. */
+  trackLoadingPromise(t, e, s) {
+    return oe.addPromise(t, e, s, this._newPromiseGroups), s;
+  }
   _postprocessPromiseGroups() {
     if (this._newPromiseGroups.length !== 0)
       for (let t = this._newPromiseGroups.length - 1; t >= 0; t--)
@@ -1292,7 +1353,7 @@ class L {
     this.renderer = t, this.context = { ...e };
   }
   #t;
-  #o = new Xe();
+  #o = new Ke();
   #r = 0;
   #n = 0;
   #i = 0;
@@ -1307,9 +1368,9 @@ class L {
     let t = 0;
     this.#t = this.renderer.render;
     const e = this;
-    we(this.renderer), this.renderer.render = function(s, r) {
+    Le(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, R && 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.#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));
       const o = t++;
       e.#t.call(this, s, r), e.onAfterRender(s, r, o);
     };
@@ -1344,7 +1405,7 @@ class L {
       (u.name === "EffectMaterial" || u.name === "CopyShader") && (o = !1);
     }
     if ((e.parent && e.parent.type === "CubeCamera" || s >= 1 && e.type === "OrthographicCamera") && (o = !1), o) {
-      if (wt || (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 (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))
         return;
       this.internalUpdate(t, e), this._postprocessPromiseGroups();
     }
@@ -1358,7 +1419,7 @@ class L {
     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")) {
-        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)));
+        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)));
         continue;
       }
       switch (a.material.type) {
@@ -1371,32 +1432,32 @@ class L {
           continue;
       }
       const l = a.object;
-      (l instanceof X || l.isMesh) && this.updateLODs(t, e, l, n);
+      (l instanceof K || l.isMesh) && this.updateLODs(t, e, l, n);
     }
     const o = s.transparent;
     for (const a of o) {
       const l = a.object;
-      (l instanceof X || l.isMesh) && this.updateLODs(t, e, l, n);
+      (l instanceof K || l.isMesh) && this.updateLODs(t, e, l, n);
     }
     const u = s.transmissive;
     for (const a of u) {
       const l = a.object;
-      (l instanceof X || l.isMesh) && this.updateLODs(t, e, l, n);
+      (l instanceof K || l.isMesh) && this.updateLODs(t, e, l, n);
     }
   }
   /** Update the LOD levels for the renderer. */
   updateLODs(t, e, s, r) {
     s.userData || (s.userData = {});
-    let n = s[fe];
-    if (n || (n = new _t(), s[fe] = n), n.frames++ < 2)
+    let n = s[he];
+    if (n || (n = new St(), s[he] = n), n.frames++ < 2)
       return;
-    for (const u of q)
+    for (const u of E)
       u.onBeforeUpdateLOD?.(this.renderer, t, e, s);
-    const o = this.overrideLodLevel !== void 0 ? this.overrideLodLevel : E;
-    o >= 0 ? (D.mesh_lod = o, D.texture_lod = o) : (this.calculateLodLevel(e, s, n, r, D), D.mesh_lod = Math.round(D.mesh_lod), D.texture_lod = Math.round(D.texture_lod)), D.mesh_lod >= 0 && this.loadProgressiveMeshes(s, D.mesh_lod), s.material && D.texture_lod >= 0 && this.loadProgressiveTextures(s.material, D.texture_lod, o), h && s.material && !s.isGizmo && Ie(s.material), xt && s.material && !s.isGizmo && !s.isBatchedMesh && $e(s.material, D.mesh_lod);
-    for (const u of q)
-      u.onAfterUpdatedLOD?.(this.renderer, t, e, s, D);
-    n.lastLodLevel_Mesh = D.mesh_lod, n.lastLodLevel_Texture = D.texture_lod;
+    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);
+    n.lastLodLevel_Mesh = T.mesh_lod, n.lastLodLevel_Texture = T.texture_lod;
   }
   /** Load progressive textures for the given material
    * @param material the material to load the textures for
@@ -1411,14 +1472,14 @@ class L {
       return;
     }
     let r = !1;
-    (t[z] === void 0 || e < t[z]) && (r = !0);
+    (t[q] === void 0 || e < t[q]) && (r = !0);
     const n = s !== void 0 && s >= 0;
-    if (n && (r = t[z] != s, e = s), r) {
-      t[z] = e;
-      const o = n ? { force: !0 } : void 0, u = p.assignTextureLOD(t, e, o).then((a) => {
+    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 }));
       });
-      ce.addPromise("texture", t, u, this._newPromiseGroups);
+      oe.addPromise("texture", t, u, this._newPromiseGroups);
     }
   }
   /** Load progressive meshes for the given mesh
@@ -1429,32 +1490,18 @@ class L {
    */
   loadProgressiveMeshes(t, e) {
     if (!t) return Promise.resolve(null);
-    let s = t[z] !== e;
+    let s = t[q] !== e;
     const r = t["DEBUG:LOD"];
-    if (r != null && (s = t[z] != r, e = r), s) {
-      t[z] = e;
-      const n = t.geometry, o = p.assignMeshLOD(t, e).then((u) => (u && t[z] == e && n != t.geometry && this._lodchangedlisteners.forEach((a) => a({ type: "mesh", level: e, object: t })), u));
-      return ce.addPromise("mesh", t, o, this._newPromiseGroups), o;
+    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));
+      return oe.addPromise("mesh", t, o, this._newPromiseGroups), o;
     }
     return Promise.resolve(null);
   }
   // private testIfLODLevelsAreAvailable() {
-  _sphere = new Oe();
-  _tempBox = new ge();
-  _tempBox2 = new ge();
-  tempMatrix = new ve();
-  _tempWorldPosition = new P();
-  _tempBoxSize = new P();
-  _tempBox2Size = new P();
-  static corner0 = new P();
-  static corner1 = new P();
-  static corner2 = new P();
-  static corner3 = new P();
-  static _tempPtInside = new P();
-  static isInside(t, e) {
-    const s = t.min, r = t.max, n = (s.x + r.x) * 0.5, o = (s.y + r.y) * 0.5;
-    return this._tempPtInside.set(n, o, s.z).applyMatrix4(e).z < 0;
-  }
+  _sphere = new Se();
+  _tempWorldPosition = new k();
   static skinnedMeshBoundsFrameOffsetCounter = 0;
   static $skinnedMeshBoundsOffset = /* @__PURE__ */ Symbol("gltf-progressive-skinnedMeshBoundsOffset");
   // #region calculateLodLevel
@@ -1468,104 +1515,85 @@ class L {
       return;
     }
     let u = 10 + 1, a = !1;
-    if (R && e["DEBUG:LOD"] != null)
+    if (A && e["DEBUG:LOD"] != null)
       return e["DEBUG:LOD"];
-    const l = p.getMeshLODExtension(e.geometry)?.lods, c = p.getPrimitiveIndex(e.geometry), f = l && l.length > 0, y = p.getMaterialMinMaxLODsCount(e.material), T = y.min_count !== 1 / 0 && y.min_count >= 0 && y.max_count >= 0;
-    if (!f && !T) {
+    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) {
       n.mesh_lod = 0, n.texture_lod = 0;
       return;
     }
-    f || (a = !0, u = 0);
-    const _ = this.renderer.domElement.clientHeight || this.renderer.domElement.height;
-    let C = e.geometry.boundingBox;
+    d || (a = !0, u = 0);
+    const x = this.renderer.domElement.clientHeight || this.renderer.domElement.height;
+    let v = e.geometry.boundingBox;
     if (e.type === "SkinnedMesh") {
-      const x = e;
-      if (!x.boundingBox)
-        x.computeBoundingBox();
+      const p = e;
+      if (!p.boundingBox)
+        p.computeBoundingBox();
       else if (this.skinnedMeshAutoUpdateBoundsInterval > 0) {
-        if (!x[L.$skinnedMeshBoundsOffset]) {
-          const B = L.skinnedMeshBoundsFrameOffsetCounter++;
-          x[L.$skinnedMeshBoundsOffset] = B;
+        if (!p[R.$skinnedMeshBoundsOffset]) {
+          const C = R.skinnedMeshBoundsFrameOffsetCounter++;
+          p[R.$skinnedMeshBoundsOffset] = C;
         }
-        const m = x[L.$skinnedMeshBoundsOffset];
-        if ((s.frames + m) % this.skinnedMeshAutoUpdateBoundsInterval === 0) {
-          const B = ee(x), G = x.geometry;
-          B && (x.geometry = B), x.computeBoundingBox(), x.geometry = G;
+        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;
         }
       }
-      C = x.boundingBox;
+      v = p.boundingBox;
     }
-    if (C) {
-      const x = t;
+    if (v) {
       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 d = t.getWorldPosition(this._tempWorldPosition);
-        if (this._sphere.containsPoint(d)) {
+        const C = t.getWorldPosition(this._tempWorldPosition);
+        if (this._sphere.containsPoint(C)) {
           n.mesh_lod = 0, n.texture_lod = 0;
           return;
         }
       }
-      if (this._tempBox.copy(C), this._tempBox.applyMatrix4(e.matrixWorld), x.isPerspectiveCamera && L.isInside(this._tempBox, this.projectionScreenMatrix)) {
+      const p = Tt({
+        geometry: e.geometry,
+        matrixWorld: e.matrixWorld,
+        camera: t,
+        projectionScreenMatrix: this.projectionScreenMatrix,
+        desiredDensity: r,
+        canvasHeight: x,
+        currentLevel: s.lastLodLevel_Mesh,
+        boundingBox: v,
+        xrEnabled: this.renderer.xr.enabled,
+        debugDrawLine: A ? R.debugDrawLine : void 0,
+        warnMissingPrimitiveDensities: !0
+      });
+      if (s.lastCentrality = p.centrality, s.lastScreenCoverage = p.screenCoverage, s.lastScreenspaceVolume.copy(p.screenspaceVolume), p.screenCoverage === 1 / 0) {
         n.mesh_lod = 0, n.texture_lod = 0;
         return;
       }
-      if (this._tempBox.applyMatrix4(this.projectionScreenMatrix), this.renderer.xr.enabled && x.isPerspectiveCamera && x.fov > 70) {
-        const d = this._tempBox.min, g = this._tempBox.max;
-        let w = d.x, v = d.y, O = g.x, Y = g.y;
-        const te = 2, ie = 1.5, se = (d.x + g.x) * 0.5, re = (d.y + g.y) * 0.5;
-        w = (w - se) * te + se, v = (v - re) * te + re, O = (O - se) * te + se, Y = (Y - re) * te + re;
-        const We = w < 0 && O > 0 ? 0 : Math.min(Math.abs(d.x), Math.abs(g.x)), Fe = v < 0 && Y > 0 ? 0 : Math.min(Math.abs(d.y), Math.abs(g.y)), ae = Math.max(We, Fe);
-        s.lastCentrality = (ie - ae) * (ie - ae) * (ie - ae);
-      } else
-        s.lastCentrality = 1;
-      const m = this._tempBox.getSize(this._tempBoxSize);
-      m.multiplyScalar(0.5), screen.availHeight > 0 && _ > 0 && m.multiplyScalar(_ / screen.availHeight), t.isPerspectiveCamera ? m.x *= t.aspect : t.isOrthographicCamera;
-      const B = t.matrixWorldInverse, G = this._tempBox2;
-      G.copy(C), G.applyMatrix4(e.matrixWorld), G.applyMatrix4(B);
-      const A = G.getSize(this._tempBox2Size), S = Math.max(A.x, A.y);
-      if (Math.max(m.x, m.y) != 0 && S != 0 && (m.z = A.z / Math.max(A.x, A.y) * Math.max(m.x, m.y)), s.lastScreenCoverage = Math.max(m.x, m.y, m.z), s.lastScreenspaceVolume.copy(m), s.lastScreenCoverage *= s.lastCentrality, R && L.debugDrawLine) {
-        const d = this.tempMatrix.copy(this.projectionScreenMatrix);
-        d.invert();
-        const g = L.corner0, w = L.corner1, v = L.corner2, O = L.corner3;
-        g.copy(this._tempBox.min), w.copy(this._tempBox.max), w.x = g.x, v.copy(this._tempBox.max), v.y = g.y, O.copy(this._tempBox.max);
-        const Y = (g.z + O.z) * 0.5;
-        g.z = w.z = v.z = O.z = Y, g.applyMatrix4(d), w.applyMatrix4(d), v.applyMatrix4(d), O.applyMatrix4(d), L.debugDrawLine(g, w, 255), L.debugDrawLine(g, v, 255), L.debugDrawLine(w, O, 255), L.debugDrawLine(v, O, 255);
-      }
-      let M = 999;
-      if (l && s.lastScreenCoverage > 0)
-        for (let d = 0; d < l.length; d++) {
-          const g = l[d], v = (g.densities?.[c] || g.density || 1e-5) / s.lastScreenCoverage;
-          if (c > 0 && Me() && !g.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.")), v < r) {
-            M = d;
-            break;
-          }
-        }
-      M < u && (u = M, a = !0);
+      p.level >= 0 && p.level < u && (u = p.level, a = !0);
     }
-    if (a ? n.mesh_lod = u : n.mesh_lod = s.lastLodLevel_Mesh, R && n.mesh_lod != s.lastLodLevel_Mesh) {
-      const m = l?.[n.mesh_lod];
-      m && console.log(`Mesh LOD changed: ${s.lastLodLevel_Mesh} → ${n.mesh_lod} (density: ${m.densities?.[c].toFixed(0)}) | ${e.name}`);
+    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 (T) {
-      const x = "saveData" in globalThis.navigator && globalThis.navigator.saveData === !0;
+    if (m) {
+      const p = "saveData" in globalThis.navigator && globalThis.navigator.saveData === !0;
       if (s.lastLodLevel_Texture < 0) {
-        if (n.texture_lod = y.max_count - 1, R) {
-          const m = y.lods[y.max_count - 1];
-          R && console.log(`First Texture LOD ${n.texture_lod} (${m.max_height}px) - ${e.name}`);
+        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}`);
         }
       } else {
-        const m = s.lastScreenspaceVolume.x + s.lastScreenspaceVolume.y + s.lastScreenspaceVolume.z;
-        let B = s.lastScreenCoverage * 4;
-        this.context?.engine === "model-viewer" && (B *= 1.5);
-        const A = _ / window.devicePixelRatio * B;
-        let S = !1;
-        for (let F = y.lods.length - 1; F >= 0; F--) {
-          const M = y.lods[F];
-          if (!(x && M.max_height >= 2048) && !(Le() && M.max_height > 4096) && (M.max_height > A || !S && F === 0)) {
-            if (S = !0, n.texture_lod = F, R && n.texture_lod < s.lastLodLevel_Texture) {
-              const b = M.max_height;
-              console.log(`Texture LOD changed: ${s.lastLodLevel_Texture} → ${n.texture_lod} = ${b}px 
-Screensize: ${A.toFixed(0)}px, Coverage: ${(100 * s.lastScreenCoverage).toFixed(2)}%, Volume ${m.toFixed(1)} 
+        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)} 
 ${e.name}`);
             }
             break;
@@ -1576,61 +1604,61 @@ ${e.name}`);
       n.texture_lod = 0;
   }
 }
-class _t {
+class St {
   frames = 0;
   lastLodLevel_Mesh = -1;
   lastLodLevel_Texture = -1;
   lastScreenCoverage = 0;
-  lastScreenspaceVolume = new P();
+  lastScreenspaceVolume = new k();
   lastCentrality = 0;
 }
-function $e(i, t) {
+function Ge(i, t) {
   if (!(t < 0)) {
     if (Array.isArray(i)) {
       for (const e of i)
-        $e(e, t);
+        Ge(e, t);
       return;
     }
-    "color" in i && i.color instanceof ke && (i.color.copy(vt(t, Lt)), i.needsUpdate = !0);
+    "color" in i && i.color instanceof Ce && (i.color.copy(Ct(t, _t)), i.needsUpdate = !0);
   }
 }
-function vt(i, t) {
-  const e = Math.max(0, Math.min(be.length - 1, Math.floor(i)));
-  return t.setHex(be[e]);
+function Ct(i, t) {
+  const e = Math.max(0, Math.min(Me.length - 1, Math.floor(i)));
+  return t.setHex(Me[e]);
 }
-const De = /* @__PURE__ */ Symbol("NEEDLE_mesh_lod"), ne = /* @__PURE__ */ Symbol("NEEDLE_texture_lod");
-let he = null;
-function Be() {
-  const i = Mt();
+const be = /* @__PURE__ */ Symbol("NEEDLE_mesh_lod"), ie = /* @__PURE__ */ Symbol("NEEDLE_texture_lod");
+let pe = null;
+function We() {
+  const i = Pt();
   i && (i.mapURLs(function(t) {
-    return Te(), t;
-  }), Te(), he?.disconnect(), he = new MutationObserver((t) => {
+    return Oe(), t;
+  }), Oe(), pe?.disconnect(), pe = new MutationObserver((t) => {
     t.forEach((e) => {
       e.addedNodes.forEach((s) => {
-        s instanceof HTMLElement && s.tagName.toLowerCase() === "model-viewer" && Ge(s);
+        s instanceof HTMLElement && s.tagName.toLowerCase() === "model-viewer" && Ue(s);
       });
     });
-  }), he.observe(document, { childList: !0, subtree: !0 }));
+  }), pe.observe(document, { childList: !0, subtree: !0 }));
 }
-function Mt() {
+function Pt() {
   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"), Be();
+    console.debug("[gltf-progressive] model-viewer defined"), We();
   }), null);
 }
-function Te() {
+function Oe() {
   if (typeof document > "u") return;
   document.querySelectorAll("model-viewer").forEach((t) => {
-    Ge(t);
+    Ue(t);
   });
 }
-const Se = /* @__PURE__ */ new WeakSet();
-let bt = 0;
-function Ge(i) {
-  if (!i || Se.has(i))
+const Te = /* @__PURE__ */ new WeakSet();
+let kt = 0;
+function Ue(i) {
+  if (!i || Te.has(i))
     return null;
-  Se.add(i), console.debug("[gltf-progressive] found new model-viewer..." + ++bt + `
+  Te.add(i), console.debug("[gltf-progressive] found new model-viewer..." + ++kt + `
 `, i.getAttribute("src"));
   let t = null, e = null, s = null;
   for (let r = i; r != null; r = Object.getPrototypeOf(r)) {
@@ -1651,8 +1679,8 @@ function Ge(i) {
       }
     };
     console.debug("[gltf-progressive] setup model-viewer");
-    const n = L.get(t, { engine: "model-viewer" });
-    return L.addPlugin(new Dt()), n.enable(), n.addEventListener("changed", () => {
+    const n = R.get(t, { engine: "model-viewer" });
+    return R.addPlugin(new At()), n.enable(), n.addEventListener("changed", () => {
       s?.call(i);
     }), i.addEventListener("model-visibility", (o) => {
       o.detail.visible && s?.call(i);
@@ -1664,7 +1692,7 @@ function Ge(i) {
   }
   return null;
 }
-class Dt {
+class At {
   _didWarnAboutMissingUrl = !1;
   onBeforeUpdateLOD(t, e, s, r) {
     this.tryParseMeshLOD(e, r), this.tryParseTextureLOD(e, r);
@@ -1682,27 +1710,27 @@ class Dt {
     return t.element;
   }
   tryParseTextureLOD(t, e) {
-    if (e[ne] == !0) return;
-    e[ne] = !0;
+    if (e[ie] == !0) return;
+    e[ie] = !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[ne] == !0) return;
-        a[ne] = !0, a.userData && (a.userData.LOD = -1);
+        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 f = l[c], y = a[f];
-          if (y?.isTexture === !0) {
-            const T = y.userData?.associations?.textures;
-            if (T == null) continue;
-            const _ = s.parser.json.textures[T];
-            if (!_) {
-              console.warn("Texture data not found for texture index " + T);
+          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);
               continue;
             }
-            if (_?.extensions?.[U]) {
-              const C = _.extensions[U];
-              C && n && p.registerTexture(n, y, C.lods.length, T, C);
+            if (x?.extensions?.[F]) {
+              const v = x.extensions[F];
+              v && n && h.registerTexture(n, g, v.lods.length, m, v);
             }
           }
         }
@@ -1713,19 +1741,19 @@ class Dt {
     }
   }
   tryParseMeshLOD(t, e) {
-    if (e[De] == !0) return;
-    e[De] = !0;
+    if (e[be] == !0) return;
+    e[be] = !0;
     const s = this.tryGetCurrentModelViewer(t), r = this.getUrl(s);
     if (!r)
       return;
-    const n = e.userData?.gltfExtensions?.[U];
+    const n = e.userData?.gltfExtensions?.[F];
     if (n && r) {
       const o = e.uuid;
-      p.registerMesh(r, o, e, 0, n.lods.length, n);
+      h.registerMesh(r, o, e, 0, n.lods.length, n);
     }
   }
 }
-function Tt(...i) {
+function Rt(...i) {
   let t, e, s, r;
   switch (i.length) {
     case 2:
@@ -1740,22 +1768,22 @@ function Tt(...i) {
     default:
       throw new Error("Invalid arguments");
   }
-  we(e), Pe(s), Re(s, {
+  Le(e), Ae(s), Ie(s, {
     progressive: !0,
     ...r?.hints
-  }), s.register((o) => new p(o));
-  const n = L.get(e);
+  }), s.register((o) => new h(o));
+  const n = R.get(e);
   return r?.enableLODsManager !== !1 && n.enable(), n;
 }
-Be();
-if (!lt) {
+We();
+if (!ct) {
   const i = {
     gltfProgressive: {
-      useNeedleProgressive: Tt,
-      LODsManager: L,
-      configureLoader: Re,
-      getRaycastMesh: ee,
-      useRaycastMeshes: ct
+      useNeedleProgressive: Rt,
+      LODsManager: R,
+      configureLoader: Ie,
+      getRaycastMesh: ne,
+      useRaycastMeshes: ft
     }
   };
   if (!globalThis.Needle)
@@ -1765,20 +1793,21 @@ if (!lt) {
       globalThis.Needle[t] = i[t];
 }
 export {
-  U as EXTENSION_NAME,
-  L as LODsManager,
-  p as NEEDLE_progressive,
-  He as VERSION,
-  Pe as addDracoAndKTX2Loaders,
-  Re as configureLoader,
-  we as createLoaders,
-  vt as getLODColor,
-  ee as getRaycastMesh,
-  be as lodDebugColors,
-  Be as patchModelViewer,
-  ut as registerRaycastMesh,
-  et as setDracoDecoderLocation,
-  tt as setKTX2TranscoderLocation,
-  Tt as useNeedleProgressive,
-  ct as useRaycastMeshes
+  F as EXTENSION_NAME,
+  R as LODsManager,
+  h as NEEDLE_progressive,
+  Je as VERSION,
+  Ae as addDracoAndKTX2Loaders,
+  Tt as calculateMeshLODLevel,
+  Ie as configureLoader,
+  Le as createLoaders,
+  Ct as getLODColor,
+  ne as getRaycastMesh,
+  Me as lodDebugColors,
+  We as patchModelViewer,
+  dt as registerRaycastMesh,
+  st as setDracoDecoderLocation,
+  rt as setKTX2TranscoderLocation,
+  Rt as useNeedleProgressive,
+  ft as useRaycastMeshes
 };