@needle-tools/gltf-progressive 3.0.0 → 3.1.0-next.f550970

package/gltf-progressive.js

@@ -1,179 +1,219 @@
-var Ke = Object.defineProperty;
-var Ye = (n, t, e) => t in n ? Ke(n, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : n[t] = e;
-var d = (n, t, e) => (Ye(n, typeof t != "symbol" ? t + "" : t, e), e), Ce = (n, t, e) => {
-  if (!t.has(n))
+var He = Object.defineProperty;
+var Qe = (o, t, e) => t in o ? He(o, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : o[t] = e;
+var u = (o, t, e) => (Qe(o, typeof t != "symbol" ? t + "" : t, e), e), Ee = (o, t, e) => {
+  if (!t.has(o))
     throw TypeError("Cannot " + e);
 };
-var y = (n, t, e) => (Ce(n, t, "read from private field"), e ? e.call(n) : t.get(n)), J = (n, t, e) => {
-  if (t.has(n))
+var L = (o, t, e) => (Ee(o, t, "read from private field"), e ? e.call(o) : t.get(o)), H = (o, t, e) => {
+  if (t.has(o))
     throw TypeError("Cannot add the same private member more than once");
-  t instanceof WeakSet ? t.add(n) : t.set(n, e);
-}, V = (n, t, e, r) => (Ce(n, t, "write to private field"), r ? r.call(n, e) : t.set(n, e), e);
-import { BufferGeometry as me, Mesh as te, Texture as ne, TextureLoader as He, Matrix4 as Ee, Clock as je, MeshStandardMaterial as Je, Sphere as Qe, Box3 as Be, Vector3 as K } from "three";
-import { GLTFLoader as Pe } from "three/examples/jsm/loaders/GLTFLoader.js";
-import { MeshoptDecoder as Ze } from "three/examples/jsm/libs/meshopt_decoder.module.js";
-import { DRACOLoader as et } from "three/examples/jsm/loaders/DRACOLoader.js";
-import { KTX2Loader as tt } from "three/examples/jsm/loaders/KTX2Loader.js";
-const rt = "";
-globalThis.GLTF_PROGRESSIVE_VERSION = rt;
+  t instanceof WeakSet ? t.add(o) : t.set(o, e);
+}, V = (o, t, e, s) => (Ee(o, t, "write to private field"), s ? s.call(o, e) : t.set(o, e), e);
+import { BufferGeometry as Le, Mesh as se, Texture as oe, TextureLoader as je, Matrix4 as Ie, Clock as Je, MeshStandardMaterial as Ze, Sphere as et, Box3 as $e, Vector3 as W } from "three";
+import { GLTFLoader as Ce } from "three/examples/jsm/loaders/GLTFLoader.js";
+import { MeshoptDecoder as tt } from "three/examples/jsm/libs/meshopt_decoder.module.js";
+import { DRACOLoader as st } from "three/examples/jsm/loaders/DRACOLoader.js";
+import { KTX2Loader as rt } from "three/examples/jsm/loaders/KTX2Loader.js";
+const it = "";
+globalThis.GLTF_PROGRESSIVE_VERSION = it;
 console.debug("[gltf-progressive] version -");
-let W = "https://www.gstatic.com/draco/versioned/decoders/1.5.7/", re = "https://www.gstatic.com/basis-universal/versioned/2021-04-15-ba1c3e4/";
-const st = W, ot = re, Ge = new URL(W + "draco_decoder.js");
-Ge.searchParams.append("range", "true");
-fetch(Ge, {
+let q = "https://www.gstatic.com/draco/versioned/decoders/1.5.7/", re = "https://www.gstatic.com/basis-universal/versioned/2021-04-15-ba1c3e4/";
+const nt = q, ot = re, Fe = new URL(q + "draco_decoder.js");
+Fe.searchParams.append("range", "true");
+fetch(Fe, {
   method: "GET",
   headers: {
     Range: "bytes=0-1"
   }
-}).catch((n) => {
-  console.debug(`Failed to fetch remote Draco decoder from ${W} (offline: ${typeof navigator < "u" ? navigator.onLine : "unknown"})`), W === st && it("./include/draco/"), re === ot && nt("./include/ktx2/");
+}).catch((o) => {
+  console.debug(`Failed to fetch remote Draco decoder from ${q} (offline: ${typeof navigator < "u" ? navigator.onLine : "unknown"})`), q === nt && at("./include/draco/"), re === ot && lt("./include/ktx2/");
 }).finally(() => {
-  $e();
+  Ne();
 });
-function it(n) {
-  W = n, R && R[Se] != W ? (console.debug("Updating Draco decoder path to " + n), R[Se] = W, R.setDecoderPath(W), R.preload()) : console.debug("Setting Draco decoder path to " + n);
+function at(o) {
+  q = o, k && k[Pe] != q ? (console.debug("Updating Draco decoder path to " + o), k[Pe] = q, k.setDecoderPath(q), k.preload()) : console.debug("Setting Draco decoder path to " + o);
 }
-function nt(n) {
-  re = n, F && F.transcoderPath != re ? (console.debug("Updating KTX2 transcoder path to " + n), F.setTranscoderPath(re), F.init()) : console.debug("Setting KTX2 transcoder path to " + n);
+function lt(o) {
+  re = o, N && N.transcoderPath != re ? (console.debug("Updating KTX2 transcoder path to " + o), N.setTranscoderPath(re), N.init()) : console.debug("Setting KTX2 transcoder path to " + o);
 }
-const Se = Symbol("dracoDecoderPath");
-let R, Le, F;
-function $e() {
-  R || (R = new et(), R[Se] = W, R.setDecoderPath(W), R.setDecoderConfig({ type: "js" }), R.preload()), F || (F = new tt(), F.setTranscoderPath(re), F.init()), Le || (Le = Ze);
+const Pe = Symbol("dracoDecoderPath");
+let k, xe, N;
+function Ne() {
+  k || (k = new st(), k[Pe] = q, k.setDecoderPath(q), k.setDecoderConfig({ type: "js" }), k.preload()), N || (N = new rt(), N.setTranscoderPath(re), N.init()), xe || (xe = tt);
 }
-function Ue(n) {
-  return $e(), n ? F.detectSupport(n) : n !== null && console.warn("No renderer provided to detect ktx2 support - loading KTX2 textures might fail"), { dracoLoader: R, ktx2Loader: F, meshoptDecoder: Le };
+function Ue(o) {
+  return Ne(), o ? N.detectSupport(o) : o !== null && console.warn("No renderer provided to detect ktx2 support - loading KTX2 textures might fail"), { dracoLoader: k, ktx2Loader: N, meshoptDecoder: xe };
 }
-function Fe(n) {
-  n.dracoLoader || n.setDRACOLoader(R), n.ktx2Loader || n.setKTX2Loader(F), n.meshoptDecoder || n.setMeshoptDecoder(Le);
+function ze(o) {
+  o.dracoLoader || o.setDRACOLoader(k), o.ktx2Loader || o.setKTX2Loader(N), o.meshoptDecoder || o.setMeshoptDecoder(xe);
 }
 const Te = /* @__PURE__ */ new WeakMap();
-function Ne(n, t) {
-  let e = Te.get(n);
-  e ? e = Object.assign(e, t) : e = t, Te.set(n, e);
+function Ve(o, t) {
+  let e = Te.get(o);
+  e ? e = Object.assign(e, t) : e = t, Te.set(o, e);
 }
-const we = Pe.prototype.load;
-function at(...n) {
+const Me = Ce.prototype.load;
+function ut(...o) {
   const t = Te.get(this);
-  let e = n[0];
-  const r = new URL(e, window.location.href);
-  if (r.hostname.endsWith("needle.tools")) {
-    const o = (t == null ? void 0 : t.progressive) !== void 0 ? t.progressive : !0, s = t != null && t.usecase ? t.usecase : "default";
-    o ? this.requestHeader.Accept = `*/*;progressive=allowed;usecase=${s}` : this.requestHeader.Accept = `*/*;usecase=${s}`, e = r.toString();
+  let e = o[0];
+  const s = new URL(e, window.location.href);
+  if (s.hostname.endsWith("needle.tools")) {
+    const r = (t == null ? void 0 : t.progressive) !== void 0 ? t.progressive : !0, i = t != null && t.usecase ? t.usecase : "default";
+    r ? this.requestHeader.Accept = `*/*;progressive=allowed;usecase=${i}` : this.requestHeader.Accept = `*/*;usecase=${i}`, e = s.toString();
   }
-  return n[0] = e, we == null ? void 0 : we.call(this, ...n);
+  return o[0] = e, Me == null ? void 0 : Me.call(this, ...o);
 }
-Pe.prototype.load = at;
-ue("debugprogressive");
-function ue(n) {
+Ce.prototype.load = ut;
+de("debugprogressive");
+function de(o) {
   if (typeof window > "u")
     return !1;
-  const e = new URL(window.location.href).searchParams.get(n);
+  const e = new URL(window.location.href).searchParams.get(o);
   return e == null || e === "0" || e === "false" ? !1 : e === "" ? !0 : e;
 }
-function lt(n, t) {
-  if (t === void 0 || t.startsWith("./") || t.startsWith("http") || n === void 0)
+function dt(o, t) {
+  if (t === void 0 || t.startsWith("./") || t.startsWith("http") || o === void 0)
     return t;
-  const e = n.lastIndexOf("/");
+  const e = o.lastIndexOf("/");
   if (e >= 0) {
-    const r = n.substring(0, e + 1);
-    for (; r.endsWith("/") && t.startsWith("/"); )
+    const s = o.substring(0, e + 1);
+    for (; s.endsWith("/") && t.startsWith("/"); )
       t = t.substring(1);
-    return r + t;
+    return s + t;
   }
   return t;
 }
 let ae;
 function ct() {
-  return ae !== void 0 || (ae = /iPhone|iPad|iPod|Android|IEMobile/i.test(navigator.userAgent), ue("debugprogressive") && console.log("[glTF Progressive]: isMobileDevice", ae)), ae;
+  return ae !== void 0 || (ae = /iPhone|iPad|iPod|Android|IEMobile/i.test(navigator.userAgent), de("debugprogressive") && console.log("[glTF Progressive]: isMobileDevice", ae)), ae;
 }
-const ut = typeof window > "u" && typeof document > "u", Ae = Symbol("needle:raycast-mesh");
-function de(n) {
-  return (n == null ? void 0 : n[Ae]) instanceof me ? n[Ae] : null;
+function Ge() {
+  if (typeof window > "u")
+    return !1;
+  const o = new URL(window.location.href), t = o.hostname === "localhost" || /^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/.test(o.hostname);
+  return o.hostname === "127.0.0.1" || t;
+}
+class ft {
+  constructor(t = 100, e = {}) {
+    u(this, "_running", /* @__PURE__ */ new Map());
+    u(this, "_queue", []);
+    u(this, "debug", !1);
+    u(this, "tick", () => {
+      this.internalUpdate(), setTimeout(this.tick, 10);
+    });
+    this.maxConcurrent = t, this.debug = e.debug ?? !1, window.requestAnimationFrame(this.tick);
+  }
+  /**
+   * Request a slot for a promise with a specific key. This function returns a promise with a `use` method that can be called to add the promise to the queue.
+   */
+  slot(t) {
+    return this.debug && console.debug(`[PromiseQueue]: Requesting slot for key ${t}, running: ${this._running.size}, waiting: ${this._queue.length}`), new Promise((e) => {
+      this._queue.push({ key: t, resolve: e });
+    });
+  }
+  add(t, e) {
+    this._running.has(t) || (this._running.set(t, e), e.finally(() => {
+      this._running.delete(t), this.debug && console.debug(`[PromiseQueue]: Promise finished now running: ${this._running.size}, waiting: ${this._queue.length}. (finished ${t})`);
+    }), this.debug && console.debug(`[PromiseQueue]: Added new promise, now running: ${this._running.size}, waiting: ${this._queue.length}. (added ${t})`));
+  }
+  internalUpdate() {
+    const t = this.maxConcurrent - this._running.size;
+    for (let e = 0; e < t && this._queue.length > 0; e++) {
+      this.debug && console.debug(`[PromiseQueue]: Running ${this._running.size} promises, waiting for ${this._queue.length} more.`);
+      const { key: s, resolve: n } = this._queue.shift();
+      n({
+        use: (r) => this.add(s, r)
+      });
+    }
+  }
+}
+const ht = typeof window > "u" && typeof document > "u", Ae = Symbol("needle:raycast-mesh");
+function ce(o) {
+  return (o == null ? void 0 : o[Ae]) instanceof Le ? o[Ae] : null;
 }
-function dt(n, t) {
-  if ((n.type === "Mesh" || n.type === "SkinnedMesh") && !de(n)) {
-    const r = ht(t);
-    r.userData = { isRaycastMesh: !0 }, n[Ae] = r;
+function gt(o, t) {
+  if ((o.type === "Mesh" || o.type === "SkinnedMesh") && !ce(o)) {
+    const s = mt(t);
+    s.userData = { isRaycastMesh: !0 }, o[Ae] = s;
   }
 }
-function ft(n = !0) {
-  if (n) {
+function pt(o = !0) {
+  if (o) {
     if (le)
       return;
-    const t = le = te.prototype.raycast;
-    te.prototype.raycast = function(e, r) {
-      const i = this, o = de(i);
-      let s;
-      o && i.isMesh && (s = i.geometry, i.geometry = o), t.call(this, e, r), s && (i.geometry = s);
+    const t = le = se.prototype.raycast;
+    se.prototype.raycast = function(e, s) {
+      const n = this, r = ce(n);
+      let i;
+      r && n.isMesh && (i = n.geometry, n.geometry = r), t.call(this, e, s), i && (n.geometry = i);
     };
   } else {
     if (!le)
       return;
-    te.prototype.raycast = le, le = null;
+    se.prototype.raycast = le, le = null;
   }
 }
 let le = null;
-function ht(n) {
-  const t = new me();
-  for (const e in n.attributes)
-    t.setAttribute(e, n.getAttribute(e));
-  return t.setIndex(n.getIndex()), t;
+function mt(o) {
+  const t = new Le();
+  for (const e in o.attributes)
+    t.setAttribute(e, o.getAttribute(e));
+  return t.setIndex(o.getIndex()), t;
 }
-const Z = new Array(), L = ue("debugprogressive");
-let ye, ee = -1;
-if (L) {
-  let n = function() {
-    ee += 1, ee >= t && (ee = -1), console.log(`Toggle LOD level [${ee}]`);
+const j = new Array(), y = de("debugprogressive");
+let me, te = -1;
+if (y) {
+  let o = function() {
+    te += 1, te >= t && (te = -1), console.log(`Toggle LOD level [${te}]`);
   }, t = 6;
   window.addEventListener("keyup", (e) => {
-    e.key === "p" && n(), e.key === "w" && (ye = !ye, console.log(`Toggle wireframe [${ye}]`));
-    const r = parseInt(e.key);
-    !isNaN(r) && r >= 0 && (ee = r, console.log(`Set LOD level to [${ee}]`));
+    e.key === "p" && o(), e.key === "w" && (me = !me, console.log(`Toggle wireframe [${me}]`));
+    const s = parseInt(e.key);
+    !isNaN(s) && s >= 0 && (te = s, console.log(`Set LOD level to [${te}]`));
   });
 }
-function ze(n) {
-  if (L)
-    if (Array.isArray(n))
-      for (const t of n)
-        ze(t);
+function qe(o) {
+  if (y)
+    if (Array.isArray(o))
+      for (const t of o)
+        qe(t);
     else
-      n && "wireframe" in n && (n.wireframe = ye === !0);
+      o && "wireframe" in o && (o.wireframe = me === !0);
 }
-const Y = "NEEDLE_progressive", _e = Symbol("needle-progressive-texture"), b = class {
+const X = "NEEDLE_progressive", Oe = Symbol("needle-progressive-texture"), O = class {
   constructor(t, e) {
-    d(this, "parser");
-    d(this, "url");
-    d(this, "_isLoadingMesh");
-    d(this, "loadMesh", (t) => {
-      var r, i;
+    u(this, "parser");
+    u(this, "url");
+    u(this, "_isLoadingMesh");
+    u(this, "loadMesh", (t) => {
+      var s, n;
       if (this._isLoadingMesh)
         return null;
-      const e = (i = (r = this.parser.json.meshes[t]) == null ? void 0 : r.extensions) == null ? void 0 : i[Y];
-      return e ? (this._isLoadingMesh = !0, this.parser.getDependency("mesh", t).then((o) => {
-        var s;
-        return this._isLoadingMesh = !1, o && b.registerMesh(this.url, e.guid, o, (s = e.lods) == null ? void 0 : s.length, 0, e), o;
+      const e = (n = (s = this.parser.json.meshes[t]) == null ? void 0 : s.extensions) == null ? void 0 : n[X];
+      return e ? (this._isLoadingMesh = !0, this.parser.getDependency("mesh", t).then((r) => {
+        var i;
+        return this._isLoadingMesh = !1, r && O.registerMesh(this.url, e.guid, r, (i = e.lods) == null ? void 0 : i.length, 0, e), r;
       })) : null;
     });
-    L && console.log("Progressive extension registered for", e), this.parser = t, this.url = e;
+    y && console.log("Progressive extension registered for", e), this.parser = t, this.url = e;
   }
   /** The name of the extension */
   get name() {
-    return Y;
+    return X;
   }
   static getMeshLODExtension(t) {
     const e = this.getAssignedLODInformation(t);
     return e != null && e.key ? this.lodInfos.get(e.key) : null;
   }
   static getPrimitiveIndex(t) {
-    var r;
-    const e = (r = this.getAssignedLODInformation(t)) == null ? void 0 : r.index;
+    var s;
+    const e = (s = this.getAssignedLODInformation(t)) == null ? void 0 : s.index;
     return e ?? -1;
   }
   static getMaterialMinMaxLODsCount(t, e) {
-    const r = this, i = "LODS:minmax", o = t[i];
-    if (o != null)
-      return o;
+    const s = this, n = "LODS:minmax", r = t[n];
+    if (r != null)
+      return r;
     if (e || (e = {
       min_count: 1 / 0,
       max_count: 0,
@@ -181,29 +221,29 @@ const Y = "NEEDLE_progressive", _e = Symbol("needle-progressive-texture"), b = c
     }), Array.isArray(t)) {
       for (const a of t)
         this.getMaterialMinMaxLODsCount(a, e);
-      return t[i] = e, e;
+      return t[n] = e, e;
     }
-    if (L === "verbose" && console.log("getMaterialMinMaxLODsCount", t), t.type === "ShaderMaterial" || t.type === "RawShaderMaterial") {
+    if (y === "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 == null ? void 0 : u.isTexture) === !0 && s(u, e);
+        const c = a.uniforms[l].value;
+        (c == null ? void 0 : c.isTexture) === !0 && i(c, e);
       }
     } else if (t.isMaterial)
       for (const a of Object.keys(t)) {
         const l = t[a];
-        (l == null ? void 0 : l.isTexture) === !0 && s(l, e);
+        (l == null ? void 0 : l.isTexture) === !0 && i(l, e);
       }
-    return t[i] = e, e;
-    function s(a, l) {
-      const u = r.getAssignedLODInformation(a);
-      if (u) {
-        const c = r.lodInfos.get(u.key);
-        if (c && c.lods) {
-          l.min_count = Math.min(l.min_count, c.lods.length), l.max_count = Math.max(l.max_count, c.lods.length);
-          for (let h = 0; h < c.lods.length; h++) {
-            const g = c.lods[h];
-            g.width && (l.lods[h] = l.lods[h] || { min_height: 1 / 0, max_height: 0 }, l.lods[h].min_height = Math.min(l.lods[h].min_height, g.height), l.lods[h].max_height = Math.max(l.lods[h].max_height, g.height));
+    return t[n] = e, e;
+    function i(a, l) {
+      const c = s.getAssignedLODInformation(a);
+      if (c) {
+        const d = s.lodInfos.get(c.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 h = 0; h < d.lods.length; h++) {
+            const f = d.lods[h];
+            f.width && (l.lods[h] = l.lods[h] || { min_height: 1 / 0, max_height: 0 }, l.lods[h].min_height = Math.min(l.lods[h].min_height, f.height), l.lods[h].max_height = Math.max(l.lods[h].max_height, f.height));
           }
         }
       }
@@ -215,32 +255,32 @@ const Y = "NEEDLE_progressive", _e = Symbol("needle-progressive-texture"), b = c
    * @returns true if the LOD level is available (or if any LOD level is available if level is undefined)
    */
   static hasLODLevelAvailable(t, e) {
-    var o;
+    var r;
     if (Array.isArray(t)) {
-      for (const s of t)
-        if (this.hasLODLevelAvailable(s, e))
+      for (const i of t)
+        if (this.hasLODLevelAvailable(i, e))
           return !0;
       return !1;
     }
     if (t.isMaterial === !0) {
-      for (const s of Object.keys(t)) {
-        const a = t[s];
+      for (const i of Object.keys(t)) {
+        const a = t[i];
         if (a && a.isTexture && this.hasLODLevelAvailable(a, e))
           return !0;
       }
       return !1;
     } else if (t.isGroup === !0) {
-      for (const s of t.children)
-        if (s.isMesh === !0 && this.hasLODLevelAvailable(s, e))
+      for (const i of t.children)
+        if (i.isMesh === !0 && this.hasLODLevelAvailable(i, e))
           return !0;
     }
-    let r, i;
-    if (t.isMesh ? r = t.geometry : (t.isBufferGeometry || t.isTexture) && (r = t), r && (o = r == null ? void 0 : r.userData) != null && o.LODS) {
-      const s = r.userData.LODS;
-      if (i = this.lodInfos.get(s.key), e === void 0)
-        return i != null;
-      if (i)
-        return Array.isArray(i.lods) ? e < i.lods.length : e === 0;
+    let s, n;
+    if (t.isMesh ? s = t.geometry : (t.isBufferGeometry || t.isTexture) && (s = t), s && (r = s == null ? void 0 : s.userData) != null && r.LODS) {
+      const i = s.userData.LODS;
+      if (n = this.lodInfos.get(i.key), e === void 0)
+        return n != null;
+      if (n)
+        return Array.isArray(n.lods) ? e < n.lods.length : e === 0;
     }
     return !1;
   }
@@ -259,369 +299,469 @@ const Y = "NEEDLE_progressive", _e = Symbol("needle-progressive-texture"), b = c
    * ```
    */
   static assignMeshLOD(t, e) {
-    var r;
+    var s;
     if (!t)
       return Promise.resolve(null);
-    if (t instanceof te || t.isMesh === !0) {
-      const i = t.geometry, o = this.getAssignedLODInformation(i);
-      if (!o)
+    if (t instanceof se || t.isMesh === !0) {
+      const n = t.geometry, r = this.getAssignedLODInformation(n);
+      if (!r)
         return Promise.resolve(null);
-      for (const s of Z)
-        (r = s.onBeforeGetLODMesh) == null || r.call(s, t, e);
-      return t["LOD:requested level"] = e, b.getOrLoadLOD(i, e).then((s) => {
-        if (Array.isArray(s)) {
-          const a = o.index || 0;
-          s = s[a];
+      for (const i of j)
+        (s = i.onBeforeGetLODMesh) == null || s.call(i, t, e);
+      return t["LOD:requested level"] = e, O.getOrLoadLOD(n, e).then((i) => {
+        if (Array.isArray(i)) {
+          const a = r.index || 0;
+          i = i[a];
         }
-        return t["LOD:requested level"] === e && (delete t["LOD:requested level"], s && i != s && ((s == null ? void 0 : s.isBufferGeometry) ? t.geometry = s : L && console.error("Invalid LOD geometry", s))), s;
-      }).catch((s) => (console.error("Error loading mesh LOD", t, s), null));
+        return t["LOD:requested level"] === e && (delete t["LOD:requested level"], i && n != i && ((i == null ? void 0 : i.isBufferGeometry) ? t.geometry = i : y && console.error("Invalid LOD geometry", i))), i;
+      }).catch((i) => (console.error("Error loading mesh LOD", t, i), null));
     } else
-      L && console.error("Invalid call to assignMeshLOD: Request mesh LOD but the object is not a mesh", t);
+      y && 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) {
     if (!t)
       return Promise.resolve(null);
     if (t.isMesh === !0) {
-      const r = t;
-      if (Array.isArray(r.material)) {
-        const i = new Array();
-        for (const o of r.material) {
-          const s = this.assignTextureLOD(o, e);
-          i.push(s);
+      const s = t;
+      if (Array.isArray(s.material)) {
+        const n = new Array();
+        for (const r of s.material) {
+          const i = this.assignTextureLOD(r, e);
+          n.push(i);
         }
-        return Promise.all(i).then((o) => {
-          const s = new Array();
-          for (const a of o)
-            Array.isArray(a) && s.push(...a);
-          return s;
+        return Promise.all(n).then((r) => {
+          const i = new Array();
+          for (const a of r)
+            Array.isArray(a) && i.push(...a);
+          return i;
         });
       } else
-        return this.assignTextureLOD(r.material, e);
+        return this.assignTextureLOD(s.material, e);
     }
     if (t.isMaterial === !0) {
-      const r = t, i = [], o = new Array();
-      if (r.uniforms && (r.isRawShaderMaterial || r.isShaderMaterial === !0)) {
-        const s = r;
-        for (const a of Object.keys(s.uniforms)) {
-          const l = s.uniforms[a].value;
+      const s = t, n = [], r = new Array();
+      if (s.uniforms && (s.isRawShaderMaterial || s.isShaderMaterial === !0)) {
+        const i = s;
+        for (const a of Object.keys(i.uniforms)) {
+          const l = i.uniforms[a].value;
           if ((l == null ? void 0 : l.isTexture) === !0) {
-            const u = this.assignTextureLODForSlot(l, e, r, a).then((c) => (c && s.uniforms[a].value != c && (s.uniforms[a].value = c, s.uniformsNeedUpdate = !0), c));
-            i.push(u), o.push(a);
+            const c = this.assignTextureLODForSlot(l, e, s, a).then((d) => (d && i.uniforms[a].value != d && (i.uniforms[a].value = d, i.uniformsNeedUpdate = !0), d));
+            n.push(c), r.push(a);
           }
         }
       } else
-        for (const s of Object.keys(r)) {
-          const a = r[s];
+        for (const i of Object.keys(s)) {
+          const a = s[i];
           if ((a == null ? void 0 : a.isTexture) === !0) {
-            const l = this.assignTextureLODForSlot(a, e, r, s);
-            i.push(l), o.push(s);
+            const l = this.assignTextureLODForSlot(a, e, s, i);
+            n.push(l), r.push(i);
           }
         }
-      return Promise.all(i).then((s) => {
+      return Promise.all(n).then((i) => {
         const a = new Array();
-        for (let l = 0; l < s.length; l++) {
-          const u = s[l], c = o[l];
-          u && u.isTexture === !0 ? a.push({ material: r, slot: c, texture: u, level: e }) : a.push({ material: r, slot: c, texture: null, level: e });
+        for (let l = 0; l < i.length; l++) {
+          const c = i[l], d = r[l];
+          c && c.isTexture === !0 ? a.push({ material: s, slot: d, texture: c, level: e }) : a.push({ material: s, slot: d, texture: null, level: e });
         }
         return a;
       });
     }
-    if (t instanceof ne || t.isTexture === !0) {
-      const r = t;
-      return this.assignTextureLODForSlot(r, e, null, null);
+    if (t instanceof oe || t.isTexture === !0) {
+      const s = t;
+      return this.assignTextureLODForSlot(s, e, null, null);
     }
     return Promise.resolve(null);
   }
-  static assignTextureLODForSlot(t, e, r, i) {
-    return (t == null ? void 0 : t.isTexture) !== !0 ? Promise.resolve(null) : i === "glyphMap" ? Promise.resolve(t) : b.getOrLoadLOD(t, e).then((o) => {
-      if (Array.isArray(o))
-        return null;
-      if ((o == null ? void 0 : o.isTexture) === !0) {
-        if (o != t && r && i) {
-          const s = r[i];
-          if (s && !L) {
-            const a = this.getAssignedLODInformation(s);
+  static assignTextureLODForSlot(t, e, s, n) {
+    return (t == null ? void 0 : t.isTexture) !== !0 ? Promise.resolve(null) : n === "glyphMap" ? Promise.resolve(t) : O.getOrLoadLOD(t, e).then((r) => {
+      if (Array.isArray(r))
+        return console.warn("Progressive: Got an array of textures for a texture slot, this should not happen", r), null;
+      if ((r == null ? void 0 : r.isTexture) === !0) {
+        if (r != t && s && n) {
+          const i = s[n];
+          if (i && !y) {
+            const a = this.getAssignedLODInformation(i);
             if (a && (a == null ? void 0 : a.level) < e)
-              return L === "verbose" && console.warn("Assigned texture level is already higher: ", a.level, e, r, s, o), null;
+              return y === "verbose" && console.warn("Assigned texture level is already higher: ", a.level, e, s, i, r), null;
           }
-          r[i] = o;
+          s[n] = r;
         }
-        return o;
+        return r;
       } else
-        L == "verbose" && console.warn("No LOD found for", t, e);
+        y == "verbose" && console.warn("No LOD found for", t, e);
       return null;
-    }).catch((o) => (console.error("Error loading LOD", t, o), null));
+    }).catch((r) => (console.error("Error loading LOD", t, r), null));
   }
+  // private _isLoadingTexture;
+  // loadTexture = (textureIndex: number) => {
+  //     if (this._isLoadingTexture) return null;
+  //     const ext = this.parser.json.textures[textureIndex]?.extensions?.[EXTENSION_NAME] as NEEDLE_ext_progressive_texture;
+  //     if (!ext) return null;
+  //     this._isLoadingTexture = true;
+  //     return this.parser.getDependency("texture", textureIndex).then(tex => {
+  //         this._isLoadingTexture = false;
+  //         if (tex) {
+  //             NEEDLE_progressive.registerTexture(this.url, tex as Texture, ext.lods?.length, textureIndex, ext);
+  //         }
+  //         return tex;
+  //     });
+  // }
   afterRoot(t) {
-    var e, r;
-    return L && console.log("AFTER", this.url, t), (e = this.parser.json.textures) == null || e.forEach((i, o) => {
-      var s;
-      if (i != null && i.extensions) {
-        const a = i == null ? void 0 : i.extensions[Y];
+    var e, s;
+    return y && console.log("AFTER", this.url, t), (e = this.parser.json.textures) == null || e.forEach((n, r) => {
+      var i;
+      if (n != null && n.extensions) {
+        const a = n == null ? void 0 : n.extensions[X];
         if (a) {
           if (!a.lods) {
-            L && console.warn("Texture has no LODs", a);
+            y && console.warn("Texture has no LODs", a);
             return;
           }
           let l = !1;
-          for (const u of this.parser.associations.keys())
-            if (u.isTexture === !0) {
-              const c = this.parser.associations.get(u);
-              (c == null ? void 0 : c.textures) === o && (l = !0, b.registerTexture(this.url, u, (s = a.lods) == null ? void 0 : s.length, o, a));
+          for (const c of this.parser.associations.keys())
+            if (c.isTexture === !0) {
+              const d = this.parser.associations.get(c);
+              (d == null ? void 0 : d.textures) === r && (l = !0, O.registerTexture(this.url, c, (i = a.lods) == null ? void 0 : i.length, r, a));
             }
-          l || this.parser.getDependency("texture", o).then((u) => {
-            var c;
-            u && b.registerTexture(this.url, u, (c = a.lods) == null ? void 0 : c.length, o, a);
+          l || this.parser.getDependency("texture", r).then((c) => {
+            var d;
+            c && O.registerTexture(this.url, c, (d = a.lods) == null ? void 0 : d.length, r, a);
           });
         }
       }
-    }), (r = this.parser.json.meshes) == null || r.forEach((i, o) => {
-      if (i != null && i.extensions) {
-        const s = i == null ? void 0 : i.extensions[Y];
-        if (s && s.lods) {
+    }), (s = this.parser.json.meshes) == null || s.forEach((n, r) => {
+      if (n != null && n.extensions) {
+        const i = n == null ? void 0 : n.extensions[X];
+        if (i && i.lods) {
           for (const a of this.parser.associations.keys())
             if (a.isMesh) {
               const l = this.parser.associations.get(a);
-              (l == null ? void 0 : l.meshes) === o && b.registerMesh(this.url, s.guid, a, s.lods.length, l.primitives, s);
+              (l == null ? void 0 : l.meshes) === r && O.registerMesh(this.url, i.guid, a, i.lods.length, l.primitives, i);
             }
         }
       }
     }), null;
   }
   static async getOrLoadLOD(t, e) {
-    var a, l, u, c;
-    const r = L == "verbose", i = t.userData.LODS;
-    if (!i)
-      return null;
-    const o = i == null ? void 0 : i.key;
-    let s;
+    var a, l, c, d;
+    const s = y == "verbose", n = this.getAssignedLODInformation(t);
+    if (!n)
+      return y && console.warn(`[gltf-progressive] No LOD information found: ${t.name}, uuid: ${t.uuid}, type: ${t.type}`, t), null;
+    const r = n == null ? void 0 : n.key;
+    let i;
     if (t.isTexture === !0) {
       const h = t;
-      h.source && h.source[_e] && (s = h.source[_e]);
+      h.source && h.source[Oe] && (i = h.source[Oe]);
     }
-    if (s || (s = b.lodInfos.get(o)), s) {
+    if (i || (i = O.lodInfos.get(r)), i) {
       if (e > 0) {
-        let D = !1;
-        const _ = Array.isArray(s.lods);
-        if (_ && e >= s.lods.length ? D = !0 : _ || (D = !0), D)
-          return this.lowresCache.get(o);
+        let w = !1;
+        const v = Array.isArray(i.lods);
+        if (v && e >= i.lods.length ? w = !0 : v || (w = !0), w)
+          return this.lowresCache.get(r);
       }
-      const h = Array.isArray(s.lods) ? (a = s.lods[e]) == null ? void 0 : a.path : s.lods;
+      const h = Array.isArray(i.lods) ? (a = i.lods[e]) == null ? void 0 : a.path : i.lods;
       if (!h)
-        return L && !s["missing:uri"] && (s["missing:uri"] = !0, console.warn("Missing uri for progressive asset for LOD " + e, s)), null;
-      const g = lt(i.url, h);
-      if (g.endsWith(".glb") || g.endsWith(".gltf")) {
-        if (!s.guid)
-          return console.warn("missing pointer for glb/gltf texture", s), null;
-        const D = g + "_" + s.guid, _ = this.previouslyLoaded.get(D);
-        if (_ !== void 0) {
-          r && console.log(`LOD ${e} was already loading/loaded: ${D}`);
-          let M = await _.catch((p) => (console.error(`Error loading LOD ${e} from ${g}
-`, p), null)), w = !1;
-          if (M == null || (M instanceof ne && t instanceof ne ? (l = M.image) != null && l.data || (u = M.source) != null && u.data ? M = this.copySettings(t, M) : (w = !0, this.previouslyLoaded.delete(D)) : M instanceof me && t instanceof me && ((c = M.attributes.position) != null && c.array || (w = !0, this.previouslyLoaded.delete(D)))), !w)
-            return M;
+        return y && !i["missing:uri"] && (i["missing:uri"] = !0, console.warn("Missing uri for progressive asset for LOD " + e, i)), null;
+      const f = dt(n.url, h);
+      if (f.endsWith(".glb") || f.endsWith(".gltf")) {
+        if (!i.guid)
+          return console.warn("missing pointer for glb/gltf texture", i), null;
+        const w = f + "_" + i.guid, v = this.previouslyLoaded.get(w);
+        if (v !== void 0) {
+          s && console.log(`LOD ${e} was already loading/loaded: ${w}`);
+          let g = await v.catch((E) => (console.error(`Error loading LOD ${e} from ${f}
+`, E), null)), x = !1;
+          if (g == null || (g instanceof oe && t instanceof oe ? (l = g.image) != null && l.data || (c = g.source) != null && c.data ? g = this.copySettings(t, g) : (x = !0, this.previouslyLoaded.delete(w)) : g instanceof Le && t instanceof Le && ((d = g.attributes.position) != null && d.array || (x = !0, this.previouslyLoaded.delete(w)))), !x)
+            return g;
         }
-        const x = s, N = new Promise(async (M, w) => {
-          const p = new Pe();
-          Fe(p), L && (await new Promise((O) => setTimeout(O, 1e3)), r && console.warn("Start loading (delayed) " + g, x.guid));
-          let q = g;
-          if (x && Array.isArray(x.lods)) {
-            const O = x.lods[e];
-            O.hash && (q += "?v=" + O.hash);
+        const P = await this.queue.slot(f);
+        if (!P.use)
+          return y && console.log(`LOD ${e} was aborted: ${f}`), null;
+        const M = i, R = new Promise(async (g, x) => {
+          const E = new Ce();
+          ze(E), y && (await new Promise((D) => setTimeout(D, 1e3)), s && console.warn("Start loading (delayed) " + f, M.guid));
+          let U = f;
+          if (M && Array.isArray(M.lods)) {
+            const D = M.lods[e];
+            D.hash && (U += "?v=" + D.hash);
           }
-          const P = await p.loadAsync(q).catch((O) => (console.error(`Error loading LOD ${e} from ${g}
-`, O), null));
-          if (!P)
-            return null;
-          const G = P.parser;
-          r && console.log("Loading finished " + g, x.guid);
-          let k = 0;
-          if (P.parser.json.textures) {
-            let O = !1;
-            for (const f of P.parser.json.textures) {
-              if (f != null && f.extensions) {
-                const S = f == null ? void 0 : f.extensions[Y];
-                if (S != null && S.guid && S.guid === x.guid) {
-                  O = !0;
+          const S = await E.loadAsync(U).catch((D) => (console.error(`Error loading LOD ${e} from ${f}
+`, D), g(null)));
+          if (!S)
+            return g(null);
+          const ee = S.parser;
+          s && console.log("Loading finished " + f, M.guid);
+          let I = 0;
+          if (S.parser.json.textures) {
+            let D = !1;
+            for (const m of S.parser.json.textures) {
+              if (m != null && m.extensions) {
+                const p = m == null ? void 0 : m.extensions[X];
+                if (p != null && p.guid && p.guid === M.guid) {
+                  D = !0;
                   break;
                 }
               }
-              k++;
+              I++;
             }
-            if (O) {
-              let f = await G.getDependency("texture", k);
-              return f && b.assignLODInformation(i.url, f, o, e, void 0), r && console.log('change "' + t.name + '" → "' + f.name + '"', g, k, f, D), t instanceof ne && (f = this.copySettings(t, f)), f && (f.guid = x.guid), M(f);
+            if (D) {
+              let m = await ee.getDependency("texture", I);
+              return m && O.assignLODInformation(n.url, m, r, e, void 0), s && console.log('change "' + t.name + '" → "' + m.name + '"', f, I, m, w), t instanceof oe && (m = this.copySettings(t, m)), m && (m.guid = M.guid), g(m);
             } else
-              L && console.warn("Could not find texture with guid", x.guid, P.parser.json);
+              y && console.warn("Could not find texture with guid", M.guid, S.parser.json);
           }
-          if (k = 0, P.parser.json.meshes) {
-            let O = !1;
-            for (const f of P.parser.json.meshes) {
-              if (f != null && f.extensions) {
-                const S = f == null ? void 0 : f.extensions[Y];
-                if (S != null && S.guid && S.guid === x.guid) {
-                  O = !0;
+          if (I = 0, S.parser.json.meshes) {
+            let D = !1;
+            for (const m of S.parser.json.meshes) {
+              if (m != null && m.extensions) {
+                const p = m == null ? void 0 : m.extensions[X];
+                if (p != null && p.guid && p.guid === M.guid) {
+                  D = !0;
                   break;
                 }
               }
-              k++;
+              I++;
             }
-            if (O) {
-              const f = await G.getDependency("mesh", k);
-              if (r && console.log(`Loaded Mesh "${f.name}"`, g, k, f, D), f.isMesh === !0) {
-                const S = f.geometry;
-                return b.assignLODInformation(i.url, S, o, e, 0), M(S);
+            if (D) {
+              const m = await ee.getDependency("mesh", I);
+              if (s && console.log(`Loaded Mesh "${m.name}"`, f, I, m, w), m.isMesh === !0) {
+                const p = m.geometry;
+                return O.assignLODInformation(n.url, p, r, e, 0), g(p);
               } else {
-                const S = new Array();
-                for (let m = 0; m < f.children.length; m++) {
-                  const v = f.children[m];
-                  if (v.isMesh === !0) {
-                    const C = v.geometry;
-                    b.assignLODInformation(i.url, C, o, e, m), S.push(C);
+                const p = new Array();
+                for (let _ = 0; _ < m.children.length; _++) {
+                  const $ = m.children[_];
+                  if ($.isMesh === !0) {
+                    const A = $.geometry;
+                    O.assignLODInformation(n.url, A, r, e, _), p.push(A);
                   }
                 }
-                return M(S);
+                return g(p);
               }
             } else
-              L && console.warn("Could not find mesh with guid", x.guid, P.parser.json);
+              y && console.warn("Could not find mesh with guid", M.guid, S.parser.json);
           }
-          return M(null);
+          return g(null);
         });
-        return this.previouslyLoaded.set(D, N), await N;
-      } else if (t instanceof ne) {
-        r && console.log("Load texture from uri: " + g);
-        const _ = await new He().loadAsync(g);
-        return _ ? (_.guid = s.guid, _.flipY = !1, _.needsUpdate = !0, _.colorSpace = t.colorSpace, r && console.log(s, _)) : L && console.warn("failed loading", g), _;
+        return this.previouslyLoaded.set(w, R), P.use(R), await R;
+      } else if (t instanceof oe) {
+        s && console.log("Load texture from uri: " + f);
+        const v = await new je().loadAsync(f);
+        return v ? (v.guid = i.guid, v.flipY = !1, v.needsUpdate = !0, v.colorSpace = t.colorSpace, s && console.log(i, v)) : y && console.warn("failed loading", f), v;
       }
     } else
-      L && console.warn(`Can not load LOD ${e}: no LOD info found for "${o}" ${t.name}`, t.type);
+      y && console.warn(`Can not load LOD ${e}: no LOD info found for "${r}" ${t.name}`, t.type);
     return null;
   }
-  static assignLODInformation(t, e, r, i, o) {
+  static assignLODInformation(t, e, s, n, r) {
     if (!e)
       return;
     e.userData || (e.userData = {});
-    const s = new gt(t, r, i, o);
-    e.userData.LODS = s;
+    const i = new yt(t, s, n, r);
+    e.userData.LODS = i, "source" in e && typeof e.source == "object" && (e.source.LODS = i);
   }
   static getAssignedLODInformation(t) {
-    var e;
-    return ((e = t == null ? void 0 : t.userData) == null ? void 0 : e.LODS) || null;
+    var e, s;
+    return t ? (e = t.userData) != null && e.LODS ? t.userData.LODS : "source" in t && ((s = t.source) != null && s.LODS) ? t.source.LODS : null : null;
   }
   // private static readonly _copiedTextures: WeakMap<Texture, Texture> = new Map();
   static copySettings(t, e) {
-    return e ? (L && console.warn(`Copy texture settings
+    return e ? (y && console.warn(`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;
   }
 };
-let A = b;
+let T = O;
 /**
  * Register a texture with LOD information
  */
-d(A, "registerTexture", (t, e, r, i, o) => {
-  if (L && console.log("> Progressive: register texture", i, e.name, e.uuid, e, o), !e) {
-    L && console.error("gltf-progressive: Register texture without texture");
+u(T, "registerTexture", (t, e, s, n, r) => {
+  var a, l, c, d, h, f, w, v;
+  if (!e) {
+    y && console.error("gltf-progressive: Called register texture without texture");
     return;
   }
-  e.source && (e.source[_e] = o);
-  const s = o.guid;
-  b.assignLODInformation(t, e, s, r, i), b.lodInfos.set(s, o), b.lowresCache.set(s, e);
+  if (y) {
+    const P = ((a = e.image) == null ? void 0 : a.width) || ((c = (l = e.source) == null ? void 0 : l.data) == null ? void 0 : c.width) || 0, M = ((d = e.image) == null ? void 0 : d.height) || ((f = (h = e.source) == null ? void 0 : h.data) == null ? void 0 : f.height) || 0;
+    console.log(`> Progressive: register texture[${n}] "${e.name || e.uuid}", Current: ${P}x${M}, Max: ${(w = r.lods[0]) == null ? void 0 : w.width}x${(v = r.lods[0]) == null ? void 0 : v.height}, uuid: ${e.uuid}`, r, e);
+  }
+  e.source && (e.source[Oe] = r);
+  const i = r.guid;
+  O.assignLODInformation(t, e, i, s, n), O.lodInfos.set(i, r), O.lowresCache.set(i, e);
 }), /**
  * Register a mesh with LOD information
  */
-d(A, "registerMesh", (t, e, r, i, o, s) => {
-  var u;
-  const a = r.geometry;
+u(T, "registerMesh", (t, e, s, n, r, i) => {
+  var c;
+  const a = s.geometry;
   if (!a) {
-    L && console.warn("gltf-progressive: Register mesh without geometry");
+    y && console.warn("gltf-progressive: Register mesh without geometry");
     return;
   }
-  a.userData || (a.userData = {}), L && console.log("> Progressive: register mesh " + r.name, { index: o, uuid: r.uuid }, s, r), b.assignLODInformation(t, a, e, i, o), b.lodInfos.set(e, s);
-  let l = b.lowresCache.get(e);
-  l ? l.push(r.geometry) : l = [r.geometry], b.lowresCache.set(e, l), i > 0 && !de(r) && dt(r, a);
-  for (const c of Z)
-    (u = c.onRegisteredNewMesh) == null || u.call(c, r, s);
+  a.userData || (a.userData = {}), y && console.log("> Progressive: register mesh " + s.name, { index: r, uuid: s.uuid }, i, s), O.assignLODInformation(t, a, e, n, r), O.lodInfos.set(e, i);
+  let l = O.lowresCache.get(e);
+  l ? l.push(s.geometry) : l = [s.geometry], O.lowresCache.set(e, l), n > 0 && !ce(s) && gt(s, a);
+  for (const d of j)
+    (c = d.onRegisteredNewMesh) == null || c.call(d, s, i);
 }), /** A map of key = asset uuid and value = LOD information */
-d(A, "lodInfos", /* @__PURE__ */ new Map()), /** cache of already loaded mesh lods */
-d(A, "previouslyLoaded", /* @__PURE__ */ new Map()), /** this contains the geometry/textures that were originally loaded */
-d(A, "lowresCache", /* @__PURE__ */ new Map());
-class gt {
-  constructor(t, e, r, i) {
-    d(this, "url");
+u(T, "lodInfos", /* @__PURE__ */ new Map()), /** cache of already loaded mesh lods */
+u(T, "previouslyLoaded", /* @__PURE__ */ new Map()), /** this contains the geometry/textures that were originally loaded */
+u(T, "lowresCache", /* @__PURE__ */ new Map()), u(T, "queue", new ft(100, { debug: y != !1 }));
+class yt {
+  constructor(t, e, s, n) {
+    u(this, "url");
     /** the key to lookup the LOD information */
-    d(this, "key");
-    d(this, "level");
+    u(this, "key");
+    u(this, "level");
     /** For multi objects (e.g. a group of meshes) this is the index of the object */
-    d(this, "index");
-    this.url = t, this.key = e, this.level = r, i != null && (this.index = i);
+    u(this, "index");
+    this.url = t, this.key = e, this.level = s, n != null && (this.index = n);
+  }
+}
+class ye {
+  constructor(t, e) {
+    u(this, "frame_start");
+    u(this, "frame_capture_end");
+    u(this, "ready");
+    u(this, "_resolve");
+    u(this, "_signal");
+    u(this, "_resolved", !1);
+    u(this, "_addedCount", 0);
+    u(this, "_resolvedCount", 0);
+    /** These promises are currently being awaited */
+    u(this, "_awaiting", []);
+    u(this, "_maxPromisesPerObject", 1);
+    u(this, "_currentFrame", 0);
+    u(this, "_seen", /* @__PURE__ */ new WeakMap());
+    var r;
+    const n = Math.max(e.frames ?? 2, 2);
+    this.frame_start = t, this.frame_capture_end = t + n, this.ready = new Promise((i) => {
+      this._resolve = i;
+    }), this.ready.finally(() => {
+      this._resolved = !0, this._awaiting.length = 0;
+    }), this._signal = e.signal, (r = this._signal) == null || r.addEventListener("abort", () => {
+      this.resolveNow();
+    }), this._maxPromisesPerObject = Math.max(1, e.maxPromisesPerObject ?? 1);
+  }
+  /**
+   * The number of promises that have been added to this group so far.
+   */
+  get awaitedCount() {
+    return this._addedCount;
+  }
+  get resolvedCount() {
+    return this._resolvedCount;
+  }
+  get currentlyAwaiting() {
+    return this._awaiting.length;
+  }
+  update(t) {
+    var e;
+    this._currentFrame = t, ((e = this._signal) != null && e.aborted || this._currentFrame > this.frame_capture_end && this._awaiting.length === 0) && this.resolveNow();
+  }
+  add(t, e, s) {
+    if (this._resolved) {
+      y && console.warn("PromiseGroup: Trying to add a promise to a resolved group, ignoring.");
+      return;
+    }
+    if (!(this._currentFrame > this.frame_capture_end)) {
+      if (this._maxPromisesPerObject >= 1)
+        if (this._seen.has(e)) {
+          let n = this._seen.get(e);
+          if (n >= this._maxPromisesPerObject) {
+            y && console.warn("PromiseGroup: Already awaiting object ignoring new promise for it.");
+            return;
+          }
+          this._seen.set(e, n + 1);
+        } else
+          this._seen.set(e, 1);
+      this._awaiting.push(s), this._addedCount++, s.finally(() => {
+        this._resolvedCount++, this._awaiting.splice(this._awaiting.indexOf(s), 1);
+      });
+    }
+  }
+  resolveNow() {
+    var t, e;
+    this._resolved || (e = this._resolve) == null || e.call(this, {
+      awaited_count: this._addedCount,
+      resolved_count: this._resolvedCount,
+      cancelled: ((t = this._signal) == null ? void 0 : t.aborted) ?? !1
+    });
   }
 }
-const U = ue("debugprogressive"), pt = ue("noprogressive"), Oe = Symbol("Needle:LODSManager"), be = Symbol("Needle:LODState"), Q = Symbol("Needle:CurrentLOD"), E = { mesh_lod: -1, texture_lod: -1 };
-var B, H, xe, se, oe, De, j;
-const T = class {
+u(ye, "addPromise", (t, e, s, n) => {
+  n.forEach((r) => {
+    r.add(t, e, s);
+  });
+});
+const F = de("debugprogressive"), Lt = de("noprogressive"), be = Symbol("Needle:LODSManager"), Se = Symbol("Needle:LODState"), Q = Symbol("Needle:CurrentLOD"), G = { mesh_lod: -1, texture_lod: -1 };
+var B, K, we, J, ie, _e, Y;
+const b = class {
   // readonly plugins: NEEDLE_progressive_plugin[] = [];
   constructor(t, e) {
-    d(this, "context");
-    d(this, "renderer");
-    d(this, "projectionScreenMatrix", new Ee());
+    u(this, "renderer");
+    u(this, "context");
+    u(this, "projectionScreenMatrix", new Ie());
     /**
      * The target triangle density is the desired max amount of triangles on screen when the mesh is filling the screen.  
      * @default 200_000
      */
-    d(this, "targetTriangleDensity", 2e5);
+    u(this, "targetTriangleDensity", 2e5);
     /**
      * The interval in frames to automatically update the bounds of skinned meshes.   
      * Set to 0 or a negative value to disable automatic bounds updates. 
      * @default 30
      */
-    d(this, "skinnedMeshAutoUpdateBoundsInterval", 30);
+    u(this, "skinnedMeshAutoUpdateBoundsInterval", 30);
     /**
      * The update interval in frames. If set to 0, the LODs will be updated every frame. If set to 2, the LODs will be updated every second frame, etc.
      * @default "auto"
      */
-    d(this, "updateInterval", "auto");
-    J(this, B, 1);
+    u(this, "updateInterval", "auto");
+    H(this, B, 1);
     /**
      * If set to true, the LODsManager will not update the LODs.
      * @default false
      */
-    d(this, "pause", !1);
+    u(this, "pause", !1);
     /**
      * When set to true the LODsManager will not update the LODs. This can be used to manually update the LODs using the `update` method.  
      * Otherwise the LODs will be updated automatically when the renderer renders the scene.
      * @default false
      */
-    d(this, "manual", !1);
-    d(this, "_lodchangedlisteners", []);
-    J(this, H, void 0);
-    J(this, xe, new je());
-    J(this, se, 0);
-    J(this, oe, 0);
-    J(this, De, 0);
-    J(this, j, 0);
-    d(this, "_fpsBuffer", [60, 60, 60, 60, 60]);
+    u(this, "manual", !1);
+    u(this, "_newPromiseGroups", []);
+    u(this, "_promiseGroupIds", 0);
+    u(this, "_lodchangedlisteners", []);
+    H(this, K, void 0);
+    H(this, we, new Je());
+    H(this, J, 0);
+    H(this, ie, 0);
+    H(this, _e, 0);
+    H(this, Y, 0);
+    u(this, "_fpsBuffer", [60, 60, 60, 60, 60]);
     // private testIfLODLevelsAreAvailable() {
-    d(this, "_sphere", new Qe());
-    d(this, "_tempBox", new Be());
-    d(this, "_tempBox2", new Be());
-    d(this, "tempMatrix", new Ee());
-    d(this, "_tempWorldPosition", new K());
-    d(this, "_tempBoxSize", new K());
-    d(this, "_tempBox2Size", new K());
+    u(this, "_sphere", new et());
+    u(this, "_tempBox", new $e());
+    u(this, "_tempBox2", new $e());
+    u(this, "tempMatrix", new Ie());
+    u(this, "_tempWorldPosition", new W());
+    u(this, "_tempBoxSize", new W());
+    u(this, "_tempBox2Size", new W());
     this.renderer = t, this.context = { ...e };
   }
   /** @internal */
   static getObjectLODState(t) {
-    return t[be];
+    return t[Se];
   }
   static addPlugin(t) {
-    Z.push(t);
+    j.push(t);
   }
   static removePlugin(t) {
-    const e = Z.indexOf(t);
-    e >= 0 && Z.splice(e, 1);
+    const e = j.indexOf(t);
+    e >= 0 && j.splice(e, 1);
   }
   /**
    * Gets the LODsManager for the given renderer. If the LODsManager does not exist yet, it will be created.  
@@ -629,79 +769,99 @@ const T = class {
    * @returns The LODsManager instance.
    */
   static get(t, e) {
-    if (t[Oe])
-      return console.debug("[gltf-progressive] LODsManager already exists for this renderer"), t[Oe];
-    const r = new T(t, {
+    if (t[be])
+      return console.debug("[gltf-progressive] LODsManager already exists for this renderer"), t[be];
+    const s = new b(t, {
       engine: "unknown",
       ...e
     });
-    return t[Oe] = r, r;
+    return t[be] = s, s;
   }
   /** @deprecated use static `LODsManager.addPlugin()` method. This getter will be removed in later versions */
   get plugins() {
-    return Z;
+    return j;
+  }
+  /**
+   * Call to await LODs loading during the next render cycle.
+   */
+  awaitLoading(t) {
+    const e = this._promiseGroupIds++, s = new ye(L(this, J), { ...t });
+    this._newPromiseGroups.push(s);
+    const n = performance.now();
+    return s.ready.finally(() => {
+      const r = this._newPromiseGroups.indexOf(s);
+      r >= 0 && (this._newPromiseGroups.splice(r, 1), Ge() && performance.measure("LODsManager:awaitLoading", {
+        start: n,
+        detail: { id: e, name: t == null ? void 0 : t.name, awaited: s.awaitedCount, resolved: s.resolvedCount }
+      }));
+    }), s.ready;
+  }
+  _postprocessPromiseGroups() {
+    if (this._newPromiseGroups.length !== 0)
+      for (let t = this._newPromiseGroups.length - 1; t >= 0; t--)
+        this._newPromiseGroups[t].update(L(this, J));
   }
   addEventListener(t, e) {
     t === "changed" && this._lodchangedlisteners.push(e);
   }
   removeEventListener(t, e) {
     if (t === "changed") {
-      const r = this._lodchangedlisteners.indexOf(e);
-      r >= 0 && this._lodchangedlisteners.splice(r, 1);
+      const s = this._lodchangedlisteners.indexOf(e);
+      s >= 0 && this._lodchangedlisteners.splice(s, 1);
     }
   }
   /**
    * Enable the LODsManager. This will replace the render method of the renderer with a method that updates the LODs.
    */
   enable() {
-    if (y(this, H))
+    if (L(this, K))
       return;
     console.debug("[gltf-progressive] Enabling LODsManager for renderer");
     let t = 0;
-    V(this, H, this.renderer.render);
+    V(this, K, this.renderer.render);
     const e = this;
-    Ue(this.renderer), this.renderer.render = function(r, i) {
-      const o = e.renderer.getRenderTarget();
-      (o == null || "isXRRenderTarget" in o && o.isXRRenderTarget) && (t = 0, V(e, se, y(e, se) + 1), V(e, oe, y(e, xe).getDelta()), V(e, De, y(e, De) + y(e, oe)), e._fpsBuffer.shift(), e._fpsBuffer.push(1 / y(e, oe)), V(e, j, e._fpsBuffer.reduce((a, l) => a + l) / e._fpsBuffer.length), U && y(e, se) % 200 === 0 && console.log("FPS", Math.round(y(e, j)), "Interval:", y(e, B)));
-      const s = t++;
-      y(e, H).call(this, r, i), e.onAfterRender(r, i, s);
+    Ue(this.renderer), this.renderer.render = function(s, n) {
+      const r = e.renderer.getRenderTarget();
+      (r == null || "isXRRenderTarget" in r && r.isXRRenderTarget) && (t = 0, V(e, J, L(e, J) + 1), V(e, ie, L(e, we).getDelta()), V(e, _e, L(e, _e) + L(e, ie)), e._fpsBuffer.shift(), e._fpsBuffer.push(1 / L(e, ie)), V(e, Y, e._fpsBuffer.reduce((a, l) => a + l) / e._fpsBuffer.length), F && L(e, J) % 200 === 0 && console.log("FPS", Math.round(L(e, Y)), "Interval:", L(e, B)));
+      const i = t++;
+      L(e, K).call(this, s, n), e.onAfterRender(s, n, i);
     };
   }
   disable() {
-    y(this, H) && (console.debug("[gltf-progressive] Disabling LODsManager for renderer"), this.renderer.render = y(this, H), V(this, H, void 0));
+    L(this, K) && (console.debug("[gltf-progressive] Disabling LODsManager for renderer"), this.renderer.render = L(this, K), V(this, K, void 0));
   }
   update(t, e) {
     this.internalUpdate(t, e);
   }
-  onAfterRender(t, e, r) {
+  onAfterRender(t, e, s) {
     if (this.pause)
       return;
-    const o = this.renderer.renderLists.get(t, 0).opaque;
-    let s = !0;
-    if (o.length === 1) {
-      const a = o[0].material;
-      (a.name === "EffectMaterial" || a.name === "CopyShader") && (s = !1);
+    const r = this.renderer.renderLists.get(t, 0).opaque;
+    let i = !0;
+    if (r.length === 1) {
+      const a = r[0].material;
+      (a.name === "EffectMaterial" || a.name === "CopyShader") && (i = !1);
     }
-    if ((e.parent && e.parent.type === "CubeCamera" || r >= 1 && e.type === "OrthographicCamera") && (s = !1), s) {
-      if (pt || (this.updateInterval === "auto" ? y(this, j) < 40 && y(this, B) < 10 ? (V(this, B, y(this, B) + 1), U && console.warn("↓ Reducing LOD updates", y(this, B), y(this, j).toFixed(0))) : y(this, j) >= 60 && y(this, B) > 1 && (V(this, B, y(this, B) - 1), U && console.warn("↑ Increasing LOD updates", y(this, B), y(this, j).toFixed(0))) : V(this, B, this.updateInterval), y(this, B) > 0 && y(this, se) % y(this, B) != 0))
+    if ((e.parent && e.parent.type === "CubeCamera" || s >= 1 && e.type === "OrthographicCamera") && (i = !1), i) {
+      if (Lt || (this.updateInterval === "auto" ? L(this, Y) < 40 && L(this, B) < 10 ? (V(this, B, L(this, B) + 1), F && console.warn("↓ Reducing LOD updates", L(this, B), L(this, Y).toFixed(0))) : L(this, Y) >= 60 && L(this, B) > 1 && (V(this, B, L(this, B) - 1), F && console.warn("↑ Increasing LOD updates", L(this, B), L(this, Y).toFixed(0))) : V(this, B, this.updateInterval), L(this, B) > 0 && L(this, J) % L(this, B) != 0))
         return;
-      this.internalUpdate(t, e);
+      this.internalUpdate(t, e), this._postprocessPromiseGroups();
     }
   }
   /**
    * Update LODs in a scene
    */
   internalUpdate(t, e) {
-    var l, u;
-    const r = this.renderer.renderLists.get(t, 0), i = r.opaque;
+    var l, c;
+    const s = this.renderer.renderLists.get(t, 0), n = s.opaque;
     this.projectionScreenMatrix.multiplyMatrices(e.projectionMatrix, e.matrixWorldInverse);
-    const o = this.targetTriangleDensity;
-    for (const c of i) {
-      if (c.material && (((l = c.geometry) == null ? void 0 : l.type) === "BoxGeometry" || ((u = c.geometry) == null ? void 0 : u.type) === "BufferGeometry") && (c.material.name === "SphericalGaussianBlur" || c.material.name == "BackgroundCubeMaterial" || c.material.name === "CubemapFromEquirect" || c.material.name === "EquirectangularToCubeUV")) {
-        U && (c.material["NEEDLE_PROGRESSIVE:IGNORE-WARNING"] || (c.material["NEEDLE_PROGRESSIVE:IGNORE-WARNING"] = !0, console.warn("Ignoring skybox or BLIT object", c, c.material.name, c.material.type)));
+    const r = this.targetTriangleDensity;
+    for (const d of n) {
+      if (d.material && (((l = d.geometry) == null ? void 0 : l.type) === "BoxGeometry" || ((c = d.geometry) == null ? void 0 : c.type) === "BufferGeometry") && (d.material.name === "SphericalGaussianBlur" || d.material.name == "BackgroundCubeMaterial" || d.material.name === "CubemapFromEquirect" || d.material.name === "EquirectangularToCubeUV")) {
+        F && (d.material["NEEDLE_PROGRESSIVE:IGNORE-WARNING"] || (d.material["NEEDLE_PROGRESSIVE:IGNORE-WARNING"] = !0, console.warn("Ignoring skybox or BLIT object", d, d.material.name, d.material.type)));
         continue;
       }
-      switch (c.material.type) {
+      switch (d.material.type) {
         case "LineBasicMaterial":
         case "LineDashedMaterial":
         case "PointsMaterial":
@@ -710,39 +870,39 @@ const T = class {
         case "MeshDepthMaterial":
           continue;
       }
-      if (U === "color" && c.material && !c.object.progressive_debug_color) {
-        c.object.progressive_debug_color = !0;
-        const g = Math.random() * 16777215, D = new Je({ color: g });
-        c.object.material = D;
+      if (F === "color" && d.material && !d.object.progressive_debug_color) {
+        d.object.progressive_debug_color = !0;
+        const f = Math.random() * 16777215, w = new Ze({ color: f });
+        d.object.material = w;
       }
-      const h = c.object;
-      (h instanceof te || h.isMesh) && this.updateLODs(t, e, h, o);
+      const h = d.object;
+      (h instanceof se || h.isMesh) && this.updateLODs(t, e, h, r);
     }
-    const s = r.transparent;
-    for (const c of s) {
-      const h = c.object;
-      (h instanceof te || h.isMesh) && this.updateLODs(t, e, h, o);
+    const i = s.transparent;
+    for (const d of i) {
+      const h = d.object;
+      (h instanceof se || h.isMesh) && this.updateLODs(t, e, h, r);
     }
-    const a = r.transmissive;
-    for (const c of a) {
-      const h = c.object;
-      (h instanceof te || h.isMesh) && this.updateLODs(t, e, h, o);
+    const a = s.transmissive;
+    for (const d of a) {
+      const h = d.object;
+      (h instanceof se || h.isMesh) && this.updateLODs(t, e, h, r);
     }
   }
   /** Update the LOD levels for the renderer. */
-  updateLODs(t, e, r, i) {
+  updateLODs(t, e, s, n) {
     var a, l;
-    r.userData || (r.userData = {});
-    let o = r[be];
-    if (o || (o = new yt(), r[be] = o), o.frames++ < 2)
+    s.userData || (s.userData = {});
+    let r = s[Se];
+    if (r || (r = new xt(), s[Se] = r), r.frames++ < 2)
       return;
-    for (const u of Z)
-      (a = u.onBeforeUpdateLOD) == null || a.call(u, this.renderer, t, e, r);
-    const s = T.overrideGlobalLodLevel !== void 0 ? T.overrideGlobalLodLevel : ee;
-    s >= 0 ? (E.mesh_lod = s, E.texture_lod = s) : (this.calculateLodLevel(e, r, o, i, E), E.mesh_lod = Math.round(E.mesh_lod), E.texture_lod = Math.round(E.texture_lod)), E.mesh_lod >= 0 && this.loadProgressiveMeshes(r, E.mesh_lod), r.material && E.texture_lod >= 0 && this.loadProgressiveTextures(r.material, E.texture_lod), L && r.material && !r.isGizmo && ze(r.material);
-    for (const u of Z)
-      (l = u.onAfterUpdatedLOD) == null || l.call(u, this.renderer, t, e, r, E);
-    o.lastLodLevel_Mesh = E.mesh_lod, o.lastLodLevel_Texture = E.texture_lod;
+    for (const c of j)
+      (a = c.onBeforeUpdateLOD) == null || a.call(c, this.renderer, t, e, s);
+    const i = b.overrideGlobalLodLevel !== void 0 ? b.overrideGlobalLodLevel : te;
+    i >= 0 ? (G.mesh_lod = i, G.texture_lod = i) : (this.calculateLodLevel(e, s, r, n, G), G.mesh_lod = Math.round(G.mesh_lod), G.texture_lod = Math.round(G.texture_lod)), G.mesh_lod >= 0 && this.loadProgressiveMeshes(s, G.mesh_lod), s.material && G.texture_lod >= 0 && this.loadProgressiveTextures(s.material, G.texture_lod), y && s.material && !s.isGizmo && qe(s.material);
+    for (const c of j)
+      (l = c.onAfterUpdatedLOD) == null || l.call(c, this.renderer, t, e, s, G);
+    r.lastLodLevel_Mesh = G.mesh_lod, r.lastLodLevel_Texture = G.texture_lod;
   }
   /** Load progressive textures for the given material
    * @param material the material to load the textures for
@@ -753,16 +913,20 @@ const T = class {
     if (!t)
       return;
     if (Array.isArray(t)) {
-      for (const o of t)
-        this.loadProgressiveTextures(o, e);
+      for (const r of t)
+        this.loadProgressiveTextures(r, e);
       return;
     }
-    let r = !1;
-    (t[Q] === void 0 || e < t[Q]) && (r = !0);
-    const i = t["DEBUG:LOD"];
-    i != null && (r = t[Q] != i, e = i), r && (t[Q] = e, A.assignTextureLOD(t, e).then((o) => {
-      this._lodchangedlisteners.forEach((s) => s({ type: "texture", level: e, object: t }));
-    }));
+    let s = !1;
+    (t[Q] === void 0 || e < t[Q]) && (s = !0);
+    const n = t["DEBUG:LOD"];
+    if (n != null && (s = t[Q] != n, e = n), s) {
+      t[Q] = e;
+      const r = T.assignTextureLOD(t, e).then((i) => {
+        this._lodchangedlisteners.forEach((a) => a({ type: "texture", level: e, object: t }));
+      });
+      ye.addPromise("texture", t, r, this._newPromiseGroups);
+    }
   }
   /** Load progressive meshes for the given mesh
    * @param mesh the mesh to load the LOD for
@@ -773,121 +937,128 @@ const T = class {
   loadProgressiveMeshes(t, e) {
     if (!t)
       return Promise.resolve(null);
-    let r = t[Q] !== e;
-    const i = t["DEBUG:LOD"];
-    if (i != null && (r = t[Q] != i, e = i), r) {
+    let s = t[Q] !== e;
+    const n = t["DEBUG:LOD"];
+    if (n != null && (s = t[Q] != n, e = n), s) {
       t[Q] = e;
-      const o = t.geometry;
-      return A.assignMeshLOD(t, e).then((s) => (s && t[Q] == e && o != t.geometry && this._lodchangedlisteners.forEach((a) => a({ type: "mesh", level: e, object: t })), s));
+      const r = t.geometry, i = T.assignMeshLOD(t, e).then((a) => (a && t[Q] == e && r != t.geometry && this._lodchangedlisteners.forEach((l) => l({ type: "mesh", level: e, object: t })), a));
+      return ye.addPromise("mesh", t, i, this._newPromiseGroups), i;
     }
     return Promise.resolve(null);
   }
   static isInside(t, e) {
-    const r = t.min, i = t.max, o = (r.x + i.x) * 0.5, s = (r.y + i.y) * 0.5;
-    return this._tempPtInside.set(o, s, r.z).applyMatrix4(e).z < 0;
+    const s = t.min, n = t.max, r = (s.x + n.x) * 0.5, i = (s.y + n.y) * 0.5;
+    return this._tempPtInside.set(r, i, s.z).applyMatrix4(e).z < 0;
   }
-  calculateLodLevel(t, e, r, i, o) {
-    var N, X, M;
+  calculateLodLevel(t, e, s, n, r) {
+    var M, R, Z;
     if (!e) {
-      o.mesh_lod = -1, o.texture_lod = -1;
+      r.mesh_lod = -1, r.texture_lod = -1;
       return;
     }
     if (!t) {
-      o.mesh_lod = -1, o.texture_lod = -1;
+      r.mesh_lod = -1, r.texture_lod = -1;
       return;
     }
     let a = 10 + 1, l = !1;
-    if (U && e["DEBUG:LOD"] != null)
+    if (F && e["DEBUG:LOD"] != null)
       return e["DEBUG:LOD"];
-    const u = (N = A.getMeshLODExtension(e.geometry)) == null ? void 0 : N.lods, c = A.getPrimitiveIndex(e.geometry), h = u && u.length > 0, g = A.getMaterialMinMaxLODsCount(e.material), D = (g == null ? void 0 : g.min_count) != 1 / 0 && g.min_count > 0 && g.max_count > 0;
-    if (!h && !D) {
-      o.mesh_lod = 0, o.texture_lod = 0;
+    const c = (M = T.getMeshLODExtension(e.geometry)) == null ? void 0 : M.lods, d = T.getPrimitiveIndex(e.geometry), h = c && c.length > 0, f = T.getMaterialMinMaxLODsCount(e.material), w = (f == null ? void 0 : f.min_count) != 1 / 0 && f.min_count > 0 && f.max_count > 0;
+    if (!h && !w) {
+      r.mesh_lod = 0, r.texture_lod = 0;
       return;
     }
     h || (l = !0, a = 0);
-    const _ = this.renderer.domElement.clientHeight || this.renderer.domElement.height;
-    let x = e.geometry.boundingBox;
+    const v = this.renderer.domElement.clientHeight || this.renderer.domElement.height;
+    let P = e.geometry.boundingBox;
     if (e.type === "SkinnedMesh") {
-      const w = e;
-      if (!w.boundingBox)
-        w.computeBoundingBox();
-      else if (this.skinnedMeshAutoUpdateBoundsInterval > 0 && r.frames % this.skinnedMeshAutoUpdateBoundsInterval === 0) {
-        const p = de(w), q = w.geometry;
-        p && (w.geometry = p), w.computeBoundingBox(), w.geometry = q;
+      const g = e;
+      if (!g.boundingBox)
+        g.computeBoundingBox();
+      else if (this.skinnedMeshAutoUpdateBoundsInterval > 0) {
+        if (!g[b.$skinnedMeshBoundsOffset]) {
+          const E = b.skinnedMeshBoundsFrameOffsetCounter++;
+          g[b.$skinnedMeshBoundsOffset] = E;
+        }
+        const x = g[b.$skinnedMeshBoundsOffset];
+        if ((s.frames + x) % this.skinnedMeshAutoUpdateBoundsInterval === 0) {
+          const E = ce(g), U = g.geometry;
+          E && (g.geometry = E), g.computeBoundingBox(), g.geometry = U;
+        }
       }
-      x = w.boundingBox;
+      P = g.boundingBox;
     }
-    if (x) {
-      const w = t;
+    if (P) {
+      const g = t;
       if (e.geometry.attributes.color && e.geometry.attributes.color.count < 100 && e.geometry.boundingSphere) {
         this._sphere.copy(e.geometry.boundingSphere), this._sphere.applyMatrix4(e.matrixWorld);
-        const m = t.getWorldPosition(this._tempWorldPosition);
-        if (this._sphere.containsPoint(m)) {
-          o.mesh_lod = 0, o.texture_lod = 0;
+        const p = t.getWorldPosition(this._tempWorldPosition);
+        if (this._sphere.containsPoint(p)) {
+          r.mesh_lod = 0, r.texture_lod = 0;
           return;
         }
       }
-      if (this._tempBox.copy(x), this._tempBox.applyMatrix4(e.matrixWorld), w.isPerspectiveCamera && T.isInside(this._tempBox, this.projectionScreenMatrix)) {
-        o.mesh_lod = 0, o.texture_lod = 0;
+      if (this._tempBox.copy(P), this._tempBox.applyMatrix4(e.matrixWorld), g.isPerspectiveCamera && b.isInside(this._tempBox, this.projectionScreenMatrix)) {
+        r.mesh_lod = 0, r.texture_lod = 0;
         return;
       }
-      if (this._tempBox.applyMatrix4(this.projectionScreenMatrix), this.renderer.xr.enabled && w.isPerspectiveCamera && w.fov > 70) {
-        const m = this._tempBox.min, v = this._tempBox.max;
-        let C = m.x, $ = m.y, z = v.x, ie = v.y;
-        const fe = 2, Me = 1.5, he = (m.x + v.x) * 0.5, ge = (m.y + v.y) * 0.5;
-        C = (C - he) * fe + he, $ = ($ - ge) * fe + ge, z = (z - he) * fe + he, ie = (ie - ge) * fe + ge;
-        const Xe = C < 0 && z > 0 ? 0 : Math.min(Math.abs(m.x), Math.abs(v.x)), qe = $ < 0 && ie > 0 ? 0 : Math.min(Math.abs(m.y), Math.abs(v.y)), ve = Math.max(Xe, qe);
-        r.lastCentrality = (Me - ve) * (Me - ve) * (Me - ve);
+      if (this._tempBox.applyMatrix4(this.projectionScreenMatrix), this.renderer.xr.enabled && g.isPerspectiveCamera && g.fov > 70) {
+        const p = this._tempBox.min, _ = this._tempBox.max;
+        let $ = p.x, A = p.y, z = _.x, ne = _.y;
+        const fe = 2, ve = 1.5, he = (p.x + _.x) * 0.5, ge = (p.y + _.y) * 0.5;
+        $ = ($ - he) * fe + he, A = (A - ge) * fe + ge, z = (z - he) * fe + he, ne = (ne - ge) * fe + ge;
+        const Ke = $ < 0 && z > 0 ? 0 : Math.min(Math.abs(p.x), Math.abs(_.x)), Ye = A < 0 && ne > 0 ? 0 : Math.min(Math.abs(p.y), Math.abs(_.y)), De = Math.max(Ke, Ye);
+        s.lastCentrality = (ve - De) * (ve - De) * (ve - De);
       } else
-        r.lastCentrality = 1;
-      const p = this._tempBox.getSize(this._tempBoxSize);
-      p.multiplyScalar(0.5), screen.availHeight > 0 && _ > 0 && p.multiplyScalar(_ / screen.availHeight), t.isPerspectiveCamera ? p.x *= t.aspect : t.isOrthographicCamera;
-      const q = t.matrixWorldInverse, P = this._tempBox2;
-      P.copy(x), P.applyMatrix4(e.matrixWorld), P.applyMatrix4(q);
-      const G = P.getSize(this._tempBox2Size), k = Math.max(G.x, G.y);
-      if (Math.max(p.x, p.y) != 0 && k != 0 && (p.z = G.z / Math.max(G.x, G.y) * Math.max(p.x, p.y)), r.lastScreenCoverage = Math.max(p.x, p.y, p.z), r.lastScreenspaceVolume.copy(p), r.lastScreenCoverage *= r.lastCentrality, U && T.debugDrawLine) {
-        const m = this.tempMatrix.copy(this.projectionScreenMatrix);
-        m.invert();
-        const v = T.corner0, C = T.corner1, $ = T.corner2, z = T.corner3;
-        v.copy(this._tempBox.min), C.copy(this._tempBox.max), C.x = v.x, $.copy(this._tempBox.max), $.y = v.y, z.copy(this._tempBox.max);
-        const ie = (v.z + z.z) * 0.5;
-        v.z = C.z = $.z = z.z = ie, v.applyMatrix4(m), C.applyMatrix4(m), $.applyMatrix4(m), z.applyMatrix4(m), T.debugDrawLine(v, C, 255), T.debugDrawLine(v, $, 255), T.debugDrawLine(C, z, 255), T.debugDrawLine($, z, 255);
+        s.lastCentrality = 1;
+      const x = this._tempBox.getSize(this._tempBoxSize);
+      x.multiplyScalar(0.5), screen.availHeight > 0 && v > 0 && x.multiplyScalar(v / screen.availHeight), t.isPerspectiveCamera ? x.x *= t.aspect : t.isOrthographicCamera;
+      const E = t.matrixWorldInverse, U = this._tempBox2;
+      U.copy(P), U.applyMatrix4(e.matrixWorld), U.applyMatrix4(E);
+      const S = U.getSize(this._tempBox2Size), ee = Math.max(S.x, S.y);
+      if (Math.max(x.x, x.y) != 0 && ee != 0 && (x.z = S.z / Math.max(S.x, S.y) * Math.max(x.x, x.y)), s.lastScreenCoverage = Math.max(x.x, x.y, x.z), s.lastScreenspaceVolume.copy(x), s.lastScreenCoverage *= s.lastCentrality, F && b.debugDrawLine) {
+        const p = this.tempMatrix.copy(this.projectionScreenMatrix);
+        p.invert();
+        const _ = b.corner0, $ = b.corner1, A = b.corner2, z = b.corner3;
+        _.copy(this._tempBox.min), $.copy(this._tempBox.max), $.x = _.x, A.copy(this._tempBox.max), A.y = _.y, z.copy(this._tempBox.max);
+        const ne = (_.z + z.z) * 0.5;
+        _.z = $.z = A.z = z.z = ne, _.applyMatrix4(p), $.applyMatrix4(p), A.applyMatrix4(p), z.applyMatrix4(p), b.debugDrawLine(_, $, 255), b.debugDrawLine(_, A, 255), b.debugDrawLine($, z, 255), b.debugDrawLine(A, z, 255);
       }
-      let f = 999;
-      if (u && r.lastScreenCoverage > 0)
-        for (let m = 0; m < u.length; m++) {
-          const v = u[m];
-          if ((((X = v.densities) == null ? void 0 : X[c]) || v.density || 1e-5) / r.lastScreenCoverage < i) {
-            f = m;
+      let D = 999;
+      if (c && s.lastScreenCoverage > 0)
+        for (let p = 0; p < c.length; p++) {
+          const _ = c[p], A = (((R = _.densities) == null ? void 0 : R[d]) || _.density || 1e-5) / s.lastScreenCoverage;
+          if (d > 0 && Ge() && !_.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.")), A < n) {
+            D = p;
             break;
           }
         }
-      f < a && (a = f, l = !0);
+      D < a && (a = D, l = !0);
     }
-    if (l ? o.mesh_lod = a : o.mesh_lod = r.lastLodLevel_Mesh, U && o.mesh_lod != r.lastLodLevel_Mesh) {
-      const p = u == null ? void 0 : u[o.mesh_lod];
-      p && console.log(`Mesh LOD changed: ${r.lastLodLevel_Mesh} → ${o.mesh_lod} (${p.density.toFixed(0)}) - ${e.name}`);
+    if (l ? r.mesh_lod = a : r.mesh_lod = s.lastLodLevel_Mesh, F && r.mesh_lod != s.lastLodLevel_Mesh) {
+      const x = c == null ? void 0 : c[r.mesh_lod];
+      x && console.log(`Mesh LOD changed: ${s.lastLodLevel_Mesh} → ${r.mesh_lod} (${x.density.toFixed(0)}) - ${e.name}`);
     }
-    if (D) {
-      const w = "saveData" in globalThis.navigator && globalThis.navigator.saveData === !0;
-      if (r.lastLodLevel_Texture < 0) {
-        if (o.texture_lod = g.max_count - 1, U) {
-          const p = g.lods[g.max_count - 1];
-          U && console.log(`First Texture LOD ${o.texture_lod} (${p.max_height}px) - ${e.name}`);
+    if (w) {
+      const g = "saveData" in globalThis.navigator && globalThis.navigator.saveData === !0;
+      if (s.lastLodLevel_Texture < 0) {
+        if (r.texture_lod = f.max_count - 1, F) {
+          const x = f.lods[f.max_count - 1];
+          F && console.log(`First Texture LOD ${r.texture_lod} (${x.max_height}px) - ${e.name}`);
         }
       } else {
-        const p = r.lastScreenspaceVolume.x + r.lastScreenspaceVolume.y + r.lastScreenspaceVolume.z;
-        let q = r.lastScreenCoverage * 4;
-        ((M = this.context) == null ? void 0 : M.engine) === "model-viewer" && (q *= 1.5);
-        const G = _ / window.devicePixelRatio * q;
-        let k = !1;
-        for (let O = g.lods.length - 1; O >= 0; O--) {
-          const f = g.lods[O];
-          if (!(w && f.max_height >= 2048) && !(ct() && f.max_height > 4096) && (f.max_height > G || !k && O === 0)) {
-            if (k = !0, o.texture_lod = O, o.texture_lod < r.lastLodLevel_Texture) {
-              const S = f.max_height;
-              U && console.log(`Texture LOD changed: ${r.lastLodLevel_Texture} → ${o.texture_lod} = ${S}px 
-Screensize: ${G.toFixed(0)}px, Coverage: ${(100 * r.lastScreenCoverage).toFixed(2)}%, Volume ${p.toFixed(1)} 
+        const x = s.lastScreenspaceVolume.x + s.lastScreenspaceVolume.y + s.lastScreenspaceVolume.z;
+        let E = s.lastScreenCoverage * 4;
+        ((Z = this.context) == null ? void 0 : Z.engine) === "model-viewer" && (E *= 1.5);
+        const S = v / window.devicePixelRatio * E;
+        let ee = !1;
+        for (let I = f.lods.length - 1; I >= 0; I--) {
+          const D = f.lods[I];
+          if (!(g && D.max_height >= 2048) && !(ct() && D.max_height > 4096) && (D.max_height > S || !ee && I === 0)) {
+            if (ee = !0, r.texture_lod = I, r.texture_lod < s.lastLodLevel_Texture) {
+              const m = D.max_height;
+              F && console.log(`Texture LOD changed: ${s.lastLodLevel_Texture} → ${r.texture_lod} = ${m}px 
+Screensize: ${S.toFixed(0)}px, Coverage: ${(100 * s.lastScreenCoverage).toFixed(2)}%, Volume ${x.toFixed(1)} 
 ${e.name}`);
             }
             break;
@@ -895,100 +1066,100 @@ ${e.name}`);
         }
       }
     } else
-      o.texture_lod = 0;
+      r.texture_lod = 0;
   }
 };
-let I = T;
-B = new WeakMap(), H = new WeakMap(), xe = new WeakMap(), se = new WeakMap(), oe = new WeakMap(), De = new WeakMap(), j = new WeakMap(), /** 
+let C = b;
+B = new WeakMap(), K = new WeakMap(), we = new WeakMap(), J = new WeakMap(), ie = new WeakMap(), _e = new WeakMap(), Y = new WeakMap(), /** 
  * 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.
  */
-d(I, "debugDrawLine"), /**
+u(C, "debugDrawLine"), /**
  * Force override the LOD level for all objects in the scene
  */
-d(I, "overrideGlobalLodLevel"), d(I, "corner0", new K()), d(I, "corner1", new K()), d(I, "corner2", new K()), d(I, "corner3", new K()), d(I, "_tempPtInside", new K());
-class yt {
+u(C, "overrideGlobalLodLevel"), u(C, "corner0", new W()), u(C, "corner1", new W()), u(C, "corner2", new W()), u(C, "corner3", new W()), u(C, "_tempPtInside", new W()), u(C, "skinnedMeshBoundsFrameOffsetCounter", 0), u(C, "$skinnedMeshBoundsOffset", Symbol("gltf-progressive-skinnedMeshBoundsOffset"));
+class xt {
   constructor() {
-    d(this, "frames", 0);
-    d(this, "lastLodLevel_Mesh", -1);
-    d(this, "lastLodLevel_Texture", -1);
-    d(this, "lastScreenCoverage", 0);
-    d(this, "lastScreenspaceVolume", new K());
-    d(this, "lastCentrality", 0);
+    u(this, "frames", 0);
+    u(this, "lastLodLevel_Mesh", -1);
+    u(this, "lastLodLevel_Texture", -1);
+    u(this, "lastScreenCoverage", 0);
+    u(this, "lastScreenspaceVolume", new W());
+    u(this, "lastCentrality", 0);
   }
 }
-const Ie = Symbol("NEEDLE_mesh_lod"), pe = Symbol("NEEDLE_texture_lod");
-let ce = null;
-function Ve() {
-  const n = mt();
-  n && (n.mapURLs(function(t) {
-    return Re(), t;
-  }), Re(), ce == null || ce.disconnect(), ce = new MutationObserver((t) => {
+const Be = Symbol("NEEDLE_mesh_lod"), pe = Symbol("NEEDLE_texture_lod");
+let ue = null;
+function We() {
+  const o = wt();
+  o && (o.mapURLs(function(t) {
+    return ke(), t;
+  }), ke(), ue == null || ue.disconnect(), ue = new MutationObserver((t) => {
     t.forEach((e) => {
-      e.addedNodes.forEach((r) => {
-        r instanceof HTMLElement && r.tagName.toLowerCase() === "model-viewer" && We(r);
+      e.addedNodes.forEach((s) => {
+        s instanceof HTMLElement && s.tagName.toLowerCase() === "model-viewer" && Xe(s);
       });
     });
-  }), ce.observe(document, { childList: !0, subtree: !0 }));
+  }), ue.observe(document, { childList: !0, subtree: !0 }));
 }
-function mt() {
+function wt() {
   if (typeof customElements > "u")
     return null;
-  const n = customElements.get("model-viewer");
-  return n || (customElements.whenDefined("model-viewer").then(() => {
-    console.debug("[gltf-progressive] model-viewer defined"), Ve();
+  const o = customElements.get("model-viewer");
+  return o || (customElements.whenDefined("model-viewer").then(() => {
+    console.debug("[gltf-progressive] model-viewer defined"), We();
   }), null);
 }
-function Re() {
+function ke() {
   if (typeof document > "u")
     return;
   document.querySelectorAll("model-viewer").forEach((t) => {
-    We(t);
+    Xe(t);
   });
 }
-const ke = /* @__PURE__ */ new WeakSet();
-let Lt = 0;
-function We(n) {
-  if (!n || ke.has(n))
+const Re = /* @__PURE__ */ new WeakSet();
+let _t = 0;
+function Xe(o) {
+  if (!o || Re.has(o))
     return null;
-  ke.add(n), console.debug("[gltf-progressive] found new model-viewer..." + ++Lt + `
-`, n.getAttribute("src"));
-  let t = null, e = null, r = null;
-  for (let i = n; i != null; i = Object.getPrototypeOf(i)) {
-    const o = Object.getOwnPropertySymbols(i), s = o.find((u) => u.toString() == "Symbol(renderer)"), a = o.find((u) => u.toString() == "Symbol(scene)"), l = o.find((u) => u.toString() == "Symbol(needsRender)");
-    !t && s != null && (t = n[s].threeRenderer), !e && a != null && (e = n[a]), !r && l != null && (r = n[l]);
+  Re.add(o), console.debug("[gltf-progressive] found new model-viewer..." + ++_t + `
+`, o.getAttribute("src"));
+  let t = null, e = null, s = null;
+  for (let n = o; n != null; n = Object.getPrototypeOf(n)) {
+    const r = Object.getOwnPropertySymbols(n), i = r.find((c) => c.toString() == "Symbol(renderer)"), a = r.find((c) => c.toString() == "Symbol(scene)"), l = r.find((c) => c.toString() == "Symbol(needsRender)");
+    !t && i != null && (t = o[i].threeRenderer), !e && a != null && (e = o[a]), !s && l != null && (s = o[l]);
   }
   if (t && e) {
-    let i = function() {
-      if (r) {
-        let s = 0, a = setInterval(() => {
-          if (s++ > 5) {
+    let n = function() {
+      if (s) {
+        let i = 0, a = setInterval(() => {
+          if (i++ > 5) {
             clearInterval(a);
             return;
           }
-          r == null || r.call(n);
+          s == null || s.call(o);
         }, 300);
       }
     };
     console.debug("[gltf-progressive] setup model-viewer");
-    const o = I.get(t, { engine: "model-viewer" });
-    return I.addPlugin(new xt()), o.enable(), o.addEventListener("changed", () => {
-      r == null || r.call(n);
-    }), n.addEventListener("model-visibility", (s) => {
-      s.detail.visible && (r == null || r.call(n));
-    }), n.addEventListener("load", () => {
-      i();
+    const r = C.get(t, { engine: "model-viewer" });
+    return C.addPlugin(new vt()), r.enable(), r.addEventListener("changed", () => {
+      s == null || s.call(o);
+    }), o.addEventListener("model-visibility", (i) => {
+      i.detail.visible && (s == null || s.call(o));
+    }), o.addEventListener("load", () => {
+      n();
     }), () => {
-      o.disable();
+      r.disable();
     };
   }
   return null;
 }
-class xt {
+class vt {
   constructor() {
-    d(this, "_didWarnAboutMissingUrl", !1);
+    u(this, "_didWarnAboutMissingUrl", !1);
   }
-  onBeforeUpdateLOD(t, e, r, i) {
-    this.tryParseMeshLOD(e, i), this.tryParseTextureLOD(e, i);
+  onBeforeUpdateLOD(t, e, s, n) {
+    this.tryParseMeshLOD(e, n), this.tryParseTextureLOD(e, n);
   }
   getUrl(t) {
     if (!t)
@@ -1006,28 +1177,28 @@ class xt {
     if (e[pe] == !0)
       return;
     e[pe] = !0;
-    const r = this.tryGetCurrentGLTF(t), i = this.tryGetCurrentModelViewer(t), o = this.getUrl(i);
-    if (o && r && e.material) {
-      let s = function(l) {
-        var c, h, g;
+    const s = this.tryGetCurrentGLTF(t), n = this.tryGetCurrentModelViewer(t), r = this.getUrl(n);
+    if (r && s && e.material) {
+      let i = function(l) {
+        var d, h, f;
         if (l[pe] == !0)
           return;
         l[pe] = !0, l.userData && (l.userData.LOD = -1);
-        const u = Object.keys(l);
-        for (let D = 0; D < u.length; D++) {
-          const _ = u[D], x = l[_];
-          if ((x == null ? void 0 : x.isTexture) === !0) {
-            const N = (h = (c = x.userData) == null ? void 0 : c.associations) == null ? void 0 : h.textures;
-            if (N == null)
+        const c = Object.keys(l);
+        for (let w = 0; w < c.length; w++) {
+          const v = c[w], P = l[v];
+          if ((P == null ? void 0 : P.isTexture) === !0) {
+            const M = (h = (d = P.userData) == null ? void 0 : d.associations) == null ? void 0 : h.textures;
+            if (M == null)
               continue;
-            const X = r.parser.json.textures[N];
-            if (!X) {
-              console.warn("Texture data not found for texture index " + N);
+            const R = s.parser.json.textures[M];
+            if (!R) {
+              console.warn("Texture data not found for texture index " + M);
               continue;
             }
-            if ((g = X == null ? void 0 : X.extensions) != null && g[Y]) {
-              const M = X.extensions[Y];
-              M && o && A.registerTexture(o, x, M.lods.length, N, M);
+            if ((f = R == null ? void 0 : R.extensions) != null && f[X]) {
+              const Z = R.extensions[X];
+              Z && r && T.registerTexture(r, P, Z.lods.length, M, Z);
             }
           }
         }
@@ -1035,64 +1206,64 @@ class xt {
       const a = e.material;
       if (Array.isArray(a))
         for (const l of a)
-          s(l);
+          i(l);
       else
-        s(a);
+        i(a);
     }
   }
   tryParseMeshLOD(t, e) {
-    var s, a;
-    if (e[Ie] == !0)
+    var i, a;
+    if (e[Be] == !0)
       return;
-    e[Ie] = !0;
-    const r = this.tryGetCurrentModelViewer(t), i = this.getUrl(r);
-    if (!i)
+    e[Be] = !0;
+    const s = this.tryGetCurrentModelViewer(t), n = this.getUrl(s);
+    if (!n)
       return;
-    const o = (a = (s = e.userData) == null ? void 0 : s.gltfExtensions) == null ? void 0 : a[Y];
-    if (o && i) {
+    const r = (a = (i = e.userData) == null ? void 0 : i.gltfExtensions) == null ? void 0 : a[X];
+    if (r && n) {
       const l = e.uuid;
-      A.registerMesh(i, l, e, 0, o.lods.length, o);
+      T.registerMesh(n, l, e, 0, r.lods.length, r);
     }
   }
 }
-function Dt(n, t, e, r) {
-  Ue(t), Fe(e), Ne(e, {
+function Dt(o, t, e, s) {
+  Ue(t), ze(e), Ve(e, {
     progressive: !0,
-    ...r == null ? void 0 : r.hints
-  }), e.register((o) => new A(o, n));
-  const i = I.get(t);
-  return (r == null ? void 0 : r.enableLODsManager) !== !1 && i.enable(), i;
+    ...s == null ? void 0 : s.hints
+  }), e.register((r) => new T(r, o));
+  const n = C.get(t);
+  return (s == null ? void 0 : s.enableLODsManager) !== !1 && n.enable(), n;
 }
-Ve();
-if (!ut) {
-  const n = {
+We();
+if (!ht) {
+  const o = {
     gltfProgressive: {
       useNeedleProgressive: Dt,
-      LODsManager: I,
-      configureLoader: Ne,
-      getRaycastMesh: de,
-      useRaycastMeshes: ft
+      LODsManager: C,
+      configureLoader: Ve,
+      getRaycastMesh: ce,
+      useRaycastMeshes: pt
     }
   };
   if (!globalThis.Needle)
-    globalThis.Needle = n;
+    globalThis.Needle = o;
   else
-    for (const t in n)
-      globalThis.Needle[t] = n[t];
+    for (const t in o)
+      globalThis.Needle[t] = o[t];
 }
 export {
-  Y as EXTENSION_NAME,
-  I as LODsManager,
-  A as NEEDLE_progressive,
-  rt as VERSION,
-  Fe as addDracoAndKTX2Loaders,
-  Ne as configureLoader,
+  X as EXTENSION_NAME,
+  C as LODsManager,
+  T as NEEDLE_progressive,
+  it as VERSION,
+  ze as addDracoAndKTX2Loaders,
+  Ve as configureLoader,
   Ue as createLoaders,
-  de as getRaycastMesh,
-  Ve as patchModelViewer,
-  dt as registerRaycastMesh,
-  it as setDracoDecoderLocation,
-  nt as setKTX2TranscoderLocation,
+  ce as getRaycastMesh,
+  We as patchModelViewer,
+  gt as registerRaycastMesh,
+  at as setDracoDecoderLocation,
+  lt as setKTX2TranscoderLocation,
   Dt as useNeedleProgressive,
-  ft as useRaycastMeshes
+  pt as useRaycastMeshes
 };