@needle-tools/gltf-progressive 1.2.2-alpha.4 → 1.2.3-alpha

package/gltf-progressive.js

@@ -1,176 +1,184 @@
-var Ae = Object.defineProperty;
-var Pe = (a, e, t) => e in a ? Ae(a, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : a[e] = t;
-var d = (a, e, t) => (Pe(a, typeof e != "symbol" ? e + "" : e, t), t);
-import { BufferGeometry as ie, Mesh as W, Material as Ee, Texture as q, TextureLoader as Ce, Matrix4 as ye, Frustum as Be, Sphere as Re, Box3 as me, Vector3 as G } from "three";
-import { GLTFLoader as ke } from "three/examples/jsm/loaders/GLTFLoader.js";
-import { MeshoptDecoder as Ie } from "three/examples/jsm/libs/meshopt_decoder.module.js";
-import { DRACOLoader as Ge } from "three/examples/jsm/loaders/DRACOLoader.js";
-import { KTX2Loader as Fe } from "three/examples/jsm/loaders/KTX2Loader.js";
-const we = "";
-globalThis.GLTF_PROGRESSIVE_VERSION = we;
-console.debug(`[gltf-progressive] version ${we}`);
-let ne = "https://www.gstatic.com/draco/versioned/decoders/1.4.1/", ge = "https://www.gstatic.com/basis-universal/versioned/2021-04-15-ba1c3e4/";
-fetch(ne + "draco_decoder.js", { method: "head" }).catch((a) => {
-  ne = "./include/draco/", ge = "./include/ktx2/";
+var ze = Object.defineProperty;
+var Ve = (a, t, e) => t in a ? ze(a, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : a[t] = e;
+var d = (a, t, e) => (Ve(a, typeof t != "symbol" ? t + "" : t, e), e), Se = (a, t, e) => {
+  if (!t.has(a))
+    throw TypeError("Cannot " + e);
+};
+var m = (a, t, e) => (Se(a, t, "read from private field"), e ? e.call(a) : t.get(a)), q = (a, t, e) => {
+  if (t.has(a))
+    throw TypeError("Cannot add the same private member more than once");
+  t instanceof WeakSet ? t.add(a) : t.set(a, e);
+}, $ = (a, t, e, r) => (Se(a, t, "write to private field"), r ? r.call(a, e) : t.set(a, e), e);
+import { BufferGeometry as de, Mesh as J, Material as Ne, Texture as ee, TextureLoader as Ue, Matrix4 as be, Frustum as We, Clock as Ke, MeshStandardMaterial as qe, Sphere as Xe, Box3 as Te, Vector3 as V } from "three";
+import { GLTFLoader as Ye } from "three/examples/jsm/loaders/GLTFLoader.js";
+import { MeshoptDecoder as He } from "three/examples/jsm/libs/meshopt_decoder.module.js";
+import { DRACOLoader as Je } from "three/examples/jsm/loaders/DRACOLoader.js";
+import { KTX2Loader as Qe } from "three/examples/jsm/loaders/KTX2Loader.js";
+const Be = "";
+globalThis.GLTF_PROGRESSIVE_VERSION = Be;
+console.debug(`[gltf-progressive] version ${Be}`);
+let he = "https://www.gstatic.com/draco/versioned/decoders/1.4.1/", _e = "https://www.gstatic.com/basis-universal/versioned/2021-04-15-ba1c3e4/";
+fetch(he + "draco_decoder.js", { method: "head" }).catch((a) => {
+  he = "./include/draco/", _e = "./include/ktx2/";
 });
-function tt(a) {
-  ne = a;
+function gt(a) {
+  he = a;
 }
-function rt(a) {
-  ge = a;
+function pt(a) {
+  _e = a;
 }
-let J, fe, Q;
-function ve(a) {
-  J || (J = new Ge(), J.setDecoderPath(ne), J.setDecoderConfig({ type: "js" })), Q || (Q = new Fe(), Q.setTranscoderPath(ge)), fe || (fe = Ie), a ? Q.detectSupport(a) : console.warn("No renderer provided to detect ktx2 support - loading KTX2 textures will probably fail");
+let ie, De, oe;
+function ke(a) {
+  ie || (ie = new Je(), ie.setDecoderPath(he), ie.setDecoderConfig({ type: "js" })), oe || (oe = new Qe(), oe.setTranscoderPath(_e)), De || (De = He), a ? oe.detectSupport(a) : console.warn("No renderer provided to detect ktx2 support - loading KTX2 textures will probably fail");
 }
-function _e(a) {
-  a.dracoLoader || a.setDRACOLoader(J), a.ktx2Loader || a.setKTX2Loader(Q), a.meshoptDecoder || a.setMeshoptDecoder(fe);
+function Ie(a) {
+  a.dracoLoader || a.setDRACOLoader(ie), a.ktx2Loader || a.setKTX2Loader(oe), a.meshoptDecoder || a.setMeshoptDecoder(De);
 }
-j("debugprogressive");
-function j(a) {
-  const t = new URL(window.location.href).searchParams.get(a);
-  return t == null || t === "0" || t === "false" ? !1 : t === "" ? !0 : t;
+ae("debugprogressive");
+function ae(a) {
+  const e = new URL(window.location.href).searchParams.get(a);
+  return e == null || e === "0" || e === "false" ? !1 : e === "" ? !0 : e;
 }
-function $e(a, e) {
-  if (e === void 0 || e.startsWith("./") || e.startsWith("http") || a === void 0)
-    return e;
-  const t = a.lastIndexOf("/");
-  if (t >= 0) {
-    const r = a.substring(0, t + 1);
-    for (; r.endsWith("/") && e.startsWith("/"); )
-      e = e.substring(1);
-    return r + e;
-  }
-  return e;
+function Ze(a, t) {
+  if (t === void 0 || t.startsWith("./") || t.startsWith("http") || a === void 0)
+    return t;
+  const e = a.lastIndexOf("/");
+  if (e >= 0) {
+    const r = a.substring(0, e + 1);
+    for (; r.endsWith("/") && t.startsWith("/"); )
+      t = t.substring(1);
+    return r + t;
+  }
+  return t;
 }
-let X;
-function ze() {
-  return X !== void 0 || (X = /iPhone|iPad|iPod|Android|IEMobile/i.test(navigator.userAgent), j("debugprogressive") && console.log("[glTF Progressive]: isMobileDevice", X)), X;
+let te;
+function je() {
+  return te !== void 0 || (te = /iPhone|iPad|iPod|Android|IEMobile/i.test(navigator.userAgent), ae("debugprogressive") && console.log("[glTF Progressive]: isMobileDevice", te)), te;
 }
-const de = Symbol("needle:raycast-mesh");
-function pe(a) {
-  return (a == null ? void 0 : a[de]) instanceof ie ? a[de] : null;
+const we = Symbol("needle:raycast-mesh");
+function Oe(a) {
+  return (a == null ? void 0 : a[we]) instanceof de ? a[we] : null;
 }
-function Ve(a, e) {
-  if ((a.type === "Mesh" || a.type === "SkinnedMesh") && !pe(a)) {
-    const r = Ne(e);
-    r.userData = { isRaycastMesh: !0 }, a[de] = r;
+function et(a, t) {
+  if ((a.type === "Mesh" || a.type === "SkinnedMesh") && !Oe(a)) {
+    const r = tt(t);
+    r.userData = { isRaycastMesh: !0 }, a[we] = r;
   }
 }
-function st(a = !0) {
+function yt(a = !0) {
   if (a) {
-    if (Y)
+    if (re)
       return;
-    const e = Y = W.prototype.raycast;
-    W.prototype.raycast = function(t, r) {
-      const n = this, i = pe(n);
+    const t = re = J.prototype.raycast;
+    J.prototype.raycast = function(e, r) {
+      const o = this, i = Oe(o);
       let s;
-      i && n.isMesh && (s = n.geometry, n.geometry = i), e.call(this, t, r), s && (n.geometry = s);
+      i && o.isMesh && (s = o.geometry, o.geometry = i), t.call(this, e, r), s && (o.geometry = s);
     };
   } else {
-    if (!Y)
+    if (!re)
       return;
-    W.prototype.raycast = Y, Y = null;
+    J.prototype.raycast = re, re = null;
   }
 }
-let Y = null;
-function Ne(a) {
-  const e = new ie();
-  for (const t in a.attributes)
-    e.setAttribute(t, a.getAttribute(t));
-  return e.setIndex(a.getIndex()), e;
+let re = null;
+function tt(a) {
+  const t = new de();
+  for (const e in a.attributes)
+    t.setAttribute(e, a.getAttribute(e));
+  return t.setIndex(a.getIndex()), t;
 }
-const z = new Array(), F = "NEEDLE_progressive", m = j("debugprogressive"), le = Symbol("needle-progressive-texture"), Z = /* @__PURE__ */ new Map(), he = /* @__PURE__ */ new Set();
-if (m) {
+const X = new Array(), N = "NEEDLE_progressive", L = ae("debugprogressive"), xe = Symbol("needle-progressive-texture"), ne = /* @__PURE__ */ new Map(), ve = /* @__PURE__ */ new Set();
+if (L) {
   let a = function() {
-    e += 1, console.log("Toggle LOD level", e, Z), Z.forEach((n, i) => {
-      for (const s of n.keys) {
-        const o = i[s];
-        if (o != null) {
-          if (o.isBufferGeometry === !0) {
-            const l = O.getMeshLODInformation(o), f = l ? Math.min(e, l.lods.length) : 0;
-            i["DEBUG:LOD"] = e, O.assignMeshLOD(i, f), l && (t = Math.max(t, l.lods.length - 1));
+    t += 1, console.log("Toggle LOD level", t, ne), ne.forEach((o, i) => {
+      for (const s of o.keys) {
+        const n = i[s];
+        if (n != null) {
+          if (n.isBufferGeometry === !0) {
+            const l = S.getMeshLODInformation(n), u = l ? Math.min(t, l.lods.length) : 0;
+            i["DEBUG:LOD"] = t, S.assignMeshLOD(i, u), l && (e = Math.max(e, l.lods.length - 1));
           } else if (i.isMaterial === !0) {
-            i["DEBUG:LOD"] = e, O.assignTextureLOD(i, e);
+            i["DEBUG:LOD"] = t, S.assignTextureLOD(i, t);
             break;
           }
         }
       }
-    }), e >= t && (e = -1);
-  }, e = -1, t = 2, r = !1;
-  window.addEventListener("keyup", (n) => {
-    n.key === "p" && a(), n.key === "w" && (r = !r, he && he.forEach((i) => {
+    }), t >= e && (t = -1);
+  }, t = -1, e = 2, r = !1;
+  window.addEventListener("keyup", (o) => {
+    o.key === "p" && a(), o.key === "w" && (r = !r, ve && ve.forEach((i) => {
       i.name != "BackgroundCubeMaterial" && i.glyphMap == null && "wireframe" in i && (i.wireframe = r);
     }));
   });
 }
-function xe(a, e, t) {
-  var n;
-  if (!m)
+function Ae(a, t, e) {
+  var o;
+  if (!L)
     return;
-  Z.has(a) || Z.set(a, { keys: [], sourceId: t });
-  const r = Z.get(a);
-  ((n = r == null ? void 0 : r.keys) == null ? void 0 : n.includes(e)) == !1 && r.keys.push(e);
+  ne.has(a) || ne.set(a, { keys: [], sourceId: e });
+  const r = ne.get(a);
+  ((o = r == null ? void 0 : r.keys) == null ? void 0 : o.includes(t)) == !1 && r.keys.push(t);
 }
-const _ = class {
-  constructor(e, t) {
+const O = class {
+  constructor(t, e) {
     d(this, "parser");
     d(this, "url");
     d(this, "_isLoadingMesh");
-    d(this, "loadMesh", (e) => {
-      var r, n;
+    d(this, "loadMesh", (t) => {
+      var r, o;
       if (this._isLoadingMesh)
         return null;
-      const t = (n = (r = this.parser.json.meshes[e]) == null ? void 0 : r.extensions) == null ? void 0 : n[F];
-      return t ? (this._isLoadingMesh = !0, this.parser.getDependency("mesh", e).then((i) => {
+      const e = (o = (r = this.parser.json.meshes[t]) == null ? void 0 : r.extensions) == null ? void 0 : o[N];
+      return e ? (this._isLoadingMesh = !0, this.parser.getDependency("mesh", t).then((i) => {
         var s;
-        return this._isLoadingMesh = !1, i && _.registerMesh(this.url, t.guid, i, (s = t.lods) == null ? void 0 : s.length, void 0, t), i;
+        return this._isLoadingMesh = !1, i && O.registerMesh(this.url, e.guid, i, (s = e.lods) == null ? void 0 : s.length, void 0, e), i;
       })) : null;
     });
-    m && 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 F;
+    return N;
   }
-  static getMeshLODInformation(e) {
-    const t = this.getAssignedLODInformation(e);
-    return t != null && t.key ? this.lodInfos.get(t.key) : null;
+  static getMeshLODInformation(t) {
+    const e = this.getAssignedLODInformation(t);
+    return e != null && e.key ? this.lodInfos.get(e.key) : null;
   }
-  static getMaterialMinMaxLODsCount(e, t) {
-    const r = this, n = "LODS:minmax", i = e[n];
+  static getMaterialMinMaxLODsCount(t, e) {
+    const r = this, o = "LODS:minmax", i = t[o];
     if (i != null)
       return i;
-    if (t || (t = {
+    if (e || (e = {
       min_count: 1 / 0,
       max_count: 0,
       lods: []
-    }), Array.isArray(e)) {
-      for (const o of e)
-        this.getMaterialMinMaxLODsCount(o, t);
-      return e[n] = t, t;
+    }), Array.isArray(t)) {
+      for (const n of t)
+        this.getMaterialMinMaxLODsCount(n, e);
+      return t[o] = e, e;
     }
-    if (m === "verbose" && console.log("getMaterialMinMaxLODsCount", e), e.type === "ShaderMaterial" || e.type === "RawShaderMaterial") {
-      const o = e;
-      for (const l of Object.keys(o.uniforms)) {
-        const f = o.uniforms[l].value;
-        (f == null ? void 0 : f.isTexture) === !0 && s(f, t);
+    if (L === "verbose" && console.log("getMaterialMinMaxLODsCount", t), t.type === "ShaderMaterial" || t.type === "RawShaderMaterial") {
+      const n = t;
+      for (const l of Object.keys(n.uniforms)) {
+        const u = n.uniforms[l].value;
+        (u == null ? void 0 : u.isTexture) === !0 && s(u, e);
       }
-    } else if (e.isMaterial)
-      for (const o of Object.keys(e)) {
-        const l = e[o];
-        (l == null ? void 0 : l.isTexture) === !0 && s(l, t);
+    } else if (t.isMaterial)
+      for (const n of Object.keys(t)) {
+        const l = t[n];
+        (l == null ? void 0 : l.isTexture) === !0 && s(l, e);
       }
-    return e[n] = t, t;
-    function s(o, l) {
-      const f = r.getAssignedLODInformation(o);
-      if (f) {
-        const c = r.lodInfos.get(f.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 x = 0; x < c.lods.length; x++) {
-            const u = c.lods[x];
-            u.width && (l.lods[x] = l.lods[x] || { min_height: 1 / 0, max_height: 0 }, l.lods[x].min_height = Math.min(l.lods[x].min_height, u.height), l.lods[x].max_height = Math.max(l.lods[x].max_height, u.height));
+    return t[o] = e, e;
+    function s(n, l) {
+      const u = r.getAssignedLODInformation(n);
+      if (u) {
+        const f = r.lodInfos.get(u.key);
+        if (f && f.lods) {
+          l.min_count = Math.min(l.min_count, f.lods.length), l.max_count = Math.max(l.max_count, f.lods.length);
+          for (let M = 0; M < f.lods.length; M++) {
+            const c = f.lods[M];
+            c.width && (l.lods[M] = l.lods[M] || { min_height: 1 / 0, max_height: 0 }, l.lods[M].min_height = Math.min(l.lods[M].min_height, c.height), l.lods[M].max_height = Math.max(l.lods[M].max_height, c.height));
           }
         }
       }
@@ -181,33 +189,33 @@ const _ = 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) {
+  static hasLODLevelAvailable(t, e) {
     var i;
-    if (Array.isArray(e)) {
-      for (const s of e)
-        if (this.hasLODLevelAvailable(s, t))
+    if (Array.isArray(t)) {
+      for (const s of t)
+        if (this.hasLODLevelAvailable(s, e))
           return !0;
       return !1;
     }
-    if (e.isMaterial === !0) {
-      for (const s of Object.keys(e)) {
-        const o = e[s];
-        if (o && o.isTexture && this.hasLODLevelAvailable(o, t))
+    if (t.isMaterial === !0) {
+      for (const s of Object.keys(t)) {
+        const n = t[s];
+        if (n && n.isTexture && this.hasLODLevelAvailable(n, e))
           return !0;
       }
       return !1;
-    } else if (e.isGroup === !0) {
-      for (const s of e.children)
-        if (s.isMesh === !0 && this.hasLODLevelAvailable(s, t))
+    } else if (t.isGroup === !0) {
+      for (const s of t.children)
+        if (s.isMesh === !0 && this.hasLODLevelAvailable(s, e))
           return !0;
     }
-    let r, n;
-    if (e.isMesh ? r = e.geometry : (e.isBufferGeometry || e.isTexture) && (r = e), r && (i = r == null ? void 0 : r.userData) != null && i.LODS) {
+    let r, o;
+    if (t.isMesh ? r = t.geometry : (t.isBufferGeometry || t.isTexture) && (r = t), r && (i = r == null ? void 0 : r.userData) != null && i.LODS) {
       const s = r.userData.LODS;
-      if (n = this.lodInfos.get(s.key), t === void 0)
-        return n != null;
-      if (n)
-        return Array.isArray(n.lods) ? t < n.lods.length : t === 0;
+      if (o = this.lodInfos.get(s.key), e === void 0)
+        return o != null;
+      if (o)
+        return Array.isArray(o.lods) ? e < o.lods.length : e === 0;
     }
     return !1;
   }
@@ -225,28 +233,28 @@ const _ = class {
    * });
    * ```
    */
-  static assignMeshLOD(e, t) {
+  static assignMeshLOD(t, e) {
     var r;
-    if (!e)
+    if (!t)
       return Promise.resolve(null);
-    if (e instanceof W || e.isMesh === !0) {
-      const n = e.geometry, i = this.getAssignedLODInformation(n);
+    if (t instanceof J || t.isMesh === !0) {
+      const o = t.geometry, i = this.getAssignedLODInformation(o);
       if (!i)
         return Promise.resolve(null);
-      for (const s of z)
-        (r = s.onBeforeGetLODMesh) == null || r.call(s, e, t);
-      return e["LOD:requested level"] = t, _.getOrLoadLOD(n, t).then((s) => {
-        if (e["LOD:requested level"] === t) {
-          if (delete e["LOD:requested level"], Array.isArray(s)) {
-            const o = i.index || 0;
-            s = s[o];
+      for (const s of X)
+        (r = s.onBeforeGetLODMesh) == null || r.call(s, t, e);
+      return t["LOD:requested level"] = e, O.getOrLoadLOD(o, e).then((s) => {
+        if (t["LOD:requested level"] === e) {
+          if (delete t["LOD:requested level"], Array.isArray(s)) {
+            const n = i.index || 0;
+            s = s[n];
           }
-          s && n != s && ((s == null ? void 0 : s.isBufferGeometry) ? (e.geometry = s, m && xe(e, "geometry", i.url)) : m && console.error("Invalid LOD geometry", s));
+          s && o != s && ((s == null ? void 0 : s.isBufferGeometry) ? (t.geometry = s, L && Ae(t, "geometry", i.url)) : L && console.error("Invalid LOD geometry", s));
         }
         return s;
-      }).catch((s) => (console.error("Error loading mesh LOD", e, s), null));
+      }).catch((s) => (console.error("Error loading mesh LOD", t, s), null));
     } else
-      m && 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);
   }
   /** Load a different resolution of a texture (if available)  
@@ -256,263 +264,263 @@ const _ = class {
    * @param level the level of detail to load (0 is the highest resolution) - currently only 0 is supported
    * @returns a promise that resolves to the material or texture with the requested LOD level
    */
-  static assignTextureLOD(e, t = 0) {
-    if (!e)
+  static assignTextureLOD(t, e = 0) {
+    if (!t)
       return Promise.resolve(null);
-    if (e instanceof Ee || e.isMaterial === !0) {
-      const r = e, n = [], i = new Array();
-      if (m && he.add(r), r.uniforms && r.isRawShaderMaterial || r.isShaderMaterial === !0) {
+    if (t instanceof Ne || t.isMaterial === !0) {
+      const r = t, o = [], i = new Array();
+      if (L && ve.add(r), r.uniforms && r.isRawShaderMaterial || r.isShaderMaterial === !0) {
         const s = r;
-        for (const o of Object.keys(s.uniforms)) {
-          const l = s.uniforms[o].value;
+        for (const n of Object.keys(s.uniforms)) {
+          const l = s.uniforms[n].value;
           if ((l == null ? void 0 : l.isTexture) === !0) {
-            const f = this.assignTextureLODForSlot(l, t, r, o);
-            n.push(f), i.push(o);
+            const u = this.assignTextureLODForSlot(l, e, r, n);
+            o.push(u), i.push(n);
           }
         }
       } else
         for (const s of Object.keys(r)) {
-          const o = r[s];
-          if ((o == null ? void 0 : o.isTexture) === !0) {
-            const l = this.assignTextureLODForSlot(o, t, r, s);
-            n.push(l), i.push(s);
+          const n = r[s];
+          if ((n == null ? void 0 : n.isTexture) === !0) {
+            const l = this.assignTextureLODForSlot(n, e, r, s);
+            o.push(l), i.push(s);
           }
         }
-      return Promise.all(n).then((s) => {
-        const o = new Array();
+      return Promise.all(o).then((s) => {
+        const n = new Array();
         for (let l = 0; l < s.length; l++) {
-          const f = s[l], c = i[l];
-          f && f.isTexture === !0 ? o.push({ material: r, slot: c, texture: f, level: t }) : o.push({ material: r, slot: c, texture: null, level: t });
+          const u = s[l], f = i[l];
+          u && u.isTexture === !0 ? n.push({ material: r, slot: f, texture: u, level: e }) : n.push({ material: r, slot: f, texture: null, level: e });
         }
-        return o;
+        return n;
       });
     }
-    if (e instanceof q || e.isTexture === !0) {
-      const r = e;
-      return this.assignTextureLODForSlot(r, t, null, null);
+    if (t instanceof ee || t.isTexture === !0) {
+      const r = t;
+      return this.assignTextureLODForSlot(r, e, null, null);
     }
     return Promise.resolve(null);
   }
-  static assignTextureLODForSlot(e, t, r, n) {
-    return (e == null ? void 0 : e.isTexture) !== !0 ? Promise.resolve(null) : n === "glyphMap" ? Promise.resolve(e) : _.getOrLoadLOD(e, t).then((i) => {
+  static assignTextureLODForSlot(t, e, r, o) {
+    return (t == null ? void 0 : t.isTexture) !== !0 ? Promise.resolve(null) : o === "glyphMap" ? Promise.resolve(t) : O.getOrLoadLOD(t, e).then((i) => {
       if (Array.isArray(i))
         return null;
       if ((i == null ? void 0 : i.isTexture) === !0) {
-        if (i != e) {
-          if (r && n) {
-            const s = r[n];
+        if (i != t) {
+          if (r && o) {
+            const s = r[o];
             if (s) {
-              const o = this.getAssignedLODInformation(s);
-              if (o && (o == null ? void 0 : o.level) < t)
-                return m === "verbose" && console.warn("Assigned texture level is already higher: ", o.level, t, r, s, i), null;
+              const n = this.getAssignedLODInformation(s);
+              if (n && (n == null ? void 0 : n.level) < e)
+                return L === "verbose" && console.warn("Assigned texture level is already higher: ", n.level, e, r, s, i), null;
             }
-            r[n] = i;
+            r[o] = i;
           }
-          if (m && n && r) {
-            const s = this.getAssignedLODInformation(e);
-            s && xe(r, n, s.url);
+          if (L && o && r) {
+            const s = this.getAssignedLODInformation(t);
+            s && Ae(r, o, s.url);
           }
         }
         return i;
       } else
-        m == "verbose" && console.warn("No LOD found for", e, t);
+        L == "verbose" && console.warn("No LOD found for", t, e);
       return null;
-    }).catch((i) => (console.error("Error loading LOD", e, i), null));
+    }).catch((i) => (console.error("Error loading LOD", t, i), null));
   }
-  afterRoot(e) {
-    var t, r;
-    return m && console.log("AFTER", this.url, e), (t = this.parser.json.textures) == null || t.forEach((n, i) => {
+  afterRoot(t) {
+    var e, r;
+    return L && console.log("AFTER", this.url, t), (e = this.parser.json.textures) == null || e.forEach((o, i) => {
       var s;
-      if (n != null && n.extensions) {
-        const o = n == null ? void 0 : n.extensions[F];
-        if (o) {
-          if (!o.lods) {
-            m && console.warn("Texture has no LODs", o);
+      if (o != null && o.extensions) {
+        const n = o == null ? void 0 : o.extensions[N];
+        if (n) {
+          if (!n.lods) {
+            L && console.warn("Texture has no LODs", n);
             return;
           }
           let l = !1;
-          for (const f of this.parser.associations.keys())
-            f.isTexture === !0 && this.parser.associations.get(f).textures === i && (l = !0, _.registerTexture(this.url, f, (s = o.lods) == null ? void 0 : s.length, i, o));
-          l || this.parser.getDependency("texture", i).then((f) => {
-            var c;
-            f && _.registerTexture(this.url, f, (c = o.lods) == null ? void 0 : c.length, i, o);
+          for (const u of this.parser.associations.keys())
+            u.isTexture === !0 && this.parser.associations.get(u).textures === i && (l = !0, O.registerTexture(this.url, u, (s = n.lods) == null ? void 0 : s.length, i, n));
+          l || this.parser.getDependency("texture", i).then((u) => {
+            var f;
+            u && O.registerTexture(this.url, u, (f = n.lods) == null ? void 0 : f.length, i, n);
           });
         }
       }
-    }), (r = this.parser.json.meshes) == null || r.forEach((n, i) => {
-      if (n != null && n.extensions) {
-        const s = n == null ? void 0 : n.extensions[F];
+    }), (r = this.parser.json.meshes) == null || r.forEach((o, i) => {
+      if (o != null && o.extensions) {
+        const s = o == null ? void 0 : o.extensions[N];
         if (s && s.lods) {
-          for (const o of this.parser.associations.keys())
-            if (o.isMesh) {
-              const l = this.parser.associations.get(o);
-              l.meshes === i && _.registerMesh(this.url, s.guid, o, s.lods.length, l.primitives, s);
+          for (const n of this.parser.associations.keys())
+            if (n.isMesh) {
+              const l = this.parser.associations.get(n);
+              l.meshes === i && O.registerMesh(this.url, s.guid, n, s.lods.length, l.primitives, s);
             }
         }
       }
     }), null;
   }
-  static async getOrLoadLOD(e, t) {
-    var o, l, f, c;
-    const r = m == "verbose", n = e.userData.LODS;
-    if (!n)
+  static async getOrLoadLOD(t, e) {
+    var n, l, u, f;
+    const r = L == "verbose", o = t.userData.LODS;
+    if (!o)
       return null;
-    const i = n == null ? void 0 : n.key;
+    const i = o == null ? void 0 : o.key;
     let s;
-    if (e.isTexture === !0) {
-      const x = e;
-      x.source && x.source[le] && (s = x.source[le]);
+    if (t.isTexture === !0) {
+      const M = t;
+      M.source && M.source[xe] && (s = M.source[xe]);
     }
-    if (s || (s = _.lodInfos.get(i)), s) {
-      if (t > 0) {
+    if (s || (s = O.lodInfos.get(i)), s) {
+      if (e > 0) {
         let y = !1;
-        const w = Array.isArray(s.lods);
-        if (w && t >= s.lods.length ? y = !0 : w || (y = !0), y)
+        const v = Array.isArray(s.lods);
+        if (v && e >= s.lods.length ? y = !0 : v || (y = !0), y)
           return this.lowresCache.get(i);
       }
-      const x = Array.isArray(s.lods) ? (o = s.lods[t]) == null ? void 0 : o.path : s.lods;
-      if (!x)
-        return m && !s["missing:uri"] && (s["missing:uri"] = !0, console.warn("Missing uri for progressive asset for LOD " + t, s)), null;
-      const u = $e(n.url, x);
-      if (u.endsWith(".glb") || u.endsWith(".gltf")) {
+      const M = Array.isArray(s.lods) ? (n = s.lods[e]) == null ? void 0 : n.path : s.lods;
+      if (!M)
+        return L && !s["missing:uri"] && (s["missing:uri"] = !0, console.warn("Missing uri for progressive asset for LOD " + e, s)), null;
+      const c = Ze(o.url, M);
+      if (c.endsWith(".glb") || c.endsWith(".gltf")) {
         if (!s.guid)
           return console.warn("missing pointer for glb/gltf texture", s), null;
-        const y = u + "_" + s.guid, w = this.previouslyLoaded.get(y);
-        if (w !== void 0) {
-          r && console.log(`LOD ${t} was already loading/loaded: ${y}`);
-          let p = await w.catch((V) => (console.error(`Error loading LOD ${t} from ${u}
-`, V), null)), M = !1;
-          if (p == null || (p instanceof q && e instanceof q ? (l = p.image) != null && l.data || (f = p.source) != null && f.data ? p = this.copySettings(e, p) : (M = !0, this.previouslyLoaded.delete(y)) : p instanceof ie && e instanceof ie && ((c = p.attributes.position) != null && c.array || (M = !0, this.previouslyLoaded.delete(y)))), !M)
+        const y = c + "_" + s.guid, v = this.previouslyLoaded.get(y);
+        if (v !== void 0) {
+          r && console.log(`LOD ${e} was already loading/loaded: ${y}`);
+          let p = await v.catch((Y) => (console.error(`Error loading LOD ${e} from ${c}
+`, Y), null)), D = !1;
+          if (p == null || (p instanceof ee && t instanceof ee ? (l = p.image) != null && l.data || (u = p.source) != null && u.data ? p = this.copySettings(t, p) : (D = !0, this.previouslyLoaded.delete(y)) : p instanceof de && t instanceof de && ((f = p.attributes.position) != null && f.array || (D = !0, this.previouslyLoaded.delete(y)))), !D)
             return p;
         }
-        const L = s, B = new Promise(async (p, M) => {
-          const V = new ke();
-          _e(V), m && (await new Promise((S) => setTimeout(S, 1e3)), r && console.warn("Start loading (delayed) " + u, L.guid));
-          let R = u;
-          if (L && Array.isArray(L.lods)) {
-            const S = L.lods[t];
-            S.hash && (R += "?v=" + S.hash);
+        const x = s, R = new Promise(async (p, D) => {
+          const Y = new Ye();
+          Ie(Y), L && (await new Promise((b) => setTimeout(b, 1e3)), r && console.warn("Start loading (delayed) " + c, x.guid));
+          let G = c;
+          if (x && Array.isArray(x.lods)) {
+            const b = x.lods[e];
+            b.hash && (G += "?v=" + b.hash);
           }
-          const v = await V.loadAsync(R).catch((S) => (console.error(`Error loading LOD ${t} from ${u}
-`, S), null));
-          if (!v)
+          const _ = await Y.loadAsync(G).catch((b) => (console.error(`Error loading LOD ${e} from ${c}
+`, b), null));
+          if (!_)
             return null;
-          const $ = v.parser;
-          r && console.log("Loading finished " + u, L.guid);
-          let k = 0;
-          if (v.parser.json.textures) {
-            let S = !1;
-            for (const g of v.parser.json.textures) {
+          const K = _.parser;
+          r && console.log("Loading finished " + c, x.guid);
+          let F = 0;
+          if (_.parser.json.textures) {
+            let b = !1;
+            for (const g of _.parser.json.textures) {
               if (g != null && g.extensions) {
-                const h = g == null ? void 0 : g.extensions[F];
-                if (h != null && h.guid && h.guid === L.guid) {
-                  S = !0;
+                const h = g == null ? void 0 : g.extensions[N];
+                if (h != null && h.guid && h.guid === x.guid) {
+                  b = !0;
                   break;
                 }
               }
-              k++;
+              F++;
             }
-            if (S) {
-              let g = await $.getDependency("texture", k);
-              return g && _.assignLODInformation(n.url, g, i, t, void 0, void 0), r && console.log('change "' + e.name + '" → "' + g.name + '"', u, k, g, y), e instanceof q && (g = this.copySettings(e, g)), g && (g.guid = L.guid), p(g);
+            if (b) {
+              let g = await K.getDependency("texture", F);
+              return g && O.assignLODInformation(o.url, g, i, e, void 0, void 0), r && console.log('change "' + t.name + '" → "' + g.name + '"', c, F, g, y), t instanceof ee && (g = this.copySettings(t, g)), g && (g.guid = x.guid), p(g);
             } else
-              m && console.warn("Could not find texture with guid", L.guid, v.parser.json);
+              L && console.warn("Could not find texture with guid", x.guid, _.parser.json);
           }
-          if (k = 0, v.parser.json.meshes) {
-            let S = !1;
-            for (const g of v.parser.json.meshes) {
+          if (F = 0, _.parser.json.meshes) {
+            let b = !1;
+            for (const g of _.parser.json.meshes) {
               if (g != null && g.extensions) {
-                const h = g == null ? void 0 : g.extensions[F];
-                if (h != null && h.guid && h.guid === L.guid) {
-                  S = !0;
+                const h = g == null ? void 0 : g.extensions[N];
+                if (h != null && h.guid && h.guid === x.guid) {
+                  b = !0;
                   break;
                 }
               }
-              k++;
+              F++;
             }
-            if (S) {
-              const g = await $.getDependency("mesh", k), h = L;
-              if (r && console.log(`Loaded Mesh "${g.name}"`, u, k, g, y), g.isMesh === !0) {
-                const D = g.geometry;
-                return _.assignLODInformation(n.url, D, i, t, void 0, h.density), p(D);
+            if (b) {
+              const g = await K.getDependency("mesh", F), h = x;
+              if (r && console.log(`Loaded Mesh "${g.name}"`, c, F, g, y), g.isMesh === !0) {
+                const w = g.geometry;
+                return O.assignLODInformation(o.url, w, i, e, void 0, h.density), p(w);
               } else {
-                const D = new Array();
-                for (let b = 0; b < g.children.length; b++) {
-                  const T = g.children[b];
-                  if (T.isMesh === !0) {
-                    const A = T.geometry;
-                    _.assignLODInformation(n.url, A, i, t, b, h.density), D.push(A);
+                const w = new Array();
+                for (let T = 0; T < g.children.length; T++) {
+                  const A = g.children[T];
+                  if (A.isMesh === !0) {
+                    const P = A.geometry;
+                    O.assignLODInformation(o.url, P, i, e, T, h.density), w.push(P);
                   }
                 }
-                return p(D);
+                return p(w);
               }
             } else
-              m && console.warn("Could not find mesh with guid", L.guid, v.parser.json);
+              L && console.warn("Could not find mesh with guid", x.guid, _.parser.json);
           }
           return p(null);
         });
-        return this.previouslyLoaded.set(y, B), await B;
-      } else if (e instanceof q) {
-        r && console.log("Load texture from uri: " + u);
-        const w = await new Ce().loadAsync(u);
-        return w ? (w.guid = s.guid, w.flipY = !1, w.needsUpdate = !0, w.colorSpace = e.colorSpace, r && console.log(s, w)) : m && console.warn("failed loading", u), w;
+        return this.previouslyLoaded.set(y, R), await R;
+      } else if (t instanceof ee) {
+        r && console.log("Load texture from uri: " + c);
+        const v = await new Ue().loadAsync(c);
+        return v ? (v.guid = s.guid, v.flipY = !1, v.needsUpdate = !0, v.colorSpace = t.colorSpace, r && console.log(s, v)) : L && console.warn("failed loading", c), v;
       }
     } else
-      m && console.warn(`Can not load LOD ${t}: no LOD info found for "${i}" ${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, r, n, i, s) {
-    if (!t)
+  static assignLODInformation(t, e, r, o, i, s) {
+    if (!e)
       return;
-    t.userData || (t.userData = {});
-    const o = new Ue(e, r, n, i, s);
-    t.userData.LODS = o;
+    e.userData || (e.userData = {});
+    const n = new rt(t, r, o, i, s);
+    e.userData.LODS = n;
   }
-  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 = t.clone(), m && console.warn(`Copying texture settings
-`, e.uuid, `
-`, t.uuid), 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;
+  static copySettings(t, e) {
+    return e = e.clone(), L && console.warn(`Copying texture settings
+`, t.uuid, `
+`, e.uuid), 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;
   }
 };
-let O = _;
+let S = O;
 /**
  * Register a texture with LOD information
  */
-d(O, "registerTexture", (e, t, r, n, i) => {
-  if (m && console.log("> Progressive: register texture", n, t.name, t.uuid, t, i), !t) {
-    m && console.error("gltf-progressive: Register texture without texture");
+d(S, "registerTexture", (t, e, r, 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[le] = i);
+  e.source && (e.source[xe] = i);
   const s = i.guid;
-  _.assignLODInformation(e, t, s, r, n, void 0), _.lodInfos.set(s, i), _.lowresCache.set(s, t);
+  O.assignLODInformation(t, e, s, r, o, void 0), O.lodInfos.set(s, i), O.lowresCache.set(s, e);
 }), /**
  * Register a mesh with LOD information
  */
-d(O, "registerMesh", (e, t, r, n, i, s) => {
-  var f;
-  m && console.log("> Progressive: register mesh", i, r.name, s, r.uuid, r);
-  const o = r.geometry;
-  if (!o) {
-    m && console.warn("gltf-progressive: Register mesh without geometry");
+d(S, "registerMesh", (t, e, r, o, i, s) => {
+  var u;
+  L && console.log("> Progressive: register mesh", i, r.name, s, r.uuid, r);
+  const n = r.geometry;
+  if (!n) {
+    L && console.warn("gltf-progressive: Register mesh without geometry");
     return;
   }
-  o.userData || (o.userData = {}), _.assignLODInformation(e, o, t, n, i, s.density), _.lodInfos.set(t, s);
-  let l = _.lowresCache.get(t);
-  l ? l.push(r.geometry) : l = [r.geometry], _.lowresCache.set(t, l), n > 0 && !pe(r) && Ve(r, o);
-  for (const c of z)
-    (f = c.onRegisteredNewMesh) == null || f.call(c, r, s);
+  n.userData || (n.userData = {}), O.assignLODInformation(t, n, e, o, i, s.density), O.lodInfos.set(e, s);
+  let l = O.lowresCache.get(e);
+  l ? l.push(r.geometry) : l = [r.geometry], O.lowresCache.set(e, l), o > 0 && !Oe(r) && et(r, n);
+  for (const f of X)
+    (u = f.onRegisteredNewMesh) == null || u.call(f, r, s);
 }), /** A map of key = asset uuid and value = LOD information */
-d(O, "lodInfos", /* @__PURE__ */ new Map()), /** cache of already loaded mesh lods */
-d(O, "previouslyLoaded", /* @__PURE__ */ new Map()), /** this contains the geometry/textures that were originally loaded */
-d(O, "lowresCache", /* @__PURE__ */ new Map());
-class Ue {
-  constructor(e, t, r, n, i) {
+d(S, "lodInfos", /* @__PURE__ */ new Map()), /** cache of already loaded mesh lods */
+d(S, "previouslyLoaded", /* @__PURE__ */ new Map()), /** this contains the geometry/textures that were originally loaded */
+d(S, "lowresCache", /* @__PURE__ */ new Map());
+class rt {
+  constructor(t, e, r, o, i) {
     d(this, "url");
     /** the key to lookup the LOD information */
     d(this, "key");
@@ -521,116 +529,124 @@ class Ue {
     d(this, "index");
     /** the mesh density */
     d(this, "density");
-    this.url = e, this.key = t, this.level = r, n != null && (this.index = n), i != null && (this.density = i);
+    this.url = t, this.key = e, this.level = r, o != null && (this.index = o), i != null && (this.density = i);
   }
 }
-const N = j("debugprogressive"), We = j("noprogressive"), ce = Symbol("Needle:LODSManager"), ue = Symbol("Needle:LODState"), U = Symbol("Needle:CurrentLOD"), E = { mesh_lod: -1, texture_lod: -1 }, P = class {
+const B = ae("debugprogressive"), st = ae("noprogressive"), Le = Symbol("Needle:LODSManager"), Me = Symbol("Needle:LODState"), H = Symbol("Needle:CurrentLOD"), k = { mesh_lod: -1, texture_lod: -1 };
+var C, U, ge, Q, Z, pe, W;
+const E = class {
   // readonly plugins: NEEDLE_progressive_plugin[] = [];
-  constructor(e, t) {
+  constructor(t, e) {
     d(this, "context");
     d(this, "renderer");
-    d(this, "projectionScreenMatrix", new ye());
-    d(this, "cameraFrustrum", new Be());
+    d(this, "projectionScreenMatrix", new be());
+    d(this, "cameraFrustrum", new We());
     /**
      * 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);
     /**
-     * The update interval in frames. If set to 0, the LODs will be updated every frame. If set to 1, the LODs will be updated every second frame, etc.
+     * 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.
      */
-    d(this, "updateInterval", 0);
+    d(this, "updateInterval", "auto");
+    q(this, C, 1);
     /**
      * If set to true, the LODsManager will not update the LODs.
      */
     d(this, "pause", !1);
     d(this, "_lodchangedlisteners", []);
-    d(this, "_frame", 0);
-    d(this, "_originalRender");
+    q(this, U, void 0);
+    q(this, ge, new Ke());
+    q(this, Q, 0);
+    q(this, Z, 0);
+    q(this, pe, 0);
+    q(this, W, 0);
+    d(this, "_fpsBuffer", [60, 60, 60, 60, 60]);
     // private testIfLODLevelsAreAvailable() {
-    d(this, "_sphere", new Re());
-    d(this, "_tempBox", new me());
-    d(this, "_tempBox2", new me());
-    d(this, "tempMatrix", new ye());
-    d(this, "_tempWorldPosition", new G());
-    d(this, "_tempBoxSize", new G());
-    d(this, "_tempBox2Size", new G());
-    this.renderer = e, this.context = { ...t };
+    d(this, "_sphere", new Xe());
+    d(this, "_tempBox", new Te());
+    d(this, "_tempBox2", new Te());
+    d(this, "tempMatrix", new be());
+    d(this, "_tempWorldPosition", new V());
+    d(this, "_tempBoxSize", new V());
+    d(this, "_tempBox2Size", new V());
+    this.renderer = t, this.context = { ...e };
   }
   /** @internal */
-  static getObjectLODState(e) {
-    return e[ue];
+  static getObjectLODState(t) {
+    return t[Me];
   }
-  static addPlugin(e) {
-    z.push(e);
+  static addPlugin(t) {
+    X.push(t);
   }
-  static removePlugin(e) {
-    const t = z.indexOf(e);
-    t >= 0 && z.splice(t, 1);
+  static removePlugin(t) {
+    const e = X.indexOf(t);
+    e >= 0 && X.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[ce])
-      return console.debug("[gltf-progressive] LODsManager already exists for this renderer"), e[ce];
-    const r = new P(e, {
+  static get(t, e) {
+    if (t[Le])
+      return console.debug("[gltf-progressive] LODsManager already exists for this renderer"), t[Le];
+    const r = new E(t, {
       engine: "unknown",
-      ...t
+      ...e
     });
-    return e[ce] = r, r;
+    return t[Le] = r, r;
   }
   /** @deprecated use static `LODsManager.addPlugin()` method. This getter will be removed in later versions */
   get plugins() {
-    return z;
+    return X;
   }
-  addEventListener(e, t) {
-    e === "changed" && this._lodchangedlisteners.push(t);
+  addEventListener(t, e) {
+    t === "changed" && this._lodchangedlisteners.push(e);
   }
   /**
    * Enable the LODsManager. This will replace the render method of the renderer with a method that updates the LODs.
    */
   enable() {
-    if (this._originalRender)
+    if (m(this, U))
       return;
     console.debug("[gltf-progressive] Enabling LODsManager for renderer");
-    let e = 0;
-    this._originalRender = this.renderer.render;
-    const t = this;
-    ve(this.renderer), this.renderer.render = function(r, n) {
-      t.renderer.getRenderTarget() == null && (e = 0, t._frame += 1);
-      const s = t._frame, o = e++;
-      t.onBeforeRender(r, n, o, s), t._originalRender.call(this, r, n), t.onAfterRender(r, n, o, s);
+    let t = 0;
+    $(this, U, this.renderer.render);
+    const e = this;
+    ke(this.renderer), this.renderer.render = function(r, o) {
+      e.renderer.getRenderTarget() == null && (t = 0, $(e, Q, m(e, Q) + 1), $(e, Z, m(e, ge).getDelta()), $(e, pe, m(e, pe) + m(e, Z)), e._fpsBuffer.shift(), e._fpsBuffer.push(1 / m(e, Z)), $(e, W, e._fpsBuffer.reduce((l, u) => l + u) / e._fpsBuffer.length), B && m(e, Q) % 30 === 0 && console.log("FPS", Math.round(m(e, W)), "Interval:", m(e, C)));
+      const s = m(e, Q), n = t++;
+      e.onBeforeRender(r, o, n, s), m(e, U).call(this, r, o), e.onAfterRender(r, o, n, s);
     };
   }
   disable() {
-    this._originalRender && (this.renderer.render = this._originalRender, this._originalRender = void 0);
+    m(this, U) && (this.renderer.render = m(this, U), $(this, U, void 0));
   }
-  onBeforeRender(e, t, r, n) {
+  onBeforeRender(t, e, r, o) {
   }
-  onAfterRender(e, t, r, n) {
-    var l, f;
+  onAfterRender(t, e, r, o) {
+    var l, u;
     if (this.pause)
       return;
-    const i = this.renderer.renderLists.get(e, 0), s = i.opaque;
-    let o = !0;
+    const i = this.renderer.renderLists.get(t, 0), s = i.opaque;
+    let n = !0;
     if (s.length === 1) {
-      const c = s[0].material;
-      (c.name === "EffectMaterial" || c.name === "CopyShader") && (o = !1);
+      const f = s[0].material;
+      (f.name === "EffectMaterial" || f.name === "CopyShader") && (n = !1);
     }
-    if ((t.parent && t.parent.type === "CubeCamera" || r >= 1 && t.type === "OrthographicCamera") && (o = !1), o) {
-      if (We || this.updateInterval > 0 && n % this.updateInterval != 0)
+    if ((e.parent && e.parent.type === "CubeCamera" || r >= 1 && e.type === "OrthographicCamera") && (n = !1), n) {
+      if (st || (this.updateInterval === "auto" ? m(this, W) < 40 && m(this, C) < 10 ? ($(this, C, m(this, C) + 1), B && console.warn("↓ Reducing LOD updates", m(this, C), m(this, W).toFixed(0))) : m(this, W) >= 80 && m(this, C) > 1 && ($(this, C, m(this, C) - 1), B && console.warn("↑ Increasing LOD updates", m(this, C), m(this, W).toFixed(0))) : $(this, C, this.updateInterval), m(this, C) > 0 && o % m(this, C) != 0))
         return;
-      this.projectionScreenMatrix.multiplyMatrices(t.projectionMatrix, t.matrixWorldInverse), this.cameraFrustrum.setFromProjectionMatrix(this.projectionScreenMatrix, this.renderer.coordinateSystem);
-      const c = this.targetTriangleDensity;
-      for (const u of s) {
-        if (u.material && (((l = u.geometry) == null ? void 0 : l.type) === "BoxGeometry" || ((f = u.geometry) == null ? void 0 : f.type) === "BufferGeometry") && (u.material.name === "SphericalGaussianBlur" || u.material.name == "BackgroundCubeMaterial" || u.material.name === "CubemapFromEquirect" || u.material.name === "EquirectangularToCubeUV")) {
-          N && (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)));
+      this.projectionScreenMatrix.multiplyMatrices(e.projectionMatrix, e.matrixWorldInverse), this.cameraFrustrum.setFromProjectionMatrix(this.projectionScreenMatrix, this.renderer.coordinateSystem);
+      const f = this.targetTriangleDensity;
+      for (const c of s) {
+        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")) {
+          B && (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)));
           continue;
         }
-        switch (u.material.type) {
+        switch (c.material.type) {
           case "LineBasicMaterial":
           case "LineDashedMaterial":
           case "PointsMaterial":
@@ -639,51 +655,56 @@ const N = j("debugprogressive"), We = j("noprogressive"), ce = Symbol("Needle:LO
           case "MeshDepthMaterial":
             continue;
         }
-        const y = u.object;
-        (y instanceof W || y.isMesh) && this.updateLODs(e, t, y, c, n);
+        if (B === "color" && c.material && !c.object.progressive_debug_color) {
+          c.object.progressive_debug_color = !0;
+          const v = Math.random() * 16777215, x = new qe({ color: v });
+          c.object.material = x;
+        }
+        const y = c.object;
+        (y instanceof J || y.isMesh) && this.updateLODs(t, e, y, f, o);
       }
-      const x = i.transparent;
-      for (const u of x) {
-        const y = u.object;
-        (y instanceof W || y.isMesh) && this.updateLODs(e, t, y, c, n);
+      const M = i.transparent;
+      for (const c of M) {
+        const y = c.object;
+        (y instanceof J || y.isMesh) && this.updateLODs(t, e, y, f, o);
       }
     }
   }
   /** Update the LOD levels for the renderer. */
-  updateLODs(e, t, r, n, i) {
-    var l, f;
+  updateLODs(t, e, r, o, i) {
+    var l, u;
     r.userData || (r.userData = {});
-    let s = r[ue];
-    if (s || (s = new Ke(), r[ue] = s), s.frames++ < 2)
+    let s = r[Me];
+    if (s || (s = new it(), r[Me] = s), s.frames++ < 2)
       return;
-    for (const c of z)
-      (l = c.onBeforeUpdateLOD) == null || l.call(c, this.renderer, e, t, r);
-    this.calculateLodLevel(t, r, s, n, 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);
-    let o = E.texture_lod;
-    if (r.material && o >= 0) {
-      const c = r["DEBUG:LOD"];
-      c != null && (o = c), this.loadProgressiveTextures(r.material, o);
+    for (const f of X)
+      (l = f.onBeforeUpdateLOD) == null || l.call(f, this.renderer, t, e, r);
+    this.calculateLodLevel(e, r, s, o, k), k.mesh_lod = Math.round(k.mesh_lod), k.texture_lod = Math.round(k.texture_lod), k.mesh_lod >= 0 && this.loadProgressiveMeshes(r, k.mesh_lod);
+    let n = k.texture_lod;
+    if (r.material && n >= 0) {
+      const f = r["DEBUG:LOD"];
+      f != null && (n = f), this.loadProgressiveTextures(r.material, n);
     }
-    for (const c of z)
-      (f = c.onAfterUpdatedLOD) == null || f.call(c, this.renderer, e, t, r, E);
-    s.lastLodLevel_Mesh = E.mesh_lod, s.lastLodLevel_Texture = E.texture_lod;
+    for (const f of X)
+      (u = f.onAfterUpdatedLOD) == null || u.call(f, this.renderer, t, e, r, k);
+    s.lastLodLevel_Mesh = k.mesh_lod, s.lastLodLevel_Texture = k.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 n of e)
-        this.loadProgressiveTextures(n, t);
+    if (Array.isArray(t)) {
+      for (const o of t)
+        this.loadProgressiveTextures(o, e);
       return;
     }
     let r = !1;
-    (e[U] === void 0 || t < e[U]) && (r = !0), r && (e[U] = t, O.assignTextureLOD(e, t).then((n) => {
-      this._lodchangedlisteners.forEach((i) => i({ type: "texture", level: t, object: e }));
+    (t[H] === void 0 || e < t[H]) && (r = !0), r && (t[H] = e, S.assignTextureLOD(t, e).then((o) => {
+      this._lodchangedlisteners.forEach((i) => i({ type: "texture", level: e, object: t }));
     }));
   }
   /** Load progressive meshes for the given mesh
@@ -692,117 +713,117 @@ const N = j("debugprogressive"), We = j("noprogressive"), ce = Symbol("Needle:LO
    * @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);
-    if (e[U] !== t) {
-      e[U] = t;
-      const r = e.geometry;
-      return O.assignMeshLOD(e, t).then((n) => (n && e[U] == t && r != e.geometry && this._lodchangedlisteners.forEach((i) => i({ type: "mesh", level: t, object: e })), n));
+    if (t[H] !== e) {
+      t[H] = e;
+      const r = t.geometry;
+      return S.assignMeshLOD(t, e).then((o) => (o && t[H] == e && r != t.geometry && this._lodchangedlisteners.forEach((i) => i({ type: "mesh", level: e, object: t })), o));
     }
     return Promise.resolve(null);
   }
-  static isInside(e, t) {
-    const r = e.min, n = e.max, i = (r.x + n.x) * 0.5, s = (r.y + n.y) * 0.5;
-    return this._tempPtInside.set(i, s, r.z).applyMatrix4(t).z < 0;
+  static isInside(t, e) {
+    const r = t.min, o = t.max, i = (r.x + o.x) * 0.5, s = (r.y + o.y) * 0.5;
+    return this._tempPtInside.set(i, s, r.z).applyMatrix4(e).z < 0;
   }
-  calculateLodLevel(e, t, r, n, i) {
-    var B, I;
-    if (!t) {
+  calculateLodLevel(t, e, r, o, i) {
+    var R, z;
+    if (!e) {
       i.mesh_lod = -1, i.texture_lod = -1;
       return;
     }
-    if (!e) {
+    if (!t) {
       i.mesh_lod = -1, i.texture_lod = -1;
       return;
     }
-    let o = 10 + 1, l = !1;
-    if (N && t["DEBUG:LOD"] != null)
-      return t["DEBUG:LOD"];
-    const f = O.getMeshLODInformation(t.geometry), c = f == null ? void 0 : f.lods, x = c && c.length > 0, u = O.getMaterialMinMaxLODsCount(t.material), y = (u == null ? void 0 : u.min_count) != 1 / 0 && u.min_count > 0 && u.max_count > 0;
-    if (!x && !y) {
+    let n = 10 + 1, l = !1;
+    if (B && e["DEBUG:LOD"] != null)
+      return e["DEBUG:LOD"];
+    const u = S.getMeshLODInformation(e.geometry), f = u == null ? void 0 : u.lods, M = f && f.length > 0, c = S.getMaterialMinMaxLODsCount(e.material), y = (c == null ? void 0 : c.min_count) != 1 / 0 && c.min_count > 0 && c.max_count > 0;
+    if (!M && !y) {
       i.mesh_lod = 0, i.texture_lod = 0;
       return;
     }
-    if (x || (l = !0, o = 0), !((B = this.cameraFrustrum) != null && B.intersectsObject(t))) {
+    if (M || (l = !0, n = 0), !((R = this.cameraFrustrum) != null && R.intersectsObject(e))) {
       i.mesh_lod = 99, i.texture_lod = 99;
       return;
     }
-    const w = this.renderer.domElement.clientHeight || this.renderer.domElement.height;
-    let L = t.geometry.boundingBox;
-    if (t.type === "SkinnedMesh") {
-      const p = t;
-      p.boundingBox || p.computeBoundingBox(), L = p.boundingBox;
-    }
-    if (L && e.isPerspectiveCamera) {
+    const v = this.renderer.domElement.clientHeight || this.renderer.domElement.height;
+    let x = e.geometry.boundingBox;
+    if (e.type === "SkinnedMesh") {
       const p = 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 h = e.getWorldPosition(this._tempWorldPosition);
+      p.boundingBox || p.computeBoundingBox(), x = p.boundingBox;
+    }
+    if (x && t.isPerspectiveCamera) {
+      const p = t;
+      if (e.geometry.attributes.color && e.geometry.attributes.color.count < 100 && e.geometry.boundingSphere) {
+        this._sphere.copy(e.geometry.boundingSphere), this._sphere.applyMatrix4(e.matrixWorld);
+        const h = t.getWorldPosition(this._tempWorldPosition);
         if (this._sphere.containsPoint(h)) {
           i.mesh_lod = 0, i.texture_lod = 0;
           return;
         }
       }
-      if (this._tempBox.copy(L), this._tempBox.applyMatrix4(t.matrixWorld), P.isInside(this._tempBox, this.projectionScreenMatrix)) {
+      if (this._tempBox.copy(x), this._tempBox.applyMatrix4(e.matrixWorld), E.isInside(this._tempBox, this.projectionScreenMatrix)) {
         i.mesh_lod = 0, i.texture_lod = 0;
         return;
       }
       if (this._tempBox.applyMatrix4(this.projectionScreenMatrix), this.renderer.xr.enabled && p.fov > 70) {
-        const h = this._tempBox.min, D = this._tempBox.max;
-        let b = h.x, T = h.y, A = D.x, K = D.y;
-        const ee = 2, oe = 1.5, te = (h.x + D.x) * 0.5, re = (h.y + D.y) * 0.5;
-        b = (b - te) * ee + te, T = (T - re) * ee + re, A = (A - te) * ee + te, K = (K - re) * ee + re;
-        const be = b < 0 && A > 0 ? 0 : Math.min(Math.abs(h.x), Math.abs(D.x)), Te = T < 0 && K > 0 ? 0 : Math.min(Math.abs(h.y), Math.abs(D.y)), ae = Math.max(be, Te);
-        r.lastCentrality = (oe - ae) * (oe - ae) * (oe - ae);
+        const h = this._tempBox.min, w = this._tempBox.max;
+        let T = h.x, A = h.y, P = w.x, j = w.y;
+        const le = 2, ye = 1.5, ce = (h.x + w.x) * 0.5, ue = (h.y + w.y) * 0.5;
+        T = (T - ce) * le + ce, A = (A - ue) * le + ue, P = (P - ce) * le + ce, j = (j - ue) * le + ue;
+        const Fe = T < 0 && P > 0 ? 0 : Math.min(Math.abs(h.x), Math.abs(w.x)), $e = A < 0 && j > 0 ? 0 : Math.min(Math.abs(h.y), Math.abs(w.y)), me = Math.max(Fe, $e);
+        r.lastCentrality = (ye - me) * (ye - me) * (ye - me);
       } else
         r.lastCentrality = 1;
-      const M = this._tempBox.getSize(this._tempBoxSize);
-      M.multiplyScalar(0.5), screen.availHeight > 0 && w > 0 && M.multiplyScalar(w / screen.availHeight), M.x *= p.aspect;
-      const V = e.matrixWorldInverse, R = this._tempBox2;
-      R.copy(L), R.applyMatrix4(t.matrixWorld), R.applyMatrix4(V);
-      const v = R.getSize(this._tempBox2Size), $ = Math.max(v.x, v.y);
-      if (Math.max(M.x, M.y) != 0 && $ != 0 && (M.z = v.z / Math.max(v.x, v.y) * Math.max(M.x, M.y)), r.lastScreenCoverage = Math.max(M.x, M.y, M.z), r.lastScreenspaceVolume.copy(M), r.lastScreenCoverage *= r.lastCentrality, N && P.debugDrawLine) {
+      const D = this._tempBox.getSize(this._tempBoxSize);
+      D.multiplyScalar(0.5), screen.availHeight > 0 && v > 0 && D.multiplyScalar(v / screen.availHeight), D.x *= p.aspect;
+      const Y = t.matrixWorldInverse, G = this._tempBox2;
+      G.copy(x), G.applyMatrix4(e.matrixWorld), G.applyMatrix4(Y);
+      const _ = G.getSize(this._tempBox2Size), K = Math.max(_.x, _.y);
+      if (Math.max(D.x, D.y) != 0 && K != 0 && (D.z = _.z / Math.max(_.x, _.y) * Math.max(D.x, D.y)), r.lastScreenCoverage = Math.max(D.x, D.y, D.z), r.lastScreenspaceVolume.copy(D), r.lastScreenCoverage *= r.lastCentrality, B && E.debugDrawLine) {
         const h = this.tempMatrix.copy(this.projectionScreenMatrix);
         h.invert();
-        const D = P.corner0, b = P.corner1, T = P.corner2, A = P.corner3;
-        D.copy(this._tempBox.min), b.copy(this._tempBox.max), b.x = D.x, T.copy(this._tempBox.max), T.y = D.y, A.copy(this._tempBox.max);
-        const K = (D.z + A.z) * 0.5;
-        D.z = b.z = T.z = A.z = K, D.applyMatrix4(h), b.applyMatrix4(h), T.applyMatrix4(h), A.applyMatrix4(h), P.debugDrawLine(D, b, 255), P.debugDrawLine(D, T, 255), P.debugDrawLine(b, A, 255), P.debugDrawLine(T, A, 255);
+        const w = E.corner0, T = E.corner1, A = E.corner2, P = E.corner3;
+        w.copy(this._tempBox.min), T.copy(this._tempBox.max), T.x = w.x, A.copy(this._tempBox.max), A.y = w.y, P.copy(this._tempBox.max);
+        const j = (w.z + P.z) * 0.5;
+        w.z = T.z = A.z = P.z = j, w.applyMatrix4(h), T.applyMatrix4(h), A.applyMatrix4(h), P.applyMatrix4(h), E.debugDrawLine(w, T, 255), E.debugDrawLine(w, A, 255), E.debugDrawLine(T, P, 255), E.debugDrawLine(A, P, 255);
       }
-      let S = 999;
-      if (c && r.lastScreenCoverage > 0) {
-        for (let h = 0; h < c.length; h++)
-          if (c[h].density / r.lastScreenCoverage < n) {
-            S = h;
+      let b = 999;
+      if (f && r.lastScreenCoverage > 0) {
+        for (let h = 0; h < f.length; h++)
+          if (f[h].density / r.lastScreenCoverage < o) {
+            b = h;
             break;
           }
       }
-      S < o && (o = S, l = !0);
+      b < n && (n = b, l = !0);
     }
-    if (l ? i.mesh_lod = o : i.mesh_lod = r.lastLodLevel_Mesh, N && i.mesh_lod != r.lastLodLevel_Mesh) {
-      const M = c == null ? void 0 : c[i.mesh_lod];
-      M && console.log(`Mesh LOD changed: ${r.lastLodLevel_Mesh} → ${i.mesh_lod} (${M.density.toFixed(0)}) - ${t.name}`);
+    if (l ? i.mesh_lod = n : i.mesh_lod = r.lastLodLevel_Mesh, B && i.mesh_lod != r.lastLodLevel_Mesh) {
+      const D = f == null ? void 0 : f[i.mesh_lod];
+      D && console.log(`Mesh LOD changed: ${r.lastLodLevel_Mesh} → ${i.mesh_lod} (${D.density.toFixed(0)}) - ${e.name}`);
     }
     if (y)
       if (r.lastLodLevel_Texture < 0) {
-        if (i.texture_lod = u.max_count - 1, N) {
-          const p = u.lods[u.max_count - 1];
-          N && console.log(`First Texture LOD ${i.texture_lod} (${p.max_height}px) - ${t.name}`);
+        if (i.texture_lod = c.max_count - 1, B) {
+          const p = c.lods[c.max_count - 1];
+          B && console.log(`First Texture LOD ${i.texture_lod} (${p.max_height}px) - ${e.name}`);
         }
       } else {
         const p = r.lastScreenspaceVolume.x + r.lastScreenspaceVolume.y + r.lastScreenspaceVolume.z;
-        let M = r.lastScreenCoverage * 2;
-        ((I = this.context) == null ? void 0 : I.engine) === "model-viewer" && (M *= 2);
-        const R = w / window.devicePixelRatio * M;
-        for (let v = u.lods.length - 1; v >= 0; v--) {
-          let $ = u.lods[v];
-          if (!(ze() && $.max_height > 4096) && $.max_height > R) {
-            if (i.texture_lod = v, i.texture_lod < r.lastLodLevel_Texture) {
-              const k = $.max_height;
-              N && console.log(`Texture LOD changed: ${r.lastLodLevel_Texture} → ${i.texture_lod} = ${k}px 
-Screensize: ${R.toFixed(0)}px, Coverage: ${(100 * r.lastScreenCoverage).toFixed(2)}%, Volume ${p.toFixed(1)} 
-${t.name}`);
+        let D = r.lastScreenCoverage * 2;
+        ((z = this.context) == null ? void 0 : z.engine) === "model-viewer" && (D *= 2);
+        const G = v / window.devicePixelRatio * D;
+        for (let _ = c.lods.length - 1; _ >= 0; _--) {
+          let K = c.lods[_];
+          if (!(je() && K.max_height > 4096) && K.max_height > G) {
+            if (i.texture_lod = _, i.texture_lod < r.lastLodLevel_Texture) {
+              const F = K.max_height;
+              B && console.log(`Texture LOD changed: ${r.lastLodLevel_Texture} → ${i.texture_lod} = ${F}px 
+Screensize: ${G.toFixed(0)}px, Coverage: ${(100 * r.lastScreenCoverage).toFixed(2)}%, Volume ${p.toFixed(1)} 
+${e.name}`);
             }
             break;
           }
@@ -812,63 +833,63 @@ ${t.name}`);
       i.texture_lod = 0;
   }
 };
-let C = P;
-/** 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 = E;
+C = new WeakMap(), U = new WeakMap(), ge = new WeakMap(), Q = new WeakMap(), Z = new WeakMap(), pe = new WeakMap(), W = 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(C, "debugDrawLine"), d(C, "corner0", new G()), d(C, "corner1", new G()), d(C, "corner2", new G()), d(C, "corner3", new G()), d(C, "_tempPtInside", new G());
-class Ke {
+d(I, "debugDrawLine"), d(I, "corner0", new V()), d(I, "corner1", new V()), d(I, "corner2", new V()), d(I, "corner3", new V()), d(I, "_tempPtInside", new V());
+class it {
   constructor() {
     d(this, "frames", 0);
     d(this, "lastLodLevel_Mesh", -1);
     d(this, "lastLodLevel_Texture", -1);
     d(this, "lastScreenCoverage", 0);
-    d(this, "lastScreenspaceVolume", new G());
+    d(this, "lastScreenspaceVolume", new V());
     d(this, "lastCentrality", 0);
   }
 }
-const Le = Symbol("NEEDLE_mesh_lod"), se = Symbol("NEEDLE_texture_lod");
-let H = null;
-function Oe() {
-  const a = qe();
-  a && (a.mapURLs(function(e) {
-    return Me(), e;
-  }), Me(), H == null || H.disconnect(), H = new MutationObserver((e) => {
-    e.forEach((t) => {
-      t.addedNodes.forEach((r) => {
-        r instanceof HTMLElement && r.tagName.toLowerCase() === "model-viewer" && Se(r);
+const Pe = Symbol("NEEDLE_mesh_lod"), fe = Symbol("NEEDLE_texture_lod");
+let se = null;
+function Re() {
+  const a = ot();
+  a && (a.mapURLs(function(t) {
+    return Ee(), t;
+  }), Ee(), se == null || se.disconnect(), se = new MutationObserver((t) => {
+    t.forEach((e) => {
+      e.addedNodes.forEach((r) => {
+        r instanceof HTMLElement && r.tagName.toLowerCase() === "model-viewer" && Ge(r);
       });
     });
-  }), H.observe(document, { childList: !0, subtree: !0 }));
+  }), se.observe(document, { childList: !0, subtree: !0 }));
 }
-function qe() {
+function ot() {
   const a = customElements.get("model-viewer");
   return a || (customElements.whenDefined("model-viewer").then(() => {
-    console.debug("[gltf-progressive] model-viewer defined"), Oe();
+    console.debug("[gltf-progressive] model-viewer defined"), Re();
   }), null);
 }
-function Me() {
-  document.querySelectorAll("model-viewer").forEach((e) => {
-    Se(e);
+function Ee() {
+  document.querySelectorAll("model-viewer").forEach((t) => {
+    Ge(t);
   });
 }
-const De = /* @__PURE__ */ new WeakSet();
-let Xe = 0;
-function Se(a) {
-  if (!a || De.has(a))
+const Ce = /* @__PURE__ */ new WeakSet();
+let nt = 0;
+function Ge(a) {
+  if (!a || Ce.has(a))
     return null;
-  De.add(a), console.debug("[gltf-progressive] found new model-viewer..." + ++Xe + `
+  Ce.add(a), console.debug("[gltf-progressive] found new model-viewer..." + ++nt + `
 `, a.getAttribute("src"));
-  let e = null, t = null, r = null;
-  for (let n = a; n != null; n = Object.getPrototypeOf(n)) {
-    const i = Object.getOwnPropertySymbols(n), s = i.find((f) => f.toString() == "Symbol(renderer)"), o = i.find((f) => f.toString() == "Symbol(scene)"), l = i.find((f) => f.toString() == "Symbol(needsRender)");
-    !e && s != null && (e = a[s].threeRenderer), !t && o != null && (t = a[o]), !r && l != null && (r = a[l]);
+  let t = null, e = null, r = null;
+  for (let o = a; o != null; o = Object.getPrototypeOf(o)) {
+    const i = Object.getOwnPropertySymbols(o), s = i.find((u) => u.toString() == "Symbol(renderer)"), n = i.find((u) => u.toString() == "Symbol(scene)"), l = i.find((u) => u.toString() == "Symbol(needsRender)");
+    !t && s != null && (t = a[s].threeRenderer), !e && n != null && (e = a[n]), !r && l != null && (r = a[l]);
   }
-  if (e && t) {
-    let n = function() {
+  if (t && e) {
+    let o = function() {
       if (r) {
-        let s = 0, o = setInterval(() => {
+        let s = 0, n = setInterval(() => {
           if (s++ > 5) {
-            clearInterval(o);
+            clearInterval(n);
             return;
           }
           r == null || r.call(a);
@@ -876,109 +897,109 @@ function Se(a) {
       }
     };
     console.debug("[gltf-progressive] setup model-viewer");
-    const i = C.get(e, { engine: "model-viewer" });
-    return C.addPlugin(new Ye()), i.enable(), i.addEventListener("changed", () => {
+    const i = I.get(t, { engine: "model-viewer" });
+    return I.addPlugin(new at()), i.enable(), i.addEventListener("changed", () => {
       r == null || r.call(a);
     }), a.addEventListener("model-visibility", (s) => {
       s.detail.visible && (r == null || r.call(a));
     }), a.addEventListener("load", () => {
-      n();
+      o();
     }), () => {
       i.disable();
     };
   }
   return null;
 }
-class Ye {
+class at {
   constructor() {
     d(this, "_didWarnAboutMissingUrl", !1);
   }
-  onBeforeUpdateLOD(e, t, r, n) {
-    this.tryParseMeshLOD(t, n), this.tryParseTextureLOD(t, n);
+  onBeforeUpdateLOD(t, e, r, 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[se] == !0)
+  tryParseTextureLOD(t, e) {
+    if (e[fe] == !0)
       return;
-    t[se] = !0;
-    const r = this.tryGetCurrentGLTF(e), n = this.tryGetCurrentModelViewer(e), i = this.getUrl(n);
-    if (i && r && t.material) {
+    e[fe] = !0;
+    const r = this.tryGetCurrentGLTF(t), o = this.tryGetCurrentModelViewer(t), i = this.getUrl(o);
+    if (i && r && e.material) {
       let s = function(l) {
-        var c, x, u;
-        if (l[se] == !0)
+        var f, M, c;
+        if (l[fe] == !0)
           return;
-        l[se] = !0, l.userData && (l.userData.LOD = -1);
-        const f = Object.keys(l);
-        for (let y = 0; y < f.length; y++) {
-          const w = f[y], L = l[w];
-          if ((L == null ? void 0 : L.isTexture) === !0) {
-            const B = (x = (c = L.userData) == null ? void 0 : c.associations) == null ? void 0 : x.textures;
-            if (B == null)
+        l[fe] = !0, l.userData && (l.userData.LOD = -1);
+        const u = Object.keys(l);
+        for (let y = 0; y < u.length; y++) {
+          const v = u[y], x = l[v];
+          if ((x == null ? void 0 : x.isTexture) === !0) {
+            const R = (M = (f = x.userData) == null ? void 0 : f.associations) == null ? void 0 : M.textures;
+            if (R == null)
               continue;
-            const I = r.parser.json.textures[B];
-            if (!I) {
-              console.warn("Texture data not found for texture index " + B);
+            const z = r.parser.json.textures[R];
+            if (!z) {
+              console.warn("Texture data not found for texture index " + R);
               continue;
             }
-            if ((u = I == null ? void 0 : I.extensions) != null && u[F]) {
-              const p = I.extensions[F];
-              p && i && O.registerTexture(i, L, p.lods.length, B, p);
+            if ((c = z == null ? void 0 : z.extensions) != null && c[N]) {
+              const p = z.extensions[N];
+              p && i && S.registerTexture(i, x, p.lods.length, R, p);
             }
           }
         }
       };
-      const o = t.material;
-      if (Array.isArray(o))
-        for (const l of o)
+      const n = e.material;
+      if (Array.isArray(n))
+        for (const l of n)
           s(l);
       else
-        s(o);
+        s(n);
     }
   }
-  tryParseMeshLOD(e, t) {
-    var s, o;
-    if (t[Le] == !0)
+  tryParseMeshLOD(t, e) {
+    var s, n;
+    if (e[Pe] == !0)
       return;
-    t[Le] = !0;
-    const r = this.tryGetCurrentModelViewer(e), n = this.getUrl(r);
-    if (!n)
+    e[Pe] = !0;
+    const r = this.tryGetCurrentModelViewer(t), o = this.getUrl(r);
+    if (!o)
       return;
-    const i = (o = (s = t.userData) == null ? void 0 : s.gltfExtensions) == null ? void 0 : o[F];
-    if (i && n) {
-      const l = t.uuid;
-      O.registerMesh(n, l, t, 0, i.lods.length, i);
+    const i = (n = (s = e.userData) == null ? void 0 : s.gltfExtensions) == null ? void 0 : n[N];
+    if (i && o) {
+      const l = e.uuid;
+      S.registerMesh(o, l, e, 0, i.lods.length, i);
     }
   }
 }
-function it(a, e, t, r) {
-  ve(e), _e(t), t.register((i) => new O(i, a));
-  const n = C.get(e);
-  return (r == null ? void 0 : r.enableLODsManager) !== !1 && n.enable(), n;
+function mt(a, t, e, r) {
+  ke(t), Ie(e), e.register((i) => new S(i, a));
+  const o = I.get(t);
+  return (r == null ? void 0 : r.enableLODsManager) !== !1 && o.enable(), o;
 }
-Oe();
+Re();
 export {
-  F as EXTENSION_NAME,
-  C as LODsManager,
-  O as NEEDLE_progressive,
-  we as VERSION,
-  _e as addDracoAndKTX2Loaders,
-  ve as createLoaders,
-  pe as getRaycastMesh,
-  Oe as patchModelViewer,
-  tt as setDracoDecoderLocation,
-  rt as setKTX2TranscoderLocation,
-  Ve as setRaycastMesh,
-  it as useNeedleProgressive,
-  st as useRaycastMeshes
+  N as EXTENSION_NAME,
+  I as LODsManager,
+  S as NEEDLE_progressive,
+  Be as VERSION,
+  Ie as addDracoAndKTX2Loaders,
+  ke as createLoaders,
+  Oe as getRaycastMesh,
+  Re as patchModelViewer,
+  gt as setDracoDecoderLocation,
+  pt as setKTX2TranscoderLocation,
+  et as setRaycastMesh,
+  mt as useNeedleProgressive,
+  yt as useRaycastMeshes
 };