@needle-tools/gltf-progressive 2.1.6 → 3.0.0-alpha.2

package/gltf-progressive.js

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