@needle-tools/gltf-progressive 1.0.0-alpha.8 → 1.1.0-alpha

package/gltf-progressive.js

@@ -1,74 +1,86 @@
-var oe = Object.defineProperty;
-var ae = (l, e, t) => e in l ? oe(l, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : l[e] = t;
-var u = (l, e, t) => (ae(l, typeof e != "symbol" ? e + "" : e, t), t);
-import { Mesh as q, BufferGeometry as X, Material as le, RawShaderMaterial as ue, Texture as U, TextureLoader as ce, Matrix4 as j, Frustum as fe, Sphere as de, Box3 as ee, Vector3 as k } from "three";
-import { GLTFLoader as ge } from "three/examples/jsm/loaders/GLTFLoader.js";
-import { MeshoptDecoder as he } from "three/examples/jsm/libs/meshopt_decoder.module.js";
-import { DRACOLoader as pe } from "three/examples/jsm/loaders/DRACOLoader.js";
-import { KTX2Loader as ye } from "three/examples/jsm/loaders/KTX2Loader.js";
-const me = "https://www.gstatic.com/draco/versioned/decoders/1.4.1/", Le = "https://www.gstatic.com/basis-universal/versioned/2021-04-15-ba1c3e4/";
-let F, H, W;
-function se(l) {
-  F || (F = new pe(), F.setDecoderPath(me), F.setDecoderConfig({ type: "js" })), W || (W = new ye(), W.setTranscoderPath(Le)), H || (H = he), l ? W.detectSupport(l) : console.warn("No renderer provided to detect ktx2 support - loading KTX2 textures will probably fail");
+var ge = Object.defineProperty;
+var pe = (a, e, t) => e in a ? ge(a, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : a[e] = t;
+var f = (a, e, t) => (pe(a, typeof e != "symbol" ? e + "" : e, t), t);
+import { MeshoptDecoder as ye } from "three/examples/jsm/libs/meshopt_decoder.module.js";
+import { DRACOLoader as me } from "three/examples/jsm/loaders/DRACOLoader.js";
+import { KTX2Loader as Le } from "three/examples/jsm/loaders/KTX2Loader.js";
+import { BufferGeometry as Y, Mesh as V, Material as xe, Texture as N, TextureLoader as De, Matrix4 as ne, Frustum as Me, Sphere as Oe, Box3 as oe, Vector3 as k } from "three";
+import { GLTFLoader as we } from "three/examples/jsm/loaders/GLTFLoader.js";
+let H = "https://www.gstatic.com/draco/versioned/decoders/1.4.1/", se = "https://www.gstatic.com/basis-universal/versioned/2021-04-15-ba1c3e4/";
+fetch(H + "draco_decoder.js", { method: "head" }).catch((a) => {
+  H = "./include/draco/", se = "./include/ktx2/";
+});
+function Ue(a) {
+  H = a;
+}
+function Ne(a) {
+  se = a;
 }
-function ie(l) {
-  l.dracoLoader || l.setDRACOLoader(F), l.ktx2Loader || l.setKTX2Loader(W), l.meshoptDecoder || l.setMeshoptDecoder(H);
+let z, te, W;
+function fe(a) {
+  z || (z = new me(), z.setDecoderPath(H), z.setDecoderConfig({ type: "js" })), W || (W = new Le(), W.setTranscoderPath(se)), te || (te = ye), a ? W.detectSupport(a) : console.warn("No renderer provided to detect ktx2 support - loading KTX2 textures will probably fail");
 }
-function Z(l) {
-  const t = new URL(window.location.href).searchParams.get(l);
+function ue(a) {
+  a.dracoLoader || a.setDRACOLoader(z), a.ktx2Loader || a.setKTX2Loader(W), a.meshoptDecoder || a.setMeshoptDecoder(te);
+}
+function ie(a) {
+  const t = new URL(window.location.href).searchParams.get(a);
   return t == null || t === "0" || t === "false" ? !1 : t === "" ? !0 : t;
 }
-function De(l, e) {
-  if (e === void 0 || e.startsWith("./") || e.startsWith("http") || l === void 0)
+function ve(a, e) {
+  if (e === void 0 || e.startsWith("./") || e.startsWith("http") || a === void 0)
     return e;
-  const t = l.lastIndexOf("/");
+  const t = a.lastIndexOf("/");
   if (t >= 0) {
-    const r = l.substring(0, t + 1);
+    const r = a.substring(0, t + 1);
     for (; r.endsWith("/") && e.startsWith("/"); )
       e = e.substring(1);
     return r + e;
   }
   return e;
 }
-const J = new Array();
-function Be(l) {
-  J.push(l);
+function Se(a) {
+  var e;
+  return ((e = a.userData) == null ? void 0 : e["needle:raycast-mesh"]) instanceof Y ? a.userData["needle:raycast-mesh"] : null;
+}
+function _e(a, e) {
+  (a.type === "Mesh" || a.type === "SkinnedMesh") && (a.userData || (a.userData = {}), a.userData["needle:raycast-mesh"] = e);
 }
-const R = "NEEDLE_progressive", S = Z("debugprogressive"), V = Symbol("needle-progressive-texture"), z = /* @__PURE__ */ new Map(), Q = /* @__PURE__ */ new Set();
-if (S) {
-  let l = function() {
-    e += 1, console.log("Toggle LOD level", e, z), z.forEach((i, n) => {
+const B = new Array(), R = "NEEDLE_progressive", w = ie("debugprogressive"), j = Symbol("needle-progressive-texture"), $ = /* @__PURE__ */ new Map(), re = /* @__PURE__ */ new Set();
+if (w) {
+  let a = function() {
+    e += 1, console.log("Toggle LOD level", e, $), $.forEach((i, n) => {
       for (const s of i.keys) {
         const o = n[s];
         if (o.isBufferGeometry === !0) {
-          const a = v.getMeshLODInformation(o), h = a ? Math.min(e, a.lods.length) : 0;
-          n["DEBUG:LOD"] = e, v.assignMeshLOD(n, h), a && (t = Math.max(t, a.lods.length - 1));
+          const l = S.getMeshLODInformation(o), d = l ? Math.min(e, l.lods.length) : 0;
+          n["DEBUG:LOD"] = e, S.assignMeshLOD(n, d), l && (t = Math.max(t, l.lods.length - 1));
         } else if (n.isMaterial === !0) {
-          n["DEBUG:LOD"] = e, v.assignTextureLOD(n, e);
+          n["DEBUG:LOD"] = e, S.assignTextureLOD(n, e);
           break;
         }
       }
     }), e >= t && (e = -1);
   }, e = -1, t = 2, r = !1;
   window.addEventListener("keyup", (i) => {
-    i.key === "p" && l(), i.key === "w" && (r = !r, Q && Q.forEach((n) => {
+    i.key === "p" && a(), i.key === "w" && (r = !r, re && re.forEach((n) => {
       n.name != "BackgroundCubeMaterial" && "wireframe" in n && (n.wireframe = r);
     }));
   });
 }
-function te(l, e, t) {
+function ae(a, e, t) {
   var i;
-  if (!S)
+  if (!w)
     return;
-  z.has(l) || z.set(l, { keys: [], sourceId: t });
-  const r = z.get(l);
+  $.has(a) || $.set(a, { keys: [], sourceId: t });
+  const r = $.get(a);
   ((i = r == null ? void 0 : r.keys) == null ? void 0 : i.includes(e)) == !1 && r.keys.push(e);
 }
-const M = class {
+const v = class {
   constructor(e, t) {
-    u(this, "parser");
-    u(this, "url");
-    S && console.log("Progressive extension registered for", t), this.parser = e, this.url = t;
+    f(this, "parser");
+    f(this, "url");
+    w && console.log("Progressive extension registered for", t), this.parser = e, this.url = t;
   }
   /** The name of the extension */
   get name() {
@@ -78,6 +90,38 @@ const M = class {
     const t = this.getAssignedLODInformation(e);
     return t != null && t.key ? this.lodInfos.get(t.key) : null;
   }
+  static getMaterialMinMaxLODsCount(e, t = { min: 1 / 0, max: -1 }) {
+    if (Array.isArray(e)) {
+      for (const n of e)
+        this.getMaterialMinMaxLODsCount(n, t);
+      return t;
+    }
+    let r = t.min, i = t.max;
+    if (e.type === "ShaderMaterial" || e.type === "RawShaderMaterial") {
+      const n = e;
+      for (const s of Object.keys(n.uniforms)) {
+        const o = n.uniforms[s].value;
+        if ((o == null ? void 0 : o.isTexture) === !0) {
+          const l = this.getAssignedLODInformation(o);
+          if (l) {
+            const d = this.lodInfos.get(l.key);
+            d && d.lods && (r = Math.min(r, d.lods.length), i = Math.max(i, d.lods.length));
+          }
+        }
+      }
+    } else if (e.isMaterial)
+      for (const n of Object.keys(e)) {
+        const s = e[n];
+        if ((s == null ? void 0 : s.isTexture) === !0) {
+          const o = this.getAssignedLODInformation(s);
+          if (o) {
+            const l = this.lodInfos.get(o.key);
+            l && l.lods && (r = Math.min(r, l.lods.length), i = Math.max(i, l.lods.length));
+          }
+        }
+      }
+    return t.min = r, t.max = i, t;
+  }
   /** Check if a LOD level is available for a mesh or a texture
    * @param obj the mesh or texture to check
    * @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
@@ -85,10 +129,16 @@ const M = class {
    */
   static hasLODLevelAvailable(e, t) {
     var n;
+    if (Array.isArray(e)) {
+      for (const s of e)
+        if (this.hasLODLevelAvailable(s, t))
+          return !0;
+      return !1;
+    }
     if (e.isMaterial === !0) {
       for (const s of Object.keys(e)) {
         const o = e[s];
-        if (o.isTexture && this.hasLODLevelAvailable(o, t))
+        if (o && o.isTexture && this.hasLODLevelAvailable(o, t))
           return !0;
       }
       return !1;
@@ -125,24 +175,24 @@ const M = class {
     var r;
     if (!e)
       return Promise.resolve(null);
-    if (e instanceof q || e.isMesh === !0) {
+    if (e instanceof V || e.isMesh === !0) {
       const i = e.geometry, n = this.getAssignedLODInformation(i);
       if (!n)
         return Promise.resolve(null);
-      for (const s of J)
+      for (const s of B)
         (r = s.onBeforeGetLODMesh) == null || r.call(s, e, t);
-      return e["LOD:requested level"] = t, M.getOrLoadLOD(i, t).then((s) => {
+      return e["LOD:requested level"] = t, v.getOrLoadLOD(i, t).then((s) => {
         if (e["LOD:requested level"] === t) {
           if (delete e["LOD:requested level"], Array.isArray(s)) {
             const o = n.index || 0;
             s = s[o];
           }
-          s && i != s && s instanceof X && (e.geometry = s, S && te(e, "geometry", n.url));
+          s && i != s && s instanceof Y && (e.geometry = s, w && ae(e, "geometry", n.url));
         }
         return s;
       }).catch((s) => (console.error("Error loading mesh LOD", e, s), null));
     } else
-      S && console.error("Invalid call to assignMeshLOD: Request mesh LOD but the object is not a mesh", e);
+      w && console.error("Invalid call to assignMeshLOD: Request mesh LOD but the object is not a mesh", e);
     return Promise.resolve(null);
   }
   /** Load a different resolution of a texture (if available)  
@@ -155,65 +205,71 @@ const M = class {
   static assignTextureLOD(e, t = 0) {
     if (!e)
       return Promise.resolve(null);
-    if (e instanceof le || e.isMaterial === !0) {
+    if (e instanceof xe || e.isMaterial === !0) {
       const r = e, i = [], n = new Array();
-      if (S && Q.add(r), r instanceof ue)
-        for (const s of Object.keys(r.uniforms)) {
-          const o = r.uniforms[s].value;
-          if ((o == null ? void 0 : o.isTexture) === !0) {
-            const a = this.assignTextureLODForSlot(o, t, r, s);
-            i.push(a), n.push(s);
+      if (w && re.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;
+          if ((l == null ? void 0 : l.isTexture) === !0) {
+            const d = this.assignTextureLODForSlot(l, t, r, o);
+            i.push(d), n.push(o);
           }
         }
-      else
+      } else
         for (const s of Object.keys(r)) {
           const o = r[s];
           if ((o == null ? void 0 : o.isTexture) === !0) {
-            const a = this.assignTextureLODForSlot(o, t, r, s);
-            i.push(a), n.push(s);
+            const l = this.assignTextureLODForSlot(o, t, r, s);
+            i.push(l), n.push(s);
           }
         }
       return Promise.all(i).then((s) => {
         const o = new Array();
-        for (let a = 0; a < s.length; a++) {
-          const h = s[a], d = n[a];
-          h && h.isTexture === !0 ? o.push({ material: r, slot: d, texture: h, level: t }) : o.push({ material: r, slot: d, texture: null, level: t });
+        for (let l = 0; l < s.length; l++) {
+          const d = s[l], h = n[l];
+          d && d.isTexture === !0 ? o.push({ material: r, slot: h, texture: d, level: t }) : o.push({ material: r, slot: h, texture: null, level: t });
         }
         return o;
       });
     }
-    if (e instanceof U || e.isTexture === !0) {
+    if (e instanceof N || e.isTexture === !0) {
       const r = e;
       return this.assignTextureLODForSlot(r, t, null, null);
     }
     return Promise.resolve(null);
   }
   static assignTextureLODForSlot(e, t, r, i) {
-    return (e == null ? void 0 : e.isTexture) !== !0 ? Promise.resolve(null) : M.getOrLoadLOD(e, t).then((n) => {
-      if (Array.isArray(n))
+    if ((e == null ? void 0 : e.isTexture) !== !0)
+      return Promise.resolve(null);
+    if (i === "glyphMap")
+      return Promise.resolve(e);
+    const n = "LOD:requested level:" + i;
+    return r && (r[n] = t), v.getOrLoadLOD(e, t).then((s) => {
+      if (r && r[n] != t || Array.isArray(s))
         return null;
-      if ((n == null ? void 0 : n.isTexture) === !0) {
-        if (n != e && (r && i && (r[i] = n), S && i && r)) {
-          const s = this.getAssignedLODInformation(e);
-          s && te(r, i, s.url);
+      if ((s == null ? void 0 : s.isTexture) === !0) {
+        if (s != e && (r && i && (r[i] = s), w && i && r)) {
+          const o = this.getAssignedLODInformation(e);
+          o && ae(r, i, o.url);
         }
-        return n;
+        return s;
       } else
-        S == "verbose" && console.warn("No LOD found for", e, t);
+        w == "verbose" && console.warn("No LOD found for", e, t);
       return null;
-    }).catch((n) => (console.error("Error loading LOD", e, n), null));
+    }).catch((s) => (console.error("Error loading LOD", e, s), null));
   }
   afterRoot(e) {
     var t, r;
-    return S && console.log("AFTER", this.url, e), (t = this.parser.json.textures) == null || t.forEach((i, n) => {
+    return w && console.log("AFTER", this.url, e), (t = this.parser.json.textures) == null || t.forEach((i, n) => {
       if (i != null && i.extensions) {
         const s = i == null ? void 0 : i.extensions[R];
         if (s) {
           let o = !1;
-          for (const a of this.parser.associations.keys())
-            a.isTexture === !0 && this.parser.associations.get(a).textures === n && (o = !0, M.registerTexture(this.url, a, n, s));
-          o || this.parser.getDependency("texture", n).then((a) => {
-            a && M.registerTexture(this.url, a, n, s);
+          for (const l of this.parser.associations.keys())
+            l.isTexture === !0 && this.parser.associations.get(l).textures === n && (o = !0, v.registerTexture(this.url, l, n, s));
+          o || this.parser.getDependency("texture", n).then((l) => {
+            l && v.registerTexture(this.url, l, n, s);
           });
         }
       }
@@ -223,195 +279,205 @@ const M = class {
         if (s && s.lods) {
           for (const o of this.parser.associations.keys())
             if (o.isMesh) {
-              const a = this.parser.associations.get(o);
-              a.meshes === n && M.registerMesh(this.url, s.guid, o, s.lods.length, a.primitives, s);
+              const l = this.parser.associations.get(o);
+              l.meshes === n && v.registerMesh(this.url, s.guid, o, s.lods.length, l.primitives, s);
             }
         }
       }
     }), null;
   }
   static async getOrLoadLOD(e, t) {
-    var o, a, h;
-    const r = S == "verbose", i = e.userData.LODS;
+    var o, l, d, h;
+    const r = w == "verbose", i = e.userData.LODS;
     if (!i)
       return null;
     const n = i == null ? void 0 : i.key;
     let s;
     if (e.isTexture === !0) {
-      const d = e;
-      d.source && d.source[V] && (s = d.source[V]);
+      const m = e;
+      m.source && m.source[j] && (s = m.source[j]);
     }
-    if (s || (s = M.lodInfos.get(n)), s) {
+    if (s || (s = v.lodInfos.get(n)), s) {
       if (t > 0) {
-        let f = !1;
-        const w = Array.isArray(s.lods);
-        if (w && t >= s.lods.length ? f = !0 : w || (f = !0), f)
+        let y = !1;
+        const x = Array.isArray(s.lods);
+        if (x && t >= s.lods.length ? y = !0 : x || (y = !0), y)
           return this.lowresCache.get(n);
       }
-      const d = Array.isArray(s.lods) ? s.lods[t].path : s.lods;
-      if (!d)
-        return S && !s["missing:uri"] && (s["missing:uri"] = !0, console.warn("Missing uri for progressive asset for LOD " + t, s)), null;
-      const c = De(i.url, d);
-      if (c.endsWith(".glb") || c.endsWith(".gltf")) {
+      const m = Array.isArray(s.lods) ? (o = s.lods[t]) == null ? void 0 : o.path : s.lods;
+      if (!m)
+        return w && !s["missing:uri"] && (s["missing:uri"] = !0, console.warn("Missing uri for progressive asset for LOD " + t, s)), null;
+      const u = ve(i.url, m);
+      if (u.endsWith(".glb") || u.endsWith(".gltf")) {
         if (!s.guid)
           return console.warn("missing pointer for glb/gltf texture", s), null;
-        const f = c + "_" + s.guid, w = this.previouslyLoaded.get(f);
-        if (w !== void 0) {
-          r && console.log(`LOD ${t} was already loading/loaded: ${f}`);
-          let D = await w.catch((I) => (console.error(`Error loading LOD ${t} from ${c}
-`, I), null)), C = !1;
-          if (D == null || (D instanceof U && e instanceof U ? (o = D.image) != null && o.data || (a = D.source) != null && a.data ? D = this.copySettings(e, D) : (C = !0, this.previouslyLoaded.delete(f)) : D instanceof X && e instanceof X && ((h = D.attributes.position) != null && h.array || (C = !0, this.previouslyLoaded.delete(f)))), !C)
-            return D;
+        const y = u + "_" + s.guid, x = this.previouslyLoaded.get(y);
+        if (x !== void 0) {
+          r && console.log(`LOD ${t} was already loading/loaded: ${y}`);
+          let O = await x.catch((F) => (console.error(`Error loading LOD ${t} from ${u}
+`, F), null)), P = !1;
+          if (O == null || (O instanceof N && e instanceof N ? (l = O.image) != null && l.data || (d = O.source) != null && d.data ? O = this.copySettings(e, O) : (P = !0, this.previouslyLoaded.delete(y)) : O instanceof Y && e instanceof Y && ((h = O.attributes.position) != null && h.array || (P = !0, this.previouslyLoaded.delete(y)))), !P)
+            return O;
         }
-        const L = s, A = new Promise(async (D, C) => {
-          const I = new ge();
-          ie(I), S && (await new Promise((y) => setTimeout(y, 1e3)), r && console.warn("Start loading (delayed) " + c, L.guid));
-          let m = c;
-          if (L && Array.isArray(L.lods)) {
-            const y = L.lods[t];
-            y.hash && (m += "?v=" + y.hash);
+        const M = s, D = new Promise(async (O, P) => {
+          const F = new we();
+          ue(F), w && (await new Promise((g) => setTimeout(g, 1e3)), r && console.warn("Start loading (delayed) " + u, M.guid));
+          let J = u;
+          if (M && Array.isArray(M.lods)) {
+            const g = M.lods[t];
+            g.hash && (J += "?v=" + g.hash);
           }
-          const p = await I.loadAsync(m).catch((y) => (console.error(`Error loading LOD ${t} from ${c}
-`, y), null));
-          if (!p)
+          const E = await F.loadAsync(J).catch((g) => (console.error(`Error loading LOD ${t} from ${u}
+`, g), null));
+          if (!E)
             return null;
-          const b = p.parser;
-          r && console.log("Loading finished " + c, L.guid);
-          let x = 0;
-          if (p.parser.json.textures) {
-            let y = !1;
-            for (const g of p.parser.json.textures) {
-              if (g != null && g.extensions) {
-                const O = g == null ? void 0 : g.extensions[R];
-                if (O != null && O.guid && O.guid === L.guid) {
-                  y = !0;
+          const Q = E.parser;
+          r && console.log("Loading finished " + u, M.guid);
+          let p = 0;
+          if (E.parser.json.textures) {
+            let g = !1;
+            for (const c of E.parser.json.textures) {
+              if (c != null && c.extensions) {
+                const L = c == null ? void 0 : c.extensions[R];
+                if (L != null && L.guid && L.guid === M.guid) {
+                  g = !0;
                   break;
                 }
               }
-              x++;
-            }
-            if (y) {
-              let g = await b.getDependency("texture", x);
-              return r && console.log('change "' + e.name + '" → "' + g.name + '"', c, x, g, f), e instanceof U && (g = this.copySettings(e, g)), g && (g.guid = L.guid), D(g);
+              p++;
             }
+            if (g) {
+              let c = await Q.getDependency("texture", p);
+              return c && v.assignLODInformation(i.url, c, n, t, void 0, void 0), r && console.log('change "' + e.name + '" → "' + c.name + '"', u, p, c, y), e instanceof N && (c = this.copySettings(e, c)), c && (c.guid = M.guid), O(c);
+            } else
+              w && console.warn("Could not find texture with guid", M.guid);
           }
-          if (x = 0, p.parser.json.meshes) {
-            let y = !1;
-            for (const g of p.parser.json.meshes) {
-              if (g != null && g.extensions) {
-                const O = g == null ? void 0 : g.extensions[R];
-                if (O != null && O.guid && O.guid === L.guid) {
-                  y = !0;
+          if (p = 0, E.parser.json.meshes) {
+            let g = !1;
+            for (const c of E.parser.json.meshes) {
+              if (c != null && c.extensions) {
+                const L = c == null ? void 0 : c.extensions[R];
+                if (L != null && L.guid && L.guid === M.guid) {
+                  g = !0;
                   break;
                 }
               }
-              x++;
+              p++;
             }
-            if (y) {
-              const g = await b.getDependency("mesh", x), O = L;
-              if (r && console.log(`Loaded Mesh "${g.name}"`, c, x, g, f), g.isMesh === !0) {
-                const P = g.geometry;
-                return M.assignLODInformation(i.url, P, n, t, void 0, O.density), D(P);
+            if (g) {
+              const c = await Q.getDependency("mesh", p), L = M;
+              if (r && console.log(`Loaded Mesh "${c.name}"`, u, p, c, y), c.isMesh === !0) {
+                const _ = c.geometry;
+                return v.assignLODInformation(i.url, _, n, t, void 0, L.density), O(_);
               } else {
-                const P = new Array();
-                for (let _ = 0; _ < g.children.length; _++) {
-                  const E = g.children[_];
-                  if (E instanceof q) {
-                    const N = E.geometry;
-                    M.assignLODInformation(i.url, N, n, t, _, O.density), P.push(N);
+                const _ = new Array();
+                for (let C = 0; C < c.children.length; C++) {
+                  const I = c.children[C];
+                  if (I instanceof V) {
+                    const U = I.geometry;
+                    v.assignLODInformation(i.url, U, n, t, C, L.density), _.push(U);
                   }
                 }
-                return D(P);
+                return O(_);
               }
             }
           }
-          return D(null);
+          return O(null);
         });
-        return this.previouslyLoaded.set(f, A), await A;
-      } else if (e instanceof U) {
-        r && console.log("Load texture from uri: " + c);
-        const w = await new ce().loadAsync(c);
-        return w ? (w.guid = s.guid, w.flipY = !1, w.needsUpdate = !0, w.colorSpace = e.colorSpace, r && console.log(s, w)) : S && console.warn("failed loading", c), w;
+        return this.previouslyLoaded.set(y, D), await D;
+      } else if (e instanceof N) {
+        r && console.log("Load texture from uri: " + u);
+        const x = await new De().loadAsync(u);
+        return x ? (x.guid = s.guid, x.flipY = !1, x.needsUpdate = !0, x.colorSpace = e.colorSpace, r && console.log(s, x)) : w && console.warn("failed loading", u), x;
       }
     } else
-      S && console.warn(`Can not load LOD ${t}: no LOD info found for "${n}" ${e.name}`, e.type);
+      w && console.warn(`Can not load LOD ${t}: no LOD info found for "${n}" ${e.name}`, e.type);
     return null;
   }
   static assignLODInformation(e, t, r, i, n, s) {
     if (!t)
       return;
     t.userData || (t.userData = {});
-    const o = new xe(e, r, i, n, s);
+    const o = new Te(e, r, i, n, s);
     t.userData.LODS = o, t.userData.LOD = i;
   }
   static getAssignedLODInformation(e) {
     var t;
     return ((t = e == null ? void 0 : e.userData) == null ? void 0 : t.LODS) || null;
   }
+  // private static readonly _copiedTextures: WeakMap<Texture, Texture> = new Map();
   static copySettings(e, t) {
-    const r = this._copiedTextures.get(e);
-    return r || (t = t.clone(), this._copiedTextures.set(e, t), t.offset = e.offset, t.repeat = e.repeat, t.colorSpace = e.colorSpace, t);
+    return t = t.clone(), w && 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;
   }
 };
-let v = M;
+let S = v;
 /**
  * Register a texture with LOD information
  */
-u(v, "registerTexture", (e, t, r, i) => {
-  S && console.log("> Progressive: register texture", r, t.name, t.uuid, t, i), t.source && (t.source[V] = i);
+f(S, "registerTexture", (e, t, r, i) => {
+  w && console.log("> Progressive: register texture", r, t.name, t.uuid, t, i), t.source && (t.source[j] = i);
   const n = i.guid;
-  M.assignLODInformation(e, t, n, 0, 0, void 0), M.lodInfos.set(n, i), M.lowresCache.set(n, t);
+  v.assignLODInformation(e, t, n, 0, 0, void 0), v.lodInfos.set(n, i), v.lowresCache.set(n, t);
 }), /**
  * Register a mesh with LOD information
  */
-u(v, "registerMesh", (e, t, r, i, n, s) => {
-  var h;
-  S && console.log("> Progressive: register mesh", n, r.name, s, r.uuid, r);
+f(S, "registerMesh", (e, t, r, i, n, s) => {
+  var d;
+  w && console.log("> Progressive: register mesh", n, r.name, s, r.uuid, r);
   const o = r.geometry;
-  o.userData || (o.userData = {}), M.assignLODInformation(e, o, t, i, n, s.density), M.lodInfos.set(t, s);
-  let a = M.lowresCache.get(t);
-  a ? a.push(r.geometry) : a = [r.geometry], M.lowresCache.set(t, a);
-  for (const d of J)
-    (h = d.onRegisteredNewMesh) == null || h.call(d, r, s);
+  o.userData || (o.userData = {}), v.assignLODInformation(e, o, t, i, n, s.density), v.lodInfos.set(t, s);
+  let l = v.lowresCache.get(t);
+  l ? l.push(r.geometry) : l = [r.geometry], v.lowresCache.set(t, l), i > 0 && !Se(r) && _e(r, o);
+  for (const h of B)
+    (d = h.onRegisteredNewMesh) == null || d.call(h, r, s);
 }), /** A map of key = asset uuid and value = LOD information */
-u(v, "lodInfos", /* @__PURE__ */ new Map()), /** cache of already loaded mesh lods */
-u(v, "previouslyLoaded", /* @__PURE__ */ new Map()), /** this contains the geometry/textures that were originally loaded */
-u(v, "lowresCache", /* @__PURE__ */ new Map()), u(v, "_copiedTextures", /* @__PURE__ */ new Map());
-class xe {
+f(S, "lodInfos", /* @__PURE__ */ new Map()), /** cache of already loaded mesh lods */
+f(S, "previouslyLoaded", /* @__PURE__ */ new Map()), /** this contains the geometry/textures that were originally loaded */
+f(S, "lowresCache", /* @__PURE__ */ new Map());
+class Te {
   constructor(e, t, r, i, n) {
-    u(this, "url");
+    f(this, "url");
     /** the key to lookup the LOD information */
-    u(this, "key");
-    u(this, "level");
+    f(this, "key");
+    f(this, "level");
     /** For multi objects (e.g. a group of meshes) this is the index of the object */
-    u(this, "index");
+    f(this, "index");
     /** the mesh density */
-    u(this, "density");
+    f(this, "density");
     this.url = e, this.key = t, this.level = r, i != null && (this.index = i), n != null && (this.density = n);
   }
 }
-const Y = Z("debugprogressive"), we = Z("noprogressive"), T = class {
+const ee = ie("debugprogressive"), Ae = ie("noprogressive"), le = Symbol("Needle:LODSManager"), A = { mesh_lod: -1, texture_lod: -1 }, T = class {
+  // readonly plugins: NEEDLE_progressive_plugin[] = [];
   constructor(e) {
-    u(this, "renderer");
-    u(this, "projectionScreenMatrix", new j());
-    u(this, "cameraFrustrum", new fe());
+    f(this, "renderer");
+    f(this, "projectionScreenMatrix", new ne());
+    f(this, "cameraFrustrum", new Me());
+    /**
+     * The target triangle density is the desired max amount of triangles on screen when the mesh is filling the screen.  
+     * @default 200_000
+     */
+    f(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.
      */
-    u(this, "updateInterval", 0);
+    f(this, "updateInterval", 0);
     /**
      * If set to true, the LODsManager will not update the LODs.
      */
-    u(this, "pause", !1);
-    u(this, "plugins", []);
-    u(this, "_originalRender");
+    f(this, "pause", !1);
+    f(this, "_frame", 0);
+    f(this, "_originalRender");
     // private testIfLODLevelsAreAvailable() {
-    u(this, "_sphere", new de());
-    u(this, "_tempBox", new ee());
-    u(this, "tempMatrix", new j());
-    u(this, "_tempWorldPosition", new k());
-    u(this, "_tempBoxSize", new k());
-    u(this, "_tempBox2Size", new k());
+    f(this, "_sphere", new Oe());
+    f(this, "_tempBox", new oe());
+    f(this, "_tempBox2", new oe());
+    f(this, "tempMatrix", new ne());
+    f(this, "_tempWorldPosition", new k());
+    f(this, "_tempBoxSize", new k());
+    f(this, "_tempBox2Size", new k());
     this.renderer = e;
   }
   /** @internal */
@@ -419,6 +485,25 @@ const Y = Z("debugprogressive"), we = Z("noprogressive"), T = class {
     var t;
     return (t = e.userData) == null ? void 0 : t.LOD_state;
   }
+  static addPlugin(e) {
+    B.push(e);
+  }
+  static removePlugin(e) {
+    const t = B.indexOf(e);
+    t >= 0 && B.splice(t, 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) {
+    return e[le] ? e[le] : new T(e);
+  }
+  /** @deprecated use static `LODsManager.addPlugin()` method. This getter will be removed in later versions */
+  get plugins() {
+    return B;
+  }
   /**
    * Enable the LODsManager. This will replace the render method of the renderer with a method that updates the LODs.
    */
@@ -428,10 +513,10 @@ const Y = Z("debugprogressive"), we = Z("noprogressive"), T = class {
     let e = 0;
     this._originalRender = this.renderer.render;
     const t = this;
-    let r = 0;
-    se(this.renderer), this.renderer.render = function(i, n) {
-      const s = r++, o = e++;
-      t.onBeforeRender(i, n, o, s), t._originalRender.call(this, i, n), t.onAfterRender(i, n, o, s), e--;
+    fe(this.renderer), this.renderer.render = function(r, i) {
+      t.renderer.getRenderTarget() == null && (e = 0, t._frame += 1);
+      const s = t._frame, o = e++;
+      t.onBeforeRender(r, i, o, s), t._originalRender.call(this, r, i), t.onAfterRender(r, i, o, s);
     };
   }
   disable() {
@@ -440,46 +525,61 @@ const Y = Z("debugprogressive"), we = Z("noprogressive"), T = class {
   onBeforeRender(e, t, r, i) {
   }
   onAfterRender(e, t, r, i) {
-    var h, d;
-    if (we || this.pause || this.updateInterval > 0 && i % this.updateInterval != 0)
+    var l, d;
+    if (this.pause)
       return;
-    this.projectionScreenMatrix.multiplyMatrices(t.projectionMatrix, t.matrixWorldInverse), this.cameraFrustrum.setFromProjectionMatrix(this.projectionScreenMatrix, this.renderer.coordinateSystem);
-    const n = 1e5, s = this.renderer.renderLists.get(e, r), o = s.opaque;
-    for (const c of o) {
-      if (c.material && (((h = c.geometry) == null ? void 0 : h.type) === "BoxGeometry" || ((d = c.geometry) == null ? void 0 : d.type) === "BufferGeometry") && (c.material.name === "SphericalGaussianBlur" || c.material.name == "BackgroundCubeMaterial" || c.material.name === "CubemapFromEquirect" || c.material.name === "EquirectangularToCubeUV")) {
-        Y && (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;
-      }
-      const f = c.object;
-      (f instanceof q || f.isMesh) && this.updateLODs(e, t, f, n);
+    const n = this.renderer.renderLists.get(e, 0), s = n.opaque;
+    let o = !0;
+    if (s.length === 1) {
+      const h = s[0].material;
+      (h.name === "EffectMaterial" || h.name === "CopyShader") && (o = !1);
     }
-    const a = s.transparent;
-    for (const c of a) {
-      const f = c.object;
-      (f instanceof q || f.isMesh) && this.updateLODs(e, t, f, n);
+    if (t.parent && t.parent.type === "CubeCamera" && (o = !1), o) {
+      if (Ae || this.updateInterval > 0 && i % this.updateInterval != 0)
+        return;
+      this.projectionScreenMatrix.multiplyMatrices(t.projectionMatrix, t.matrixWorldInverse), this.cameraFrustrum.setFromProjectionMatrix(this.projectionScreenMatrix, this.renderer.coordinateSystem);
+      const h = this.targetTriangleDensity;
+      for (const u of s) {
+        if (u.material && (((l = u.geometry) == null ? void 0 : l.type) === "BoxGeometry" || ((d = u.geometry) == null ? void 0 : d.type) === "BufferGeometry") && (u.material.name === "SphericalGaussianBlur" || u.material.name == "BackgroundCubeMaterial" || u.material.name === "CubemapFromEquirect" || u.material.name === "EquirectangularToCubeUV")) {
+          ee && (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 (u.material.type) {
+          case "LineBasicMaterial":
+          case "LineDashedMaterial":
+          case "PointsMaterial":
+          case "ShadowMaterial":
+          case "MeshDistanceMaterial":
+          case "MeshDepthMaterial":
+            continue;
+        }
+        const y = u.object;
+        (y instanceof V || y.isMesh) && this.updateLODs(e, t, y, h, i);
+      }
+      const m = n.transparent;
+      for (const u of m) {
+        const y = u.object;
+        (y instanceof V || y.isMesh) && this.updateLODs(e, t, y, h, i);
+      }
     }
   }
   /** Update the LOD levels for the renderer. */
-  updateLODs(e, t, r, i) {
-    var a, h;
-    for (const d of this.plugins)
-      (a = d.onBeforeUpdateLOD) == null || a.call(d, this.renderer, e, t, r);
-    let n = r.userData.LOD_state;
-    n || (n = new Oe(), r.userData.LOD_state = n);
-    let s = this.calculateLodLevel(t, r, n, i);
-    s = Math.round(s), s >= 0 && this.loadProgressiveMeshes(r, s);
-    let o = 0;
-    if (r.material) {
-      const d = r["DEBUG:LOD"];
-      if (d != null && (o = d), Array.isArray(r.material))
-        for (const c of r.material)
-          this.loadProgressiveTextures(c, o);
-      else
-        this.loadProgressiveTextures(r.material, o);
+  updateLODs(e, t, r, i, n) {
+    var l, d;
+    let s = r.userData.LOD_state;
+    if (s || (s = new Pe(), r.userData.LOD_state = s), s.frames++ < 2)
+      return;
+    for (const h of B)
+      (l = h.onBeforeUpdateLOD) == null || l.call(h, this.renderer, e, t, r);
+    this.calculateLodLevel(t, r, s, i, A), A.mesh_lod = Math.round(A.mesh_lod), A.texture_lod = Math.round(A.texture_lod), A.mesh_lod >= 0 && this.loadProgressiveMeshes(r, A.mesh_lod);
+    let o = A.texture_lod;
+    if (r.material && o >= 0) {
+      const h = r["DEBUG:LOD"];
+      h != null && (o = h), this.loadProgressiveTextures(r.material, o);
     }
-    for (const d of this.plugins)
-      (h = d.onAfterUpdatedLOD) == null || h.call(d, this.renderer, e, t, r, s);
-    n.lastLodLevel = s;
+    for (const h of B)
+      (d = h.onAfterUpdatedLOD) == null || d.call(h, this.renderer, e, t, r, A);
+    s.lastLodLevel_Mesh = A.mesh_lod, s.lasLodLevel_Texture = A.texture_lod;
   }
   /** Load progressive textures for the given material
    * @param material the material to load the textures for
@@ -487,7 +587,16 @@ const Y = Z("debugprogressive"), we = Z("noprogressive"), T = class {
    * @returns Promise with true if the LOD was loaded, false if not
    */
   loadProgressiveTextures(e, t) {
-    return e && e.userData && e.userData.LOD !== t ? (e.userData.LOD = t, v.assignTextureLOD(e, t)) : Promise.resolve(null);
+    if (!e)
+      return;
+    if (Array.isArray(e)) {
+      for (const n of e)
+        this.loadProgressiveTextures(n, t);
+      return;
+    }
+    const r = e;
+    let i = !1;
+    (r.NEEDLE_LOD == null || t < r.NEEDLE_LOD) && (i = !0), i && (r.NEEDLE_LOD = t, S.assignTextureLOD(e, t));
   }
   /** Load progressive meshes for the given mesh
    * @param mesh the mesh to load the LOD for
@@ -501,91 +610,120 @@ const Y = Z("debugprogressive"), we = Z("noprogressive"), T = class {
     if (e.userData || (e.userData = {}), e.userData.LOD !== t) {
       e.userData.LOD = t;
       const r = e.geometry;
-      return v.assignMeshLOD(e, t).then((i) => (i && e.userData.LOD == t && r != e.geometry, i));
+      return S.assignMeshLOD(e, t).then((i) => (i && e.userData.LOD == t && r != e.geometry, i));
     }
     return Promise.resolve(null);
   }
-  calculateLodLevel(e, t, r, i) {
-    var o;
-    if (!t)
-      return -1;
-    let s = 10 + 1;
-    if (e) {
-      if (Y && t["DEBUG:LOD"] != null)
-        return t["DEBUG:LOD"];
-      const a = v.getMeshLODInformation(t.geometry), h = a == null ? void 0 : a.lods;
-      if (!h || h.length <= 0 || !((o = this.cameraFrustrum) != null && o.intersectsObject(t)))
-        return 99;
-      const d = t.geometry.boundingBox;
-      if (d && e.isPerspectiveCamera) {
-        const c = 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 m = e.getWorldPosition(this._tempWorldPosition);
-          if (this._sphere.containsPoint(m))
-            return 0;
-        }
-        if (this._tempBox.copy(d), this._tempBox.applyMatrix4(t.matrixWorld), this._tempBox.applyMatrix4(this.projectionScreenMatrix), this.renderer.xr.enabled && c.fov > 70) {
-          const m = this._tempBox.min, p = this._tempBox.max;
-          let b = m.x, x = m.y, y = p.x, g = p.y;
-          const O = 2, P = 1.5, _ = (m.x + p.x) * 0.5, E = (m.y + p.y) * 0.5;
-          b = (b - _) * O + _, x = (x - E) * O + E, y = (y - _) * O + _, g = (g - E) * O + E;
-          const N = b < 0 && y > 0 ? 0 : Math.min(Math.abs(m.x), Math.abs(p.x)), ne = x < 0 && g > 0 ? 0 : Math.min(Math.abs(m.y), Math.abs(p.y)), K = Math.max(N, ne);
-          r.lastCentrality = (P - K) * (P - K) * (P - K);
-        } else
-          r.lastCentrality = 1;
-        const f = this._tempBox.getSize(this._tempBoxSize);
-        f.multiplyScalar(0.5), screen.availHeight > 0 && f.multiplyScalar(this.renderer.domElement.clientHeight / screen.availHeight), f.x *= c.aspect;
-        const w = e.matrixWorldInverse, L = new ee();
-        L.copy(d), L.applyMatrix4(t.matrixWorld), L.applyMatrix4(w);
-        const A = L.getSize(this._tempBox2Size), G = Math.max(A.x, A.y);
-        if (Math.max(f.x, f.y) != 0 && G != 0 && (f.z = A.z / Math.max(A.x, A.y) * Math.max(f.x, f.y)), r.lastScreenCoverage = Math.max(f.x, f.y, f.z), r.lastScreenspaceVolume.copy(f), r.lastScreenCoverage *= r.lastCentrality, Y && T.debugDrawLine) {
-          const m = this.tempMatrix.copy(this.projectionScreenMatrix);
-          m.invert();
-          const p = T.corner0, b = T.corner1, x = T.corner2, y = T.corner3;
-          p.copy(this._tempBox.min), b.copy(this._tempBox.max), b.x = p.x, x.copy(this._tempBox.max), x.y = p.y, y.copy(this._tempBox.max);
-          const g = (p.z + y.z) * 0.5;
-          p.z = b.z = x.z = y.z = g, p.applyMatrix4(m), b.applyMatrix4(m), x.applyMatrix4(m), y.applyMatrix4(m), T.debugDrawLine(p, b, 255), T.debugDrawLine(p, x, 255), T.debugDrawLine(b, y, 255), T.debugDrawLine(x, y, 255);
-        }
-        let C = 999;
-        if (h && r.lastScreenCoverage > 0) {
-          for (let m = 0; m < h.length; m++)
-            if (h[m].density / r.lastScreenCoverage < i) {
-              C = m;
-              break;
-            }
+  static isInside(e, t) {
+    const r = e.min, i = e.max, n = (r.x + i.x) * 0.5, s = (r.y + i.y) * 0.5;
+    return this._tempPtInside.set(n, s, r.z).applyMatrix4(t).z < 0;
+  }
+  calculateLodLevel(e, t, r, i, n) {
+    var x;
+    if (!t) {
+      n.mesh_lod = -1, n.texture_lod = -1;
+      return;
+    }
+    if (!e) {
+      n.mesh_lod = -1, n.texture_lod = -1;
+      return;
+    }
+    let o = 10 + 1;
+    if (ee && t["DEBUG:LOD"] != null)
+      return t["DEBUG:LOD"];
+    const l = S.getMeshLODInformation(t.geometry), d = l == null ? void 0 : l.lods, h = d && d.length > 0, m = S.getMaterialMinMaxLODsCount(t.material), u = (m == null ? void 0 : m.min) != 1 / 0 && m.min > 0 && m.max > 0;
+    if (!h && !u) {
+      n.mesh_lod = 0, n.texture_lod = 0;
+      return;
+    }
+    if (h || (o = 0), !((x = this.cameraFrustrum) != null && x.intersectsObject(t))) {
+      n.mesh_lod = 99, n.texture_lod = 99;
+      return;
+    }
+    const y = t.geometry.boundingBox;
+    if (y && e.isPerspectiveCamera) {
+      const M = 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 p = e.getWorldPosition(this._tempWorldPosition);
+        if (this._sphere.containsPoint(p)) {
+          n.mesh_lod = 0, n.texture_lod = 0;
+          return;
         }
-        C < s && (s = C);
       }
+      if (this._tempBox.copy(y), this._tempBox.applyMatrix4(t.matrixWorld), T.isInside(this._tempBox, this.projectionScreenMatrix)) {
+        n.mesh_lod = 0, n.texture_lod = 0;
+        return;
+      }
+      if (this._tempBox.applyMatrix4(this.projectionScreenMatrix), this.renderer.xr.enabled && M.fov > 70) {
+        const p = this._tempBox.min, g = this._tempBox.max;
+        let c = p.x, L = p.y, _ = g.x, C = g.y;
+        const I = 2, U = 1.5, q = (p.x + g.x) * 0.5, K = (p.y + g.y) * 0.5;
+        c = (c - q) * I + q, L = (L - K) * I + K, _ = (_ - q) * I + q, C = (C - K) * I + K;
+        const de = c < 0 && _ > 0 ? 0 : Math.min(Math.abs(p.x), Math.abs(g.x)), he = L < 0 && C > 0 ? 0 : Math.min(Math.abs(p.y), Math.abs(g.y)), Z = Math.max(de, he);
+        r.lastCentrality = (U - Z) * (U - Z) * (U - Z);
+      } else
+        r.lastCentrality = 1;
+      const D = this._tempBox.getSize(this._tempBoxSize);
+      D.multiplyScalar(0.5), screen.availHeight > 0 && D.multiplyScalar(this.renderer.domElement.clientHeight / screen.availHeight), D.x *= M.aspect;
+      const G = e.matrixWorldInverse, O = this._tempBox2;
+      O.copy(y), O.applyMatrix4(t.matrixWorld), O.applyMatrix4(G);
+      const P = O.getSize(this._tempBox2Size), F = Math.max(P.x, P.y);
+      if (Math.max(D.x, D.y) != 0 && F != 0 && (D.z = P.z / Math.max(P.x, P.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, ee && T.debugDrawLine) {
+        const p = this.tempMatrix.copy(this.projectionScreenMatrix);
+        p.invert();
+        const g = T.corner0, c = T.corner1, L = T.corner2, _ = T.corner3;
+        g.copy(this._tempBox.min), c.copy(this._tempBox.max), c.x = g.x, L.copy(this._tempBox.max), L.y = g.y, _.copy(this._tempBox.max);
+        const C = (g.z + _.z) * 0.5;
+        g.z = c.z = L.z = _.z = C, g.applyMatrix4(p), c.applyMatrix4(p), L.applyMatrix4(p), _.applyMatrix4(p), T.debugDrawLine(g, c, 255), T.debugDrawLine(g, L, 255), T.debugDrawLine(c, _, 255), T.debugDrawLine(L, _, 255);
+      }
+      let E = 999;
+      if (d && r.lastScreenCoverage > 0) {
+        for (let p = 0; p < d.length; p++)
+          if (d[p].density / r.lastScreenCoverage < i) {
+            E = p;
+            break;
+          }
+      }
+      E < o && (o = E);
     }
-    return s;
+    if (n.mesh_lod = o, m != null && m.min && m.min > 0 && m.max > 0) {
+      const M = Math.min(1, Math.max(0, r.lastScreenCoverage * 3));
+      n.texture_lod = be(m.max, 0, M);
+    } else
+      n.texture_lod = 0;
   }
 };
-let B = T;
+let b = T;
 /** 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.
  */
-u(B, "debugDrawLine"), u(B, "corner0", new k()), u(B, "corner1", new k()), u(B, "corner2", new k()), u(B, "corner3", new k());
-class Oe {
+f(b, "debugDrawLine"), f(b, "corner0", new k()), f(b, "corner1", new k()), f(b, "corner2", new k()), f(b, "corner3", new k()), f(b, "_tempPtInside", new k());
+function be(a, e, t) {
+  return a + (e - a) * t;
+}
+class Pe {
   constructor() {
-    u(this, "lastLodLevel", 0);
-    u(this, "lastScreenCoverage", 0);
-    u(this, "lastScreenspaceVolume", new k());
-    u(this, "lastCentrality", 0);
+    f(this, "frames", 0);
+    f(this, "lastLodLevel_Mesh", 0);
+    f(this, "lasLodLevel_Texture", 0);
+    f(this, "lastScreenCoverage", 0);
+    f(this, "lastScreenspaceVolume", new k());
+    f(this, "lastCentrality", 0);
   }
 }
-const re = Symbol("NEEDLE_mesh_lod"), $ = Symbol("NEEDLE_texture_lod");
-function Me(l) {
-  if (!l)
+const ce = Symbol("NEEDLE_mesh_lod"), X = Symbol("NEEDLE_texture_lod");
+function Ee(a) {
+  if (!a)
     return null;
   let e = null, t = null;
-  for (let r = l; r != null; r = Object.getPrototypeOf(r)) {
+  for (let r = a; r != null; r = Object.getPrototypeOf(r)) {
     const i = Object.getOwnPropertySymbols(r), n = i.find((o) => o.toString() == "Symbol(renderer)"), s = i.find((o) => o.toString() == "Symbol(scene)");
-    !e && n != null && (e = l[n].threeRenderer), !t && s != null && (t = l[s]);
+    !e && n != null && (e = a[n].threeRenderer), !t && s != null && (t = a[s]);
   }
   if (e) {
     console.log("Adding Needle LODs to modelviewer");
-    const r = new B(e);
-    if (r.plugins.push(new ve(l)), r.enable(), t) {
+    const r = b.get(e);
+    if (b.addPlugin(new Ce(a)), r.enable(), t) {
       const i = t.camera || t.traverse((n) => n.type == "PerspectiveCamera")[0];
       i && e.render(t, i);
     }
@@ -595,10 +733,10 @@ function Me(l) {
   }
   return null;
 }
-class ve {
+class Ce {
   constructor(e) {
-    u(this, "modelviewer");
-    u(this, "_didWarnAboutMissingUrl", !1);
+    f(this, "modelviewer");
+    f(this, "_didWarnAboutMissingUrl", !1);
     this.modelviewer = e;
   }
   onBeforeUpdateLOD(e, t, r, i) {
@@ -612,24 +750,28 @@ class ve {
     return e._currentGLTF;
   }
   tryParseTextureLOD(e, t) {
-    if (t[$] == !0)
+    if (t[X] == !0)
       return;
-    t[$] = !0;
+    t[X] = !0;
     const r = this.tryGetCurrentGLTF(e), i = this.getUrl();
     if (i && r && t.material) {
       let n = function(o) {
-        var h, d, c;
-        if (o[$] == !0)
+        var d, h, m;
+        if (o[X] == !0)
           return;
-        o[$] = !0, o.userData && (o.userData.LOD = -1);
-        const a = Object.keys(o);
-        for (let f = 0; f < a.length; f++) {
-          const w = a[f], L = o[w];
-          if ((L == null ? void 0 : L.isTexture) === !0) {
-            const A = (d = (h = L.userData) == null ? void 0 : h.associations) == null ? void 0 : d.textures, G = r.parser.json.textures[A];
-            if ((c = G.extensions) != null && c[R]) {
-              const D = G.extensions[R];
-              D && i && v.registerTexture(i, L, D.lods.length, D);
+        o[X] = !0, o.userData && (o.userData.LOD = -1);
+        const l = Object.keys(o);
+        for (let u = 0; u < l.length; u++) {
+          const y = l[u], x = o[y];
+          if ((x == null ? void 0 : x.isTexture) === !0) {
+            const M = (h = (d = x.userData) == null ? void 0 : d.associations) == null ? void 0 : h.textures, D = r.parser.json.textures[M];
+            if (!D) {
+              console.warn("Texture data not found for texture index " + M);
+              continue;
+            }
+            if ((m = D == null ? void 0 : D.extensions) != null && m[R]) {
+              const G = D.extensions[R];
+              G && i && S.registerTexture(i, x, G.lods.length, G);
             }
           }
         }
@@ -644,32 +786,37 @@ class ve {
   }
   tryParseMeshLOD(e, t) {
     var n, s;
-    if (t[re] == !0)
+    if (t[ce] == !0)
       return;
-    t[re] = !0;
+    t[ce] = !0;
     const r = this.getUrl();
     if (!r)
       return;
     const i = (s = (n = t.userData) == null ? void 0 : n.gltfExtensions) == null ? void 0 : s[R];
     if (i && r) {
       const o = t.uuid;
-      v.registerMesh(r, o, t, 0, i.lods.length, i);
+      S.registerMesh(r, o, t, 0, i.lods.length, i);
     }
   }
 }
-function Ce(l, e, t, r) {
-  se(e), ie(t), t.register((n) => new v(n, l));
-  const i = new B(e);
+function ze(a, e, t, r) {
+  fe(e), ue(t), t.register((n) => new S(n, a));
+  const i = b.get(e);
   return (r == null ? void 0 : r.enableLODsManager) !== !1 && i.enable(), i;
 }
 document.addEventListener("DOMContentLoaded", () => {
-  Me(document.querySelector("model-viewer"));
+  Ee(document.querySelector("model-viewer"));
 });
 export {
   R as EXTENSION_NAME,
-  B as LODsManager,
-  v as NEEDLE_progressive,
-  Me as patchModelViewer,
-  Be as registerPlugin,
-  Ce as useNeedleProgressive
+  b as LODsManager,
+  S as NEEDLE_progressive,
+  ue as addDracoAndKTX2Loaders,
+  fe as createLoaders,
+  Se as getRaycastMesh,
+  Ee as patchModelViewer,
+  Ue as setDracoDecoderLocation,
+  Ne as setKTX2TranscoderLocation,
+  _e as setRaycastMesh,
+  ze as useNeedleProgressive
 };