@needle-tools/gltf-progressive 1.2.3-alpha.2 → 1.2.3-beta

package/gltf-progressive.js

@@ -1,15 +1,15 @@
 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) => {
+var f = (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) => {
+var x = (a, t, e) => (Se(a, t, "read from private field"), e ? e.call(a) : t.get(a)), X = (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";
+}, F = (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 H, 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 N } 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";
@@ -69,8 +69,8 @@ function yt(a = !0) {
   if (a) {
     if (re)
       return;
-    const t = re = J.prototype.raycast;
-    J.prototype.raycast = function(e, r) {
+    const t = re = H.prototype.raycast;
+    H.prototype.raycast = function(e, r) {
       const o = this, i = Oe(o);
       let s;
       i && o.isMesh && (s = o.geometry, o.geometry = i), t.call(this, e, r), s && (o.geometry = s);
@@ -78,7 +78,7 @@ function yt(a = !0) {
   } else {
     if (!re)
       return;
-    J.prototype.raycast = re, re = null;
+    H.prototype.raycast = re, re = null;
   }
 }
 let re = null;
@@ -88,18 +88,18 @@ function tt(a) {
     t.setAttribute(e, a.getAttribute(e));
   return t.setIndex(a.getIndex()), t;
 }
-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) {
+const Y = new Array(), U = "NEEDLE_progressive", M = ae("debugprogressive"), xe = Symbol("needle-progressive-texture"), ne = /* @__PURE__ */ new Map(), ve = /* @__PURE__ */ new Set();
+if (M) {
   let a = function() {
     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), f = l ? Math.min(t, l.lods.length) : 0;
-            i["DEBUG:LOD"] = t, S.assignMeshLOD(i, f), l && (e = Math.max(e, l.lods.length - 1));
+            const l = b.getMeshLODInformation(n), u = l ? Math.min(t, l.lods.length) : 0;
+            i["DEBUG:LOD"] = t, b.assignMeshLOD(i, u), l && (e = Math.max(e, l.lods.length - 1));
           } else if (i.isMaterial === !0) {
-            i["DEBUG:LOD"] = t, S.assignTextureLOD(i, t);
+            i["DEBUG:LOD"] = t, b.assignTextureLOD(i, t);
             break;
           }
         }
@@ -114,32 +114,32 @@ if (L) {
 }
 function Ae(a, t, e) {
   var o;
-  if (!L)
+  if (!M)
     return;
   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 O = class {
+const _ = class {
   constructor(t, e) {
-    d(this, "parser");
-    d(this, "url");
-    d(this, "_isLoadingMesh");
-    d(this, "loadMesh", (t) => {
+    f(this, "parser");
+    f(this, "url");
+    f(this, "_isLoadingMesh");
+    f(this, "loadMesh", (t) => {
       var r, o;
       if (this._isLoadingMesh)
         return null;
-      const e = (o = (r = this.parser.json.meshes[t]) == null ? void 0 : r.extensions) == null ? void 0 : o[N];
+      const e = (o = (r = this.parser.json.meshes[t]) == null ? void 0 : r.extensions) == null ? void 0 : o[U];
       return e ? (this._isLoadingMesh = !0, this.parser.getDependency("mesh", t).then((i) => {
         var s;
-        return this._isLoadingMesh = !1, i && O.registerMesh(this.url, e.guid, i, (s = e.lods) == null ? void 0 : s.length, void 0, e), i;
+        return this._isLoadingMesh = !1, i && _.registerMesh(this.url, e.guid, i, (s = e.lods) == null ? void 0 : s.length, void 0, e), i;
       })) : null;
     });
-    L && console.log("Progressive extension registered for", e), this.parser = t, this.url = e;
+    M && console.log("Progressive extension registered for", e), this.parser = t, this.url = e;
   }
   /** The name of the extension */
   get name() {
-    return N;
+    return U;
   }
   static getMeshLODInformation(t) {
     const e = this.getAssignedLODInformation(t);
@@ -158,11 +158,11 @@ const O = class {
         this.getMaterialMinMaxLODsCount(n, e);
       return t[o] = e, e;
     }
-    if (L === "verbose" && console.log("getMaterialMinMaxLODsCount", t), t.type === "ShaderMaterial" || t.type === "RawShaderMaterial") {
+    if (M === "verbose" && console.log("getMaterialMinMaxLODsCount", t), t.type === "ShaderMaterial" || t.type === "RawShaderMaterial") {
       const n = t;
       for (const l of Object.keys(n.uniforms)) {
-        const f = n.uniforms[l].value;
-        (f == null ? void 0 : f.isTexture) === !0 && s(f, e);
+        const u = n.uniforms[l].value;
+        (u == null ? void 0 : u.isTexture) === !0 && s(u, e);
       }
     } else if (t.isMaterial)
       for (const n of Object.keys(t)) {
@@ -171,14 +171,14 @@ const O = class {
       }
     return t[o] = e, e;
     function s(n, l) {
-      const f = r.getAssignedLODInformation(n);
-      if (f) {
-        const c = r.lodInfos.get(f.key);
+      const u = r.getAssignedLODInformation(n);
+      if (u) {
+        const c = r.lodInfos.get(u.key);
         if (c && c.lods) {
           l.min_count = Math.min(l.min_count, c.lods.length), l.max_count = Math.max(l.max_count, c.lods.length);
-          for (let M = 0; M < c.lods.length; M++) {
-            const u = c.lods[M];
-            u.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, u.height), l.lods[M].max_height = Math.max(l.lods[M].max_height, u.height));
+          for (let D = 0; D < c.lods.length; D++) {
+            const h = c.lods[D];
+            h.width && (l.lods[D] = l.lods[D] || { min_height: 1 / 0, max_height: 0 }, l.lods[D].min_height = Math.min(l.lods[D].min_height, h.height), l.lods[D].max_height = Math.max(l.lods[D].max_height, h.height));
           }
         }
       }
@@ -237,24 +237,24 @@ const O = class {
     var r;
     if (!t)
       return Promise.resolve(null);
-    if (t instanceof J || t.isMesh === !0) {
+    if (t instanceof H || t.isMesh === !0) {
       const o = t.geometry, i = this.getAssignedLODInformation(o);
       if (!i)
         return Promise.resolve(null);
-      for (const s of X)
+      for (const s of Y)
         (r = s.onBeforeGetLODMesh) == null || r.call(s, t, e);
-      return t["LOD:requested level"] = e, O.getOrLoadLOD(o, e).then((s) => {
+      return t["LOD:requested level"] = e, _.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 && o != s && ((s == null ? void 0 : s.isBufferGeometry) ? (t.geometry = s, L && Ae(t, "geometry", i.url)) : L && console.error("Invalid LOD geometry", s));
+          s && o != s && ((s == null ? void 0 : s.isBufferGeometry) ? (t.geometry = s, M && Ae(t, "geometry", i.url)) : M && console.error("Invalid LOD geometry", s));
         }
         return s;
       }).catch((s) => (console.error("Error loading mesh LOD", t, s), null));
     } else
-      L && console.error("Invalid call to assignMeshLOD: Request mesh LOD but the object is not a mesh", t);
+      M && 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)  
@@ -269,13 +269,13 @@ const O = class {
       return Promise.resolve(null);
     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) {
+      if (M && ve.add(r), r.uniforms && r.isRawShaderMaterial || r.isShaderMaterial === !0) {
         const s = r;
         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, e, r, n);
-            o.push(f), i.push(n);
+            const u = this.assignTextureLODForSlot(l, e, r, n);
+            o.push(u), i.push(n);
           }
         }
       } else
@@ -289,8 +289,8 @@ const O = class {
       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 ? n.push({ material: r, slot: c, texture: f, level: e }) : n.push({ material: r, slot: c, texture: null, level: e });
+          const u = s[l], c = i[l];
+          u && u.isTexture === !0 ? n.push({ material: r, slot: c, texture: u, level: e }) : n.push({ material: r, slot: c, texture: null, level: e });
         }
         return n;
       });
@@ -302,7 +302,7 @@ const O = class {
     return Promise.resolve(null);
   }
   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) => {
+    return (t == null ? void 0 : t.isTexture) !== !0 ? Promise.resolve(null) : o === "glyphMap" ? Promise.resolve(t) : _.getOrLoadLOD(t, e).then((i) => {
       if (Array.isArray(i))
         return null;
       if ((i == null ? void 0 : i.isTexture) === !0) {
@@ -312,164 +312,164 @@ const O = class {
             if (s) {
               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;
+                return M === "verbose" && console.warn("Assigned texture level is already higher: ", n.level, e, r, s, i), null;
             }
             r[o] = i;
           }
-          if (L && o && r) {
+          if (M && o && r) {
             const s = this.getAssignedLODInformation(t);
             s && Ae(r, o, s.url);
           }
         }
         return i;
       } else
-        L == "verbose" && console.warn("No LOD found for", t, e);
+        M == "verbose" && console.warn("No LOD found for", t, e);
       return null;
     }).catch((i) => (console.error("Error loading LOD", t, i), null));
   }
   afterRoot(t) {
     var e, r;
-    return L && console.log("AFTER", this.url, t), (e = this.parser.json.textures) == null || e.forEach((o, i) => {
+    return M && console.log("AFTER", this.url, t), (e = this.parser.json.textures) == null || e.forEach((o, i) => {
       var s;
       if (o != null && o.extensions) {
-        const n = o == null ? void 0 : o.extensions[N];
+        const n = o == null ? void 0 : o.extensions[U];
         if (n) {
           if (!n.lods) {
-            L && console.warn("Texture has no LODs", n);
+            M && console.warn("Texture has no LODs", n);
             return;
           }
           let l = !1;
-          for (const f of this.parser.associations.keys())
-            if (f.isTexture === !0) {
-              const c = this.parser.associations.get(f);
-              (c == null ? void 0 : c.textures) === i && (l = !0, O.registerTexture(this.url, f, (s = n.lods) == null ? void 0 : s.length, i, n));
+          for (const u of this.parser.associations.keys())
+            if (u.isTexture === !0) {
+              const c = this.parser.associations.get(u);
+              (c == null ? void 0 : c.textures) === i && (l = !0, _.registerTexture(this.url, u, (s = n.lods) == null ? void 0 : s.length, i, n));
             }
-          l || this.parser.getDependency("texture", i).then((f) => {
+          l || this.parser.getDependency("texture", i).then((u) => {
             var c;
-            f && O.registerTexture(this.url, f, (c = n.lods) == null ? void 0 : c.length, i, n);
+            u && _.registerTexture(this.url, u, (c = n.lods) == null ? void 0 : c.length, i, n);
           });
         }
       }
     }), (r = this.parser.json.meshes) == null || r.forEach((o, i) => {
       if (o != null && o.extensions) {
-        const s = o == null ? void 0 : o.extensions[N];
+        const s = o == null ? void 0 : o.extensions[U];
         if (s && s.lods) {
           for (const n of this.parser.associations.keys())
             if (n.isMesh) {
               const l = this.parser.associations.get(n);
-              (l == null ? void 0 : l.meshes) === i && O.registerMesh(this.url, s.guid, n, s.lods.length, l.primitives, s);
+              (l == null ? void 0 : l.meshes) === i && _.registerMesh(this.url, s.guid, n, s.lods.length, l.primitives, s);
             }
         }
       }
     }), null;
   }
   static async getOrLoadLOD(t, e) {
-    var n, l, f, c;
-    const r = L == "verbose", o = t.userData.LODS;
+    var n, l, u, c;
+    const r = M == "verbose", o = t.userData.LODS;
     if (!o)
       return null;
     const i = o == null ? void 0 : o.key;
     let s;
     if (t.isTexture === !0) {
-      const M = t;
-      M.source && M.source[xe] && (s = M.source[xe]);
+      const D = t;
+      D.source && D.source[xe] && (s = D.source[xe]);
     }
-    if (s || (s = O.lodInfos.get(i)), s) {
+    if (s || (s = _.lodInfos.get(i)), s) {
       if (e > 0) {
-        let y = !1;
-        const v = Array.isArray(s.lods);
-        if (v && e >= s.lods.length ? y = !0 : v || (y = !0), y)
+        let d = !1;
+        const p = Array.isArray(s.lods);
+        if (p && e >= s.lods.length ? d = !0 : p || (d = !0), d)
           return this.lowresCache.get(i);
       }
-      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 u = Ze(o.url, M);
-      if (u.endsWith(".glb") || u.endsWith(".gltf")) {
+      const D = Array.isArray(s.lods) ? (n = s.lods[e]) == null ? void 0 : n.path : s.lods;
+      if (!D)
+        return M && !s["missing:uri"] && (s["missing:uri"] = !0, console.warn("Missing uri for progressive asset for LOD " + e, s)), null;
+      const h = Ze(o.url, D);
+      if (h.endsWith(".glb") || h.endsWith(".gltf")) {
         if (!s.guid)
           return console.warn("missing pointer for glb/gltf texture", s), null;
-        const y = u + "_" + 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 ${u}
-`, Y), null)), D = !1;
-          if (p == null || (p instanceof ee && t instanceof ee ? (l = p.image) != null && l.data || (f = p.source) != null && f.data ? p = this.copySettings(t, p) : (D = !0, this.previouslyLoaded.delete(y)) : p instanceof de && t instanceof de && ((c = p.attributes.position) != null && c.array || (D = !0, this.previouslyLoaded.delete(y)))), !D)
-            return p;
+        const d = h + "_" + s.guid, p = this.previouslyLoaded.get(d);
+        if (p !== void 0) {
+          r && console.log(`LOD ${e} was already loading/loaded: ${d}`);
+          let m = await p.catch((z) => (console.error(`Error loading LOD ${e} from ${h}
+`, z), null)), w = !1;
+          if (m == null || (m instanceof ee && t instanceof ee ? (l = m.image) != null && l.data || (u = m.source) != null && u.data ? m = this.copySettings(t, m) : (w = !0, this.previouslyLoaded.delete(d)) : m instanceof de && t instanceof de && ((c = m.attributes.position) != null && c.array || (w = !0, this.previouslyLoaded.delete(d)))), !w)
+            return m;
         }
-        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) " + u, x.guid));
-          let G = u;
-          if (x && Array.isArray(x.lods)) {
-            const b = x.lods[e];
-            b.hash && (G += "?v=" + b.hash);
+        const L = s, k = new Promise(async (m, w) => {
+          const z = new Ye();
+          Ie(z), M && (await new Promise((O) => setTimeout(O, 1e3)), r && console.warn("Start loading (delayed) " + h, L.guid));
+          let q = h;
+          if (L && Array.isArray(L.lods)) {
+            const O = L.lods[e];
+            O.hash && (q += "?v=" + O.hash);
           }
-          const _ = await Y.loadAsync(G).catch((b) => (console.error(`Error loading LOD ${e} from ${u}
-`, b), null));
-          if (!_)
+          const S = await z.loadAsync(q).catch((O) => (console.error(`Error loading LOD ${e} from ${h}
+`, O), null));
+          if (!S)
             return null;
-          const K = _.parser;
-          r && console.log("Loading finished " + u, 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[N];
-                if (h != null && h.guid && h.guid === x.guid) {
-                  b = !0;
+          const V = S.parser;
+          r && console.log("Loading finished " + h, L.guid);
+          let A = 0;
+          if (S.parser.json.textures) {
+            let O = !1;
+            for (const y of S.parser.json.textures) {
+              if (y != null && y.extensions) {
+                const g = y == null ? void 0 : y.extensions[U];
+                if (g != null && g.guid && g.guid === L.guid) {
+                  O = !0;
                   break;
                 }
               }
-              F++;
+              A++;
             }
-            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 + '"', u, F, g, y), t instanceof ee && (g = this.copySettings(t, g)), g && (g.guid = x.guid), p(g);
+            if (O) {
+              let y = await V.getDependency("texture", A);
+              return y && _.assignLODInformation(o.url, y, i, e, void 0, void 0), r && console.log('change "' + t.name + '" → "' + y.name + '"', h, A, y, d), t instanceof ee && (y = this.copySettings(t, y)), y && (y.guid = L.guid), m(y);
             } else
-              L && console.warn("Could not find texture with guid", x.guid, _.parser.json);
+              M && console.warn("Could not find texture with guid", L.guid, S.parser.json);
           }
-          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[N];
-                if (h != null && h.guid && h.guid === x.guid) {
-                  b = !0;
+          if (A = 0, S.parser.json.meshes) {
+            let O = !1;
+            for (const y of S.parser.json.meshes) {
+              if (y != null && y.extensions) {
+                const g = y == null ? void 0 : y.extensions[U];
+                if (g != null && g.guid && g.guid === L.guid) {
+                  O = !0;
                   break;
                 }
               }
-              F++;
+              A++;
             }
-            if (b) {
-              const g = await K.getDependency("mesh", F), h = x;
-              if (r && console.log(`Loaded Mesh "${g.name}"`, u, F, g, y), g.isMesh === !0) {
-                const w = g.geometry;
-                return O.assignLODInformation(o.url, w, i, e, void 0, h.density), p(w);
+            if (O) {
+              const y = await V.getDependency("mesh", A), g = L;
+              if (r && console.log(`Loaded Mesh "${y.name}"`, h, A, y, d), y.isMesh === !0) {
+                const v = y.geometry;
+                return _.assignLODInformation(o.url, v, i, e, void 0, g.density), m(v);
               } else {
-                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);
+                const v = new Array();
+                for (let T = 0; T < y.children.length; T++) {
+                  const P = y.children[T];
+                  if (P.isMesh === !0) {
+                    const E = P.geometry;
+                    _.assignLODInformation(o.url, E, i, e, T, g.density), v.push(E);
                   }
                 }
-                return p(w);
+                return m(v);
               }
             } else
-              L && console.warn("Could not find mesh with guid", x.guid, _.parser.json);
+              M && console.warn("Could not find mesh with guid", L.guid, S.parser.json);
           }
-          return p(null);
+          return m(null);
         });
-        return this.previouslyLoaded.set(y, R), await R;
+        return this.previouslyLoaded.set(d, k), await k;
       } else if (t instanceof ee) {
-        r && console.log("Load texture from uri: " + u);
-        const v = await new Ue().loadAsync(u);
-        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", u), v;
+        r && console.log("Load texture from uri: " + h);
+        const p = await new Ue().loadAsync(h);
+        return p ? (p.guid = s.guid, p.flipY = !1, p.needsUpdate = !0, p.colorSpace = t.colorSpace, r && console.log(s, p)) : M && console.warn("failed loading", h), p;
       }
     } else
-      L && console.warn(`Can not load LOD ${e}: no LOD info found for "${i}" ${t.name}`, t.type);
+      M && console.warn(`Can not load LOD ${e}: no LOD info found for "${i}" ${t.name}`, t.type);
     return null;
   }
   static assignLODInformation(t, e, r, o, i, s) {
@@ -485,95 +485,95 @@ const O = class {
   }
   // private static readonly _copiedTextures: WeakMap<Texture, Texture> = new Map();
   static copySettings(t, e) {
-    return e = e.clone(), L && console.warn(`Copying texture settings
+    return e = e.clone(), M && 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 S = O;
+let b = _;
 /**
  * Register a texture with LOD information
  */
-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");
+f(b, "registerTexture", (t, e, r, o, i) => {
+  if (M && console.log("> Progressive: register texture", o, e.name, e.uuid, e, i), !e) {
+    M && console.error("gltf-progressive: Register texture without texture");
     return;
   }
   e.source && (e.source[xe] = i);
   const s = i.guid;
-  O.assignLODInformation(t, e, s, r, o, void 0), O.lodInfos.set(s, i), O.lowresCache.set(s, e);
+  _.assignLODInformation(t, e, s, r, o, void 0), _.lodInfos.set(s, i), _.lowresCache.set(s, e);
 }), /**
  * Register a mesh with LOD information
  */
-d(S, "registerMesh", (t, e, r, o, i, s) => {
-  var f;
-  L && console.log("> Progressive: register mesh", i, r.name, s, r.uuid, r);
+f(b, "registerMesh", (t, e, r, o, i, s) => {
+  var u;
+  M && 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");
+    M && console.warn("gltf-progressive: Register mesh without geometry");
     return;
   }
-  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 c of X)
-    (f = c.onRegisteredNewMesh) == null || f.call(c, r, s);
+  n.userData || (n.userData = {}), _.assignLODInformation(t, n, e, o, i, s.density), _.lodInfos.set(e, s);
+  let l = _.lowresCache.get(e);
+  l ? l.push(r.geometry) : l = [r.geometry], _.lowresCache.set(e, l), o > 0 && !Oe(r) && et(r, n);
+  for (const c of Y)
+    (u = c.onRegisteredNewMesh) == null || u.call(c, r, s);
 }), /** A map of key = asset uuid and value = LOD information */
-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());
+f(b, "lodInfos", /* @__PURE__ */ new Map()), /** cache of already loaded mesh lods */
+f(b, "previouslyLoaded", /* @__PURE__ */ new Map()), /** this contains the geometry/textures that were originally loaded */
+f(b, "lowresCache", /* @__PURE__ */ new Map());
 class rt {
   constructor(t, e, r, o, i) {
-    d(this, "url");
+    f(this, "url");
     /** the key to lookup the LOD information */
-    d(this, "key");
-    d(this, "level");
+    f(this, "key");
+    f(this, "level");
     /** For multi objects (e.g. a group of meshes) this is the index of the object */
-    d(this, "index");
+    f(this, "index");
     /** the mesh density */
-    d(this, "density");
+    f(this, "density");
     this.url = t, this.key = e, this.level = r, o != null && (this.index = o), i != null && (this.density = i);
   }
 }
-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 {
+const I = ae("debugprogressive"), st = ae("noprogressive"), Le = Symbol("Needle:LODSManager"), Me = Symbol("Needle:LODState"), J = Symbol("Needle:CurrentLOD"), R = { mesh_lod: -1, texture_lod: -1 };
+var B, W, ge, Q, Z, pe, K;
+const C = class {
   // readonly plugins: NEEDLE_progressive_plugin[] = [];
   constructor(t, e) {
-    d(this, "context");
-    d(this, "renderer");
-    d(this, "projectionScreenMatrix", new be());
-    d(this, "cameraFrustrum", new We());
+    f(this, "context");
+    f(this, "renderer");
+    f(this, "projectionScreenMatrix", new be());
+    f(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);
+    f(this, "targetTriangleDensity", 2e5);
     /**
      * 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", "auto");
-    q(this, C, 1);
+    f(this, "updateInterval", "auto");
+    X(this, B, 1);
     /**
      * If set to true, the LODsManager will not update the LODs.
      */
-    d(this, "pause", !1);
-    d(this, "_lodchangedlisteners", []);
-    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]);
+    f(this, "pause", !1);
+    f(this, "_lodchangedlisteners", []);
+    X(this, W, void 0);
+    X(this, ge, new Ke());
+    X(this, Q, 0);
+    X(this, Z, 0);
+    X(this, pe, 0);
+    X(this, K, 0);
+    f(this, "_fpsBuffer", [60, 60, 60, 60, 60]);
     // private testIfLODLevelsAreAvailable() {
-    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());
+    f(this, "_sphere", new Xe());
+    f(this, "_tempBox", new Te());
+    f(this, "_tempBox2", new Te());
+    f(this, "tempMatrix", new be());
+    f(this, "_tempWorldPosition", new N());
+    f(this, "_tempBoxSize", new N());
+    f(this, "_tempBox2Size", new N());
     this.renderer = t, this.context = { ...e };
   }
   /** @internal */
@@ -581,11 +581,11 @@ const E = class {
     return t[Me];
   }
   static addPlugin(t) {
-    X.push(t);
+    Y.push(t);
   }
   static removePlugin(t) {
-    const e = X.indexOf(t);
-    e >= 0 && X.splice(e, 1);
+    const e = Y.indexOf(t);
+    e >= 0 && Y.splice(e, 1);
   }
   /**
    * Gets the LODsManager for the given renderer. If the LODsManager does not exist yet, it will be created.  
@@ -595,7 +595,7 @@ const E = class {
   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, {
+    const r = new C(t, {
       engine: "unknown",
       ...e
     });
@@ -603,7 +603,7 @@ const E = class {
   }
   /** @deprecated use static `LODsManager.addPlugin()` method. This getter will be removed in later versions */
   get plugins() {
-    return X;
+    return Y;
   }
   addEventListener(t, e) {
     t === "changed" && this._lodchangedlisteners.push(e);
@@ -612,25 +612,25 @@ const E = class {
    * Enable the LODsManager. This will replace the render method of the renderer with a method that updates the LODs.
    */
   enable() {
-    if (m(this, U))
+    if (x(this, W))
       return;
     console.debug("[gltf-progressive] Enabling LODsManager for renderer");
     let t = 0;
-    $(this, U, this.renderer.render);
+    F(this, W, 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, f) => l + f) / 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);
+      e.renderer.getRenderTarget() == null && (t = 0, F(e, Q, x(e, Q) + 1), F(e, Z, x(e, ge).getDelta()), F(e, pe, x(e, pe) + x(e, Z)), e._fpsBuffer.shift(), e._fpsBuffer.push(1 / x(e, Z)), F(e, K, e._fpsBuffer.reduce((l, u) => l + u) / e._fpsBuffer.length), I && x(e, Q) % 30 === 0 && console.log("FPS", Math.round(x(e, K)), "Interval:", x(e, B)));
+      const s = x(e, Q), n = t++;
+      e.onBeforeRender(r, o, n, s), x(e, W).call(this, r, o), e.onAfterRender(r, o, n, s);
     };
   }
   disable() {
-    m(this, U) && (this.renderer.render = m(this, U), $(this, U, void 0));
+    x(this, W) && (this.renderer.render = x(this, W), F(this, W, void 0));
   }
   onBeforeRender(t, e, r, o) {
   }
   onAfterRender(t, e, r, o) {
-    var l, f;
+    var l, u;
     if (this.pause)
       return;
     const i = this.renderer.renderLists.get(t, 0), s = i.opaque;
@@ -640,16 +640,16 @@ const E = class {
       (c.name === "EffectMaterial" || c.name === "CopyShader") && (n = !1);
     }
     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))
+      if (st || (this.updateInterval === "auto" ? x(this, K) < 40 && x(this, B) < 10 ? (F(this, B, x(this, B) + 1), I && console.warn("↓ Reducing LOD updates", x(this, B), x(this, K).toFixed(0))) : x(this, K) >= 60 && x(this, B) > 1 && (F(this, B, x(this, B) - 1), I && console.warn("↑ Increasing LOD updates", x(this, B), x(this, K).toFixed(0))) : F(this, B, this.updateInterval), x(this, B) > 0 && o % x(this, B) != 0))
         return;
       this.projectionScreenMatrix.multiplyMatrices(e.projectionMatrix, e.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")) {
-          B && (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)));
+      for (const d of s) {
+        if (d.material && (((l = d.geometry) == null ? void 0 : l.type) === "BoxGeometry" || ((u = d.geometry) == null ? void 0 : u.type) === "BufferGeometry") && (d.material.name === "SphericalGaussianBlur" || d.material.name == "BackgroundCubeMaterial" || d.material.name === "CubemapFromEquirect" || d.material.name === "EquirectangularToCubeUV")) {
+          I && (d.material["NEEDLE_PROGRESSIVE:IGNORE-WARNING"] || (d.material["NEEDLE_PROGRESSIVE:IGNORE-WARNING"] = !0, console.warn("Ignoring skybox or BLIT object", d, d.material.name, d.material.type)));
           continue;
         }
-        switch (u.material.type) {
+        switch (d.material.type) {
           case "LineBasicMaterial":
           case "LineDashedMaterial":
           case "PointsMaterial":
@@ -658,39 +658,44 @@ const E = class {
           case "MeshDepthMaterial":
             continue;
         }
-        if (B === "color" && u.material && !u.object.progressive_debug_color) {
-          u.object.progressive_debug_color = !0;
-          const v = Math.random() * 16777215, x = new qe({ color: v });
-          u.object.material = x;
+        if (I === "color" && d.material && !d.object.progressive_debug_color) {
+          d.object.progressive_debug_color = !0;
+          const L = Math.random() * 16777215, k = new qe({ color: L });
+          d.object.material = k;
         }
-        const y = u.object;
-        (y instanceof J || y.isMesh) && this.updateLODs(t, e, y, c, o);
+        const p = d.object;
+        (p instanceof H || p.isMesh) && this.updateLODs(t, e, p, c, o);
       }
-      const M = i.transparent;
-      for (const u of M) {
-        const y = u.object;
-        (y instanceof J || y.isMesh) && this.updateLODs(t, e, y, c, o);
+      const D = i.transparent;
+      for (const d of D) {
+        const p = d.object;
+        (p instanceof H || p.isMesh) && this.updateLODs(t, e, p, c, o);
+      }
+      const h = i.transmissive;
+      for (const d of h) {
+        const p = d.object;
+        (p instanceof H || p.isMesh) && this.updateLODs(t, e, p, c, o);
       }
     }
   }
   /** Update the LOD levels for the renderer. */
   updateLODs(t, e, r, o, i) {
-    var l, f;
+    var l, u;
     r.userData || (r.userData = {});
     let s = r[Me];
     if (s || (s = new it(), r[Me] = s), s.frames++ < 2)
       return;
-    for (const c of X)
+    for (const c of Y)
       (l = c.onBeforeUpdateLOD) == null || l.call(c, 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;
+    this.calculateLodLevel(e, r, s, o, R), R.mesh_lod = Math.round(R.mesh_lod), R.texture_lod = Math.round(R.texture_lod), R.mesh_lod >= 0 && this.loadProgressiveMeshes(r, R.mesh_lod);
+    let n = R.texture_lod;
     if (r.material && n >= 0) {
       const c = r["DEBUG:LOD"];
       c != null && (n = c), this.loadProgressiveTextures(r.material, n);
     }
-    for (const c of X)
-      (f = c.onAfterUpdatedLOD) == null || f.call(c, this.renderer, t, e, r, k);
-    s.lastLodLevel_Mesh = k.mesh_lod, s.lastLodLevel_Texture = k.texture_lod;
+    for (const c of Y)
+      (u = c.onAfterUpdatedLOD) == null || u.call(c, this.renderer, t, e, r, R);
+    s.lastLodLevel_Mesh = R.mesh_lod, s.lastLodLevel_Texture = R.texture_lod;
   }
   /** Load progressive textures for the given material
    * @param material the material to load the textures for
@@ -706,7 +711,7 @@ const E = class {
       return;
     }
     let r = !1;
-    (t[H] === void 0 || e < t[H]) && (r = !0), r && (t[H] = e, S.assignTextureLOD(t, e).then((o) => {
+    (t[J] === void 0 || e < t[J]) && (r = !0), r && (t[J] = e, b.assignTextureLOD(t, e).then((o) => {
       this._lodchangedlisteners.forEach((i) => i({ type: "texture", level: e, object: t }));
     }));
   }
@@ -719,10 +724,10 @@ const E = class {
   loadProgressiveMeshes(t, e) {
     if (!t)
       return Promise.resolve(null);
-    if (t[H] !== e) {
-      t[H] = e;
+    if (t[J] !== e) {
+      t[J] = 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 b.assignMeshLOD(t, e).then((o) => (o && t[J] == e && r != t.geometry && this._lodchangedlisteners.forEach((i) => i({ type: "mesh", level: e, object: t })), o));
     }
     return Promise.resolve(null);
   }
@@ -731,7 +736,7 @@ const E = class {
     return this._tempPtInside.set(i, s, r.z).applyMatrix4(e).z < 0;
   }
   calculateLodLevel(t, e, r, o, i) {
-    var R, z;
+    var k, $;
     if (!e) {
       i.mesh_lod = -1, i.texture_lod = -1;
       return;
@@ -741,113 +746,114 @@ const E = class {
       return;
     }
     let n = 10 + 1, l = !1;
-    if (B && e["DEBUG:LOD"] != null)
+    if (I && e["DEBUG:LOD"] != null)
       return e["DEBUG:LOD"];
-    const f = S.getMeshLODInformation(e.geometry), c = f == null ? void 0 : f.lods, M = c && c.length > 0, u = S.getMaterialMinMaxLODsCount(e.material), y = (u == null ? void 0 : u.min_count) != 1 / 0 && u.min_count > 0 && u.max_count > 0;
-    if (!M && !y) {
+    const u = b.getMeshLODInformation(e.geometry), c = u == null ? void 0 : u.lods, D = c && c.length > 0, h = b.getMaterialMinMaxLODsCount(e.material), d = (h == null ? void 0 : h.min_count) != 1 / 0 && h.min_count > 0 && h.max_count > 0;
+    if (!D && !d) {
       i.mesh_lod = 0, i.texture_lod = 0;
       return;
     }
-    if (M || (l = !0, n = 0), !((R = this.cameraFrustrum) != null && R.intersectsObject(e))) {
+    if (D || (l = !0, n = 0), !((k = this.cameraFrustrum) != null && k.intersectsObject(e))) {
       i.mesh_lod = 99, i.texture_lod = 99;
       return;
     }
-    const v = this.renderer.domElement.clientHeight || this.renderer.domElement.height;
-    let x = e.geometry.boundingBox;
+    const p = this.renderer.domElement.clientHeight || this.renderer.domElement.height;
+    let L = e.geometry.boundingBox;
     if (e.type === "SkinnedMesh") {
-      const p = e;
-      p.boundingBox || p.computeBoundingBox(), x = p.boundingBox;
+      const m = e;
+      m.boundingBox || m.computeBoundingBox(), L = m.boundingBox;
     }
-    if (x && t.isPerspectiveCamera) {
-      const p = t;
+    if (L && t.isPerspectiveCamera) {
+      const m = 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)) {
+        const g = t.getWorldPosition(this._tempWorldPosition);
+        if (this._sphere.containsPoint(g)) {
           i.mesh_lod = 0, i.texture_lod = 0;
           return;
         }
       }
-      if (this._tempBox.copy(x), this._tempBox.applyMatrix4(e.matrixWorld), E.isInside(this._tempBox, this.projectionScreenMatrix)) {
+      if (this._tempBox.copy(L), this._tempBox.applyMatrix4(e.matrixWorld), C.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, 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);
+      if (this._tempBox.applyMatrix4(this.projectionScreenMatrix), this.renderer.xr.enabled && m.fov > 70) {
+        const g = this._tempBox.min, v = this._tempBox.max;
+        let T = g.x, P = g.y, E = v.x, j = v.y;
+        const le = 2, ye = 1.5, ce = (g.x + v.x) * 0.5, ue = (g.y + v.y) * 0.5;
+        T = (T - ce) * le + ce, P = (P - ue) * le + ue, E = (E - ce) * le + ce, j = (j - ue) * le + ue;
+        const Fe = T < 0 && E > 0 ? 0 : Math.min(Math.abs(g.x), Math.abs(v.x)), $e = P < 0 && j > 0 ? 0 : Math.min(Math.abs(g.y), Math.abs(v.y)), me = Math.max(Fe, $e);
         r.lastCentrality = (ye - me) * (ye - me) * (ye - me);
       } else
         r.lastCentrality = 1;
-      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 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);
+      const w = this._tempBox.getSize(this._tempBoxSize);
+      w.multiplyScalar(0.5), screen.availHeight > 0 && p > 0 && w.multiplyScalar(p / screen.availHeight), w.x *= m.aspect;
+      const z = t.matrixWorldInverse, q = this._tempBox2;
+      q.copy(L), q.applyMatrix4(e.matrixWorld), q.applyMatrix4(z);
+      const S = q.getSize(this._tempBox2Size), V = Math.max(S.x, S.y);
+      if (Math.max(w.x, w.y) != 0 && V != 0 && (w.z = S.z / Math.max(S.x, S.y) * Math.max(w.x, w.y)), r.lastScreenCoverage = Math.max(w.x, w.y, w.z), r.lastScreenspaceVolume.copy(w), r.lastScreenCoverage *= r.lastCentrality, I && C.debugDrawLine) {
+        const g = this.tempMatrix.copy(this.projectionScreenMatrix);
+        g.invert();
+        const v = C.corner0, T = C.corner1, P = C.corner2, E = C.corner3;
+        v.copy(this._tempBox.min), T.copy(this._tempBox.max), T.x = v.x, P.copy(this._tempBox.max), P.y = v.y, E.copy(this._tempBox.max);
+        const j = (v.z + E.z) * 0.5;
+        v.z = T.z = P.z = E.z = j, v.applyMatrix4(g), T.applyMatrix4(g), P.applyMatrix4(g), E.applyMatrix4(g), C.debugDrawLine(v, T, 255), C.debugDrawLine(v, P, 255), C.debugDrawLine(T, E, 255), C.debugDrawLine(P, E, 255);
       }
-      let b = 999;
+      let O = 999;
       if (c && r.lastScreenCoverage > 0) {
-        for (let h = 0; h < c.length; h++)
-          if (c[h].density / r.lastScreenCoverage < o) {
-            b = h;
+        for (let g = 0; g < c.length; g++)
+          if (c[g].density / r.lastScreenCoverage < o) {
+            O = g;
             break;
           }
       }
-      b < n && (n = b, l = !0);
+      O < n && (n = O, l = !0);
     }
-    if (l ? i.mesh_lod = n : i.mesh_lod = r.lastLodLevel_Mesh, B && i.mesh_lod != r.lastLodLevel_Mesh) {
-      const D = c == null ? void 0 : c[i.mesh_lod];
-      D && console.log(`Mesh LOD changed: ${r.lastLodLevel_Mesh} → ${i.mesh_lod} (${D.density.toFixed(0)}) - ${e.name}`);
+    if (l ? i.mesh_lod = n : i.mesh_lod = r.lastLodLevel_Mesh, I && i.mesh_lod != r.lastLodLevel_Mesh) {
+      const w = c == null ? void 0 : c[i.mesh_lod];
+      w && console.log(`Mesh LOD changed: ${r.lastLodLevel_Mesh} → ${i.mesh_lod} (${w.density.toFixed(0)}) - ${e.name}`);
     }
-    if (y)
+    if (d) {
+      const m = "saveData" in globalThis.navigator && globalThis.navigator.saveData === !0;
       if (r.lastLodLevel_Texture < 0) {
-        if (i.texture_lod = u.max_count - 1, B) {
-          const p = u.lods[u.max_count - 1];
-          B && console.log(`First Texture LOD ${i.texture_lod} (${p.max_height}px) - ${e.name}`);
+        if (i.texture_lod = h.max_count - 1, I) {
+          const w = h.lods[h.max_count - 1];
+          I && console.log(`First Texture LOD ${i.texture_lod} (${w.max_height}px) - ${e.name}`);
         }
       } else {
-        const p = r.lastScreenspaceVolume.x + r.lastScreenspaceVolume.y + r.lastScreenspaceVolume.z;
-        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 _ = u.lods.length - 1; _ >= 0; _--) {
-          let K = u.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)} 
+        const w = r.lastScreenspaceVolume.x + r.lastScreenspaceVolume.y + r.lastScreenspaceVolume.z;
+        let z = r.lastScreenCoverage * 2;
+        (($ = this.context) == null ? void 0 : $.engine) === "model-viewer" && (z *= 2);
+        const S = p / window.devicePixelRatio * z;
+        for (let V = h.lods.length - 1; V >= 0; V--) {
+          let A = h.lods[V];
+          if (!(m && A.max_height >= 2048) && !(je() && A.max_height > 4096) && A.max_height > S) {
+            if (i.texture_lod = V, i.texture_lod < r.lastLodLevel_Texture) {
+              const O = A.max_height;
+              I && console.log(`Texture LOD changed: ${r.lastLodLevel_Texture} → ${i.texture_lod} = ${O}px 
+Screensize: ${S.toFixed(0)}px, Coverage: ${(100 * r.lastScreenCoverage).toFixed(2)}%, Volume ${w.toFixed(1)} 
 ${e.name}`);
             }
             break;
           }
         }
       }
-    else
+    } else
       i.texture_lod = 0;
   }
 };
-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.
+let G = C;
+B = new WeakMap(), W = new WeakMap(), ge = new WeakMap(), Q = new WeakMap(), Z = new WeakMap(), pe = new WeakMap(), K = new WeakMap(), /** Assign a function to draw debug lines for the LODs. This function will be called with the start and end position of the line and the color of the line when the `debugprogressive` query parameter is set.
  */
-d(I, "debugDrawLine"), 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());
+f(G, "debugDrawLine"), f(G, "corner0", new N()), f(G, "corner1", new N()), f(G, "corner2", new N()), f(G, "corner3", new N()), f(G, "_tempPtInside", new N());
 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 V());
-    d(this, "lastCentrality", 0);
+    f(this, "frames", 0);
+    f(this, "lastLodLevel_Mesh", -1);
+    f(this, "lastLodLevel_Texture", -1);
+    f(this, "lastScreenCoverage", 0);
+    f(this, "lastScreenspaceVolume", new N());
+    f(this, "lastCentrality", 0);
   }
 }
 const Pe = Symbol("NEEDLE_mesh_lod"), fe = Symbol("NEEDLE_texture_lod");
@@ -884,7 +890,7 @@ function Ge(a) {
 `, a.getAttribute("src"));
   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((f) => f.toString() == "Symbol(renderer)"), n = i.find((f) => f.toString() == "Symbol(scene)"), l = i.find((f) => f.toString() == "Symbol(needsRender)");
+    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 (t && e) {
@@ -900,8 +906,8 @@ function Ge(a) {
       }
     };
     console.debug("[gltf-progressive] setup model-viewer");
-    const i = I.get(t, { engine: "model-viewer" });
-    return I.addPlugin(new at()), i.enable(), i.addEventListener("changed", () => {
+    const i = G.get(t, { engine: "model-viewer" });
+    return G.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));
@@ -915,7 +921,7 @@ function Ge(a) {
 }
 class at {
   constructor() {
-    d(this, "_didWarnAboutMissingUrl", !1);
+    f(this, "_didWarnAboutMissingUrl", !1);
   }
   onBeforeUpdateLOD(t, e, r, o) {
     this.tryParseMeshLOD(e, o), this.tryParseTextureLOD(e, o);
@@ -939,25 +945,25 @@ class at {
     const r = this.tryGetCurrentGLTF(t), o = this.tryGetCurrentModelViewer(t), i = this.getUrl(o);
     if (i && r && e.material) {
       let s = function(l) {
-        var c, M, u;
+        var c, D, h;
         if (l[fe] == !0)
           return;
         l[fe] = !0, l.userData && (l.userData.LOD = -1);
-        const f = Object.keys(l);
-        for (let y = 0; y < f.length; y++) {
-          const v = f[y], x = l[v];
-          if ((x == null ? void 0 : x.isTexture) === !0) {
-            const R = (M = (c = x.userData) == null ? void 0 : c.associations) == null ? void 0 : M.textures;
-            if (R == null)
+        const u = Object.keys(l);
+        for (let d = 0; d < u.length; d++) {
+          const p = u[d], L = l[p];
+          if ((L == null ? void 0 : L.isTexture) === !0) {
+            const k = (D = (c = L.userData) == null ? void 0 : c.associations) == null ? void 0 : D.textures;
+            if (k == null)
               continue;
-            const z = r.parser.json.textures[R];
-            if (!z) {
-              console.warn("Texture data not found for texture index " + R);
+            const $ = r.parser.json.textures[k];
+            if (!$) {
+              console.warn("Texture data not found for texture index " + k);
               continue;
             }
-            if ((u = z == null ? void 0 : z.extensions) != null && u[N]) {
-              const p = z.extensions[N];
-              p && i && S.registerTexture(i, x, p.lods.length, R, p);
+            if ((h = $ == null ? void 0 : $.extensions) != null && h[U]) {
+              const m = $.extensions[U];
+              m && i && b.registerTexture(i, L, m.lods.length, k, m);
             }
           }
         }
@@ -978,23 +984,23 @@ class at {
     const r = this.tryGetCurrentModelViewer(t), o = this.getUrl(r);
     if (!o)
       return;
-    const i = (n = (s = e.userData) == null ? void 0 : s.gltfExtensions) == null ? void 0 : n[N];
+    const i = (n = (s = e.userData) == null ? void 0 : s.gltfExtensions) == null ? void 0 : n[U];
     if (i && o) {
       const l = e.uuid;
-      S.registerMesh(o, l, e, 0, i.lods.length, i);
+      b.registerMesh(o, l, e, 0, i.lods.length, i);
     }
   }
 }
 function mt(a, t, e, r) {
-  ke(t), Ie(e), e.register((i) => new S(i, a));
-  const o = I.get(t);
+  ke(t), Ie(e), e.register((i) => new b(i, a));
+  const o = G.get(t);
   return (r == null ? void 0 : r.enableLODsManager) !== !1 && o.enable(), o;
 }
 Re();
 export {
-  N as EXTENSION_NAME,
-  I as LODsManager,
-  S as NEEDLE_progressive,
+  U as EXTENSION_NAME,
+  G as LODsManager,
+  b as NEEDLE_progressive,
   Be as VERSION,
   Ie as addDracoAndKTX2Loaders,
   ke as createLoaders,