@needle-tools/gltf-progressive 1.0.0-alpha → 1.0.0-alpha.2

package/dist/@needle-tools-gltf-progressive.js

@@ -0,0 +1,651 @@
+var ne = Object.defineProperty;
+var ae = (l, e, t) => e in l ? ne(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 Y, BufferGeometry as X, Material as le, RawShaderMaterial as ue, Texture as z, TextureLoader as ce, Matrix4 as Z, Frustum as fe, Sphere as de, Box3 as j, Vector3 as C } 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";
+let Le = "https://www.gstatic.com/draco/versioned/decoders/1.4.1/", De = "https://www.gstatic.com/basis-universal/versioned/2021-04-15-ba1c3e4/", U, V, I;
+function se(l) {
+  U || (U = new pe(), U.setDecoderPath(Le), U.setDecoderConfig({ type: "js" })), I || (I = new ye(), I.setTranscoderPath(De)), V || (V = he), l ? I.detectSupport(l) : console.warn("No renderer provided to detect ktx2 support - loading KTX2 textures will probably fail");
+}
+function ie(l) {
+  l.dracoLoader || l.setDRACOLoader(U), l.ktx2Loader || l.setKTX2Loader(I), l.meshoptDecoder || l.setMeshoptDecoder(V);
+}
+function Q(l) {
+  let t = new URL(window.location.href).searchParams.get(l);
+  return t == null || t === "0" || t === "false" ? !1 : t === "" ? !0 : t;
+}
+function me(l, e) {
+  if (e === void 0 || e.startsWith("./") || e.startsWith("http") || l === void 0)
+    return e;
+  const t = l.lastIndexOf("/");
+  if (t >= 0) {
+    const r = l.substring(0, t + 1);
+    for (; r.endsWith("/") && e.startsWith("/"); )
+      e = e.substring(1);
+    return r + e;
+  }
+  return e;
+}
+const H = new Array();
+function ke(l) {
+  H.push(l);
+}
+const R = "NEEDLE_progressive", S = Q("debugprogressive"), q = Symbol("needle-progressive-texture"), W = /* @__PURE__ */ new Map(), J = /* @__PURE__ */ new Set();
+if (S) {
+  let l = function() {
+    e += 1, console.log("Toggle LOD level", e, W), W.forEach((i, o) => {
+      for (const s of i.keys) {
+        const n = o[s];
+        if (n.isBufferGeometry === !0) {
+          const a = M.getMeshLODInformation(n), d = a ? Math.min(e, a.lods.length) : 0;
+          o["DEBUG:LOD"] = d, M.assignMeshLOD(o, d), a && (t = Math.max(t, a.lods.length - 1));
+        } else if (o.isMaterial === !0) {
+          o["DEBUG:LOD"] = e, M.assignTextureLOD(o, 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, J && J.forEach((o) => {
+      o.name != "BackgroundCubeMaterial" && "wireframe" in o && (o.wireframe = r);
+    }));
+  });
+}
+function ee(l, e, t) {
+  var i;
+  if (!S)
+    return;
+  W.has(l) || W.set(l, { keys: [], sourceId: t });
+  const r = W.get(l);
+  ((i = r == null ? void 0 : r.keys) == null ? void 0 : i.includes(e)) == !1 && r.keys.push(e);
+}
+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;
+  }
+  /** The name of the extension */
+  get name() {
+    return R;
+  }
+  static getMeshLODInformation(e) {
+    const t = this.getAssignedLODInformation(e);
+    return t != null && t.key ? this.lodInfos.get(t.key) : null;
+  }
+  /** 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
+   * @returns true if the LOD level is available (or if any LOD level is available if level is undefined)
+   */
+  static hasLODLevelAvailable(e, t) {
+    var o;
+    if (e.isMaterial === !0) {
+      for (const s of Object.keys(e)) {
+        const n = e[s];
+        if (n.isTexture && this.hasLODLevelAvailable(n, t))
+          return !0;
+      }
+      return !1;
+    } else if (e.isGroup === !0) {
+      for (const s of e.children)
+        if (s.isMesh === !0 && this.hasLODLevelAvailable(s, t))
+          return !0;
+    }
+    let r, i;
+    if (e.isMesh ? r = e.geometry : (e.isBufferGeometry || e.isTexture) && (r = e), r && (o = r == null ? void 0 : r.userData) != null && o.LODS) {
+      const s = r.userData.LODS;
+      if (i = this.lodInfos.get(s.key), t === void 0)
+        return i != null;
+      if (i)
+        return Array.isArray(i.lods) ? t < i.lods.length : t === 0;
+    }
+    return !1;
+  }
+  /** Load a different resolution of a mesh (if available)
+   * @param context the context
+   * @param source the sourceid of the file from which the mesh is loaded (this is usually the component's sourceId)
+   * @param mesh the mesh to load the LOD for
+   * @param level the level of detail to load (0 is the highest resolution)
+   * @returns a promise that resolves to the mesh with the requested LOD level
+   * @example
+   * ```javascript
+   * const mesh = this.gameObject as Mesh;
+   * NEEDLE_progressive.assignMeshLOD(context, sourceId, mesh, 1).then(mesh => {
+   *    console.log("Mesh with LOD level 1 loaded", mesh);
+   * });
+   * ```
+   */
+  static assignMeshLOD(e, t) {
+    var r;
+    if (!e)
+      return Promise.resolve(null);
+    if (e instanceof Y || e.isMesh === !0) {
+      const i = e.geometry, o = this.getAssignedLODInformation(i);
+      if (!o)
+        return Promise.resolve(null);
+      for (const s of H)
+        (r = s.onBeforeGetLODMesh) == null || r.call(s, e, t);
+      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 n = o.index || 0;
+            s = s[n];
+          }
+          s && i != s && s instanceof X && (e.geometry = s, S && ee(e, "geometry", o.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);
+    return Promise.resolve(null);
+  }
+  /** Load a different resolution of a texture (if available)  
+   * @param context the context
+   * @param source the sourceid of the file from which the texture is loaded (this is usually the component's sourceId)
+   * @param materialOrTexture the material or texture to load the LOD for (if passing in a material all textures in the material will be loaded)
+   * @param level the level of detail to load (0 is the highest resolution) - currently only 0 is supported
+   * @returns a promise that resolves to the material or texture with the requested LOD level
+   */
+  static assignTextureLOD(e, t = 0) {
+    if (!e)
+      return Promise.resolve(null);
+    if (e instanceof le || e.isMaterial === !0) {
+      const r = e, i = [], o = new Array();
+      if (S && J.add(r), r instanceof ue)
+        for (const s of Object.keys(r.uniforms)) {
+          const n = r.uniforms[s].value;
+          if ((n == null ? void 0 : n.isTexture) === !0) {
+            const a = this.assignTextureLODForSlot(n, t, r, s);
+            i.push(a), o.push(s);
+          }
+        }
+      else
+        for (const s of Object.keys(r)) {
+          const n = r[s];
+          if ((n == null ? void 0 : n.isTexture) === !0) {
+            const a = this.assignTextureLODForSlot(n, t, r, s);
+            i.push(a), o.push(s);
+          }
+        }
+      return Promise.all(i).then((s) => {
+        const n = new Array();
+        for (let a = 0; a < s.length; a++) {
+          const d = s[a], f = o[a];
+          d && d.isTexture === !0 ? n.push({ material: r, slot: f, texture: d, level: t }) : n.push({ material: r, slot: f, texture: null, level: t });
+        }
+        return n;
+      });
+    }
+    if (e instanceof z || 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) : v.getOrLoadLOD(e, t).then((o) => {
+      if (Array.isArray(o))
+        return null;
+      if ((o == null ? void 0 : o.isTexture) === !0) {
+        if (o != e && (r && i && (r[i] = o), S && i && r)) {
+          const s = this.getAssignedLODInformation(e);
+          s && ee(r, i, s.url);
+        }
+        return o;
+      } else
+        S == "verbose" && console.warn("No LOD found for", e, t);
+      return null;
+    }).catch((o) => (console.error("Error loading LOD", e, o), null));
+  }
+  afterRoot(e) {
+    var t, r;
+    return S && console.log("AFTER", this.url, e), (t = this.parser.json.textures) == null || t.forEach((i, o) => {
+      if (i != null && i.extensions) {
+        const s = i == null ? void 0 : i.extensions[R];
+        if (s) {
+          let n = !1;
+          for (const a of this.parser.associations.keys())
+            a.isTexture === !0 && this.parser.associations.get(a).textures === o && (n = !0, v.registerTexture(this.url, a, o, s));
+          n || this.parser.getDependency("texture", o).then((a) => {
+            a && v.registerTexture(this.url, a, o, s);
+          });
+        }
+      }
+    }), (r = this.parser.json.meshes) == null || r.forEach((i, o) => {
+      if (i != null && i.extensions) {
+        const s = i == null ? void 0 : i.extensions[R];
+        if (s && s.lods) {
+          for (const n of this.parser.associations.keys())
+            if (n.isMesh) {
+              const a = this.parser.associations.get(n);
+              a.meshes === o && v.registerMesh(this.url, n.uuid, n, s.lods.length, a.primitives, s);
+            }
+        }
+      }
+    }), null;
+  }
+  static async getOrLoadLOD(e, t) {
+    var n, a, d;
+    const r = S == "verbose", i = e.userData.LODS;
+    if (!i)
+      return null;
+    const o = i == null ? void 0 : i.key;
+    let s;
+    if (e.isTexture === !0) {
+      const f = e;
+      f.source && f.source[q] && (s = f.source[q]);
+    }
+    if (s || (s = v.lodInfos.get(o)), s) {
+      if (t > 0) {
+        let g = !1;
+        const w = Array.isArray(s.lods);
+        if (w && t >= s.lods.length ? g = !0 : w || (g = !0), g)
+          return this.lowresCache.get(o);
+      }
+      const f = Array.isArray(s.lods) ? s.lods[t].path : s.lods;
+      if (!f)
+        return S && !s["missing:uri"] && (s["missing:uri"] = !0, console.warn("Missing uri for progressive asset for LOD " + t, s)), null;
+      const L = me(i.url, f);
+      if (L.endsWith(".glb") || L.endsWith(".gltf")) {
+        if (!s.guid)
+          return console.warn("missing pointer for glb/gltf texture", s), null;
+        const g = L + "_" + s.guid, w = this.previouslyLoaded.get(g);
+        if (w !== void 0) {
+          r && console.log(`LOD ${t} was already loading/loaded: ${g}`);
+          let m = await w.catch((E) => (console.error(`Error loading LOD ${t} from ${L}
+`, E), null)), B = !1;
+          if (m == null || (m instanceof z && e instanceof z ? (n = m.image) != null && n.data || (a = m.source) != null && a.data ? m = this.copySettings(e, m) : (B = !0, this.previouslyLoaded.delete(g)) : m instanceof X && e instanceof X && ((d = m.attributes.position) != null && d.array || (B = !0, this.previouslyLoaded.delete(g)))), !B)
+            return m;
+        }
+        const D = s, P = new Promise(async (m, B) => {
+          const E = new ge();
+          ie(E), S && (await new Promise((p) => setTimeout(p, 1e3)), r && console.warn("Start loading (delayed) " + L, D.guid));
+          let y = L;
+          if (D && Array.isArray(D.lods)) {
+            const p = D.lods[t];
+            p.hash && (y += "?v=" + p.hash);
+          }
+          const h = await E.loadAsync(y).catch((p) => (console.error(`Error loading LOD ${t} from ${L}
+`, p), null));
+          if (!h)
+            return null;
+          const T = h.parser;
+          r && console.log("Loading finished " + L, D.guid);
+          let x = 0;
+          if (h.parser.json.textures) {
+            let p = !1;
+            for (const c of h.parser.json.textures) {
+              if (c != null && c.extensions) {
+                const O = c == null ? void 0 : c.extensions[R];
+                if (O != null && O.guid && O.guid === D.guid) {
+                  p = !0;
+                  break;
+                }
+              }
+              x++;
+            }
+            if (p) {
+              let c = await T.getDependency("texture", x);
+              return r && console.log('change "' + e.name + '" → "' + c.name + '"', L, x, c, g), e instanceof z && (c = this.copySettings(e, c)), c && (c.guid = D.guid), m(c);
+            }
+          }
+          if (x = 0, h.parser.json.meshes) {
+            let p = !1;
+            for (const c of h.parser.json.meshes) {
+              if (c != null && c.extensions) {
+                const O = c == null ? void 0 : c.extensions[R];
+                if (O != null && O.guid && O.guid === D.guid) {
+                  p = !0;
+                  break;
+                }
+              }
+              x++;
+            }
+            if (p) {
+              const c = await T.getDependency("mesh", x), O = D;
+              if (r && console.log(`Loaded Mesh "${c.name}"`, L, x, c, g), c.isMesh === !0) {
+                const b = c.geometry;
+                return v.assignLODInformation(i.url, b, o, t, void 0, O.density), m(b);
+              } else {
+                const b = new Array();
+                for (let _ = 0; _ < c.children.length; _++) {
+                  const F = c.children[_];
+                  if (F instanceof Y) {
+                    const $ = F.geometry;
+                    v.assignLODInformation(i.url, $, o, t, _, O.density), b.push($);
+                  }
+                }
+                return m(b);
+              }
+            }
+          }
+          return m(null);
+        });
+        return this.previouslyLoaded.set(g, P), await P;
+      } else if (e instanceof z) {
+        r && console.log("Load texture from uri: " + L);
+        const w = await new ce().loadAsync(L);
+        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", L), w;
+      }
+    } else
+      S && console.warn(`Can not load LOD ${t}: no LOD info found for "${o}" ${e.name}`, e.type);
+    return null;
+  }
+  static assignLODInformation(e, t, r, i, o, s) {
+    if (!t)
+      return;
+    t.userData || (t.userData = {});
+    const n = new xe(e, r, i, o, s);
+    t.userData.LODS = n, t.userData.LOD = i;
+  }
+  static getAssignedLODInformation(e) {
+    var t;
+    return ((t = e == null ? void 0 : e.userData) == null ? void 0 : t.LODS) || null;
+  }
+  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);
+  }
+};
+let M = v;
+/**
+ * Register a texture with LOD information
+ */
+u(M, "registerTexture", (e, t, r, i) => {
+  S && console.log("> Progressive: register texture", r, t.name, t.uuid, t, i), t.source && (t.source[q] = i);
+  const o = t.uuid;
+  v.assignLODInformation(e, t, o, 0, 0, void 0), v.lodInfos.set(o, i), v.lowresCache.set(o, t);
+}), /**
+ * Register a mesh with LOD information
+ */
+u(M, "registerMesh", (e, t, r, i, o, s) => {
+  var d;
+  S && console.log("> Progressive: register mesh", o, r.name, s, r.uuid, r);
+  const n = r.geometry;
+  n.userData || (n.userData = {}), v.assignLODInformation(e, n, t, i, o, s.density), v.lodInfos.set(t, s);
+  let a = v.lowresCache.get(t);
+  a ? a.push(r.geometry) : a = [r.geometry], v.lowresCache.set(t, a);
+  for (const f of H)
+    (d = f.onRegisteredNewMesh) == null || d.call(f, r, s);
+}), /** A map of key = asset uuid and value = LOD information */
+u(M, "lodInfos", /* @__PURE__ */ new Map()), /** cache of already loaded mesh lods */
+u(M, "previouslyLoaded", /* @__PURE__ */ new Map()), /** this contains the geometry/textures that were originally loaded */
+u(M, "lowresCache", /* @__PURE__ */ new Map()), u(M, "_copiedTextures", /* @__PURE__ */ new Map());
+class xe {
+  constructor(e, t, r, i, o) {
+    u(this, "url");
+    /** the key to lookup the LOD information */
+    u(this, "key");
+    u(this, "level");
+    /** For multi objects (e.g. a group of meshes) this is the index of the object */
+    u(this, "index");
+    /** the mesh density */
+    u(this, "density");
+    this.url = e, this.key = t, this.level = r, i != null && (this.index = i), o != null && (this.density = o);
+  }
+}
+let te = Q("debugprogressive");
+const we = Q("noprogressive"), A = class {
+  constructor(e) {
+    u(this, "renderer");
+    u(this, "projectionScreenMatrix", new Z());
+    u(this, "cameraFrustrum", new fe());
+    u(this, "updateInterval", 0);
+    u(this, "pause", !1);
+    u(this, "plugins", []);
+    u(this, "_originalRender");
+    // private testIfLODLevelsAreAvailable() {
+    u(this, "_sphere", new de());
+    u(this, "_tempBox", new j());
+    u(this, "tempMatrix", new Z());
+    u(this, "_tempWorldPosition", new C());
+    u(this, "_tempBoxSize", new C());
+    u(this, "_tempBox2Size", new C());
+    this.renderer = e;
+  }
+  enable() {
+    if (this._originalRender)
+      return;
+    let e = 0;
+    this._originalRender = this.renderer.render;
+    const t = this;
+    let r = 0;
+    se(this.renderer), this.renderer.render = function(i, o) {
+      const s = r++, n = e++;
+      t.onBeforeRender(i, o, n, s), t._originalRender.call(this, i, o), t.onAfterRender(i, o, n, s), e--;
+    };
+  }
+  disable() {
+    this._originalRender && (this.renderer.render = this._originalRender, this._originalRender = void 0);
+  }
+  onBeforeRender(e, t, r, i) {
+  }
+  onAfterRender(e, t, r, i) {
+    if (we || this.pause || this.updateInterval > 0 && i % this.updateInterval != 0)
+      return;
+    this.projectionScreenMatrix.multiplyMatrices(t.projectionMatrix, t.matrixWorldInverse), this.cameraFrustrum.setFromProjectionMatrix(this.projectionScreenMatrix, this.renderer.coordinateSystem);
+    const o = 1e5, n = this.renderer.renderLists.get(e, r).opaque;
+    for (const a of n) {
+      const d = a.object;
+      (d instanceof Y || d.isMesh) && this.updateLODs(e, t, d, o);
+    }
+  }
+  static getObjectLODState(e) {
+    var t;
+    return (t = e.userData) == null ? void 0 : t.LOD_state;
+  }
+  /** Update the LOD levels for the renderer. */
+  updateLODs(e, t, r, i) {
+    var a, d;
+    for (const f of this.plugins)
+      (a = f.onBeforeUpdateLOD) == null || a.call(f, this.renderer, e, t, r);
+    let o = r.userData.LOD_state;
+    o || (o = new Oe(), r.userData.LOD_state = o);
+    let s = this.calculateLodLevel(t, r, o, i);
+    s = Math.round(s), s >= 0 && this.loadProgressiveMeshes(r, s);
+    let n = 0;
+    if (r.material) {
+      const f = r["DEBUG:LOD"];
+      if (f != null && (n = f), Array.isArray(r.material))
+        for (const L of r.material)
+          this.loadProgressiveTextures(L, n);
+      else
+        this.loadProgressiveTextures(r.material, n);
+    }
+    for (const f of this.plugins)
+      (d = f.onAfterUpdatedLOD) == null || d.call(f, this.renderer, e, t, r, s);
+    o.lastLodLevel = s;
+  }
+  /** Load progressive textures for the given material
+   * @param material the material to load the textures for
+   * @param level the LOD level to load. Level 0 is the best quality, higher levels are lower quality
+   * @returns Promise with true if the LOD was loaded, false if not
+   */
+  loadProgressiveTextures(e, t) {
+    return e && e.userData && e.userData.LOD !== t ? (e.userData.LOD = t, M.assignTextureLOD(e, t)) : Promise.resolve(null);
+  }
+  /** Load progressive meshes for the given mesh
+   * @param mesh the mesh to load the LOD for
+   * @param index the index of the mesh if it's part of a group
+   * @param level the LOD level to load. Level 0 is the best quality, higher levels are lower quality
+   * @returns Promise with true if the LOD was loaded, false if not
+   */
+  loadProgressiveMeshes(e, t) {
+    if (!e)
+      return Promise.resolve(null);
+    if (e.userData || (e.userData = {}), e.userData.LOD !== t) {
+      e.userData.LOD = t;
+      const r = e.geometry;
+      return M.assignMeshLOD(e, t).then((i) => (i && e.userData.LOD == t && r != e.geometry, i));
+    }
+    return Promise.resolve(null);
+  }
+  calculateLodLevel(e, t, r, i) {
+    var n;
+    if (!t)
+      return -1;
+    let s = 10 + 1;
+    if (e) {
+      if (te && t["DEBUG:LOD"] != null)
+        return t["DEBUG:LOD"];
+      const a = M.getMeshLODInformation(t.geometry), d = a == null ? void 0 : a.lods;
+      if (!d || d.length <= 0 || !((n = this.cameraFrustrum) != null && n.intersectsObject(t)))
+        return 99;
+      const f = t.geometry.boundingBox;
+      if (f && e.isPerspectiveCamera) {
+        const L = 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 y = e.getWorldPosition(this._tempWorldPosition);
+          if (this._sphere.containsPoint(y))
+            return 0;
+        }
+        if (this._tempBox.copy(f), this._tempBox.applyMatrix4(t.matrixWorld), this._tempBox.applyMatrix4(this.projectionScreenMatrix), this.renderer.xr.enabled && L.fov > 70) {
+          const y = this._tempBox.min, h = this._tempBox.max;
+          let T = y.x, x = y.y, p = h.x, c = h.y;
+          const O = 2, b = 1.5, _ = (y.x + h.x) * 0.5, F = (y.y + h.y) * 0.5;
+          T = (T - _) * O + _, x = (x - F) * O + F, p = (p - _) * O + _, c = (c - F) * O + F;
+          const $ = T < 0 && p > 0 ? 0 : Math.min(Math.abs(y.x), Math.abs(h.x)), oe = x < 0 && c > 0 ? 0 : Math.min(Math.abs(y.y), Math.abs(h.y)), N = Math.max($, oe);
+          r.lastCentrality = (b - N) * (b - N) * (b - N);
+        } else
+          r.lastCentrality = 1;
+        const g = this._tempBox.getSize(this._tempBoxSize);
+        g.multiplyScalar(0.5), screen.availHeight > 0 && g.multiplyScalar(this.renderer.domElement.clientHeight / screen.availHeight), g.x *= L.aspect;
+        const w = e.matrixWorldInverse, D = new j();
+        D.copy(f), D.applyMatrix4(t.matrixWorld), D.applyMatrix4(w);
+        const P = D.getSize(this._tempBox2Size), G = Math.max(P.x, P.y);
+        if (Math.max(g.x, g.y) != 0 && G != 0 && (g.z = P.z / Math.max(P.x, P.y) * Math.max(g.x, g.y)), r.lastScreenCoverage = Math.max(g.x, g.y, g.z), r.lastScreenspaceVolume.copy(g), r.lastScreenCoverage *= r.lastCentrality, te && A.debugDrawLine) {
+          const y = this.tempMatrix.copy(this.projectionScreenMatrix);
+          y.invert();
+          const h = A.corner0, T = A.corner1, x = A.corner2, p = A.corner3;
+          h.copy(this._tempBox.min), T.copy(this._tempBox.max), T.x = h.x, x.copy(this._tempBox.max), x.y = h.y, p.copy(this._tempBox.max);
+          const c = (h.z + p.z) * 0.5;
+          h.z = T.z = x.z = p.z = c, h.applyMatrix4(y), T.applyMatrix4(y), x.applyMatrix4(y), p.applyMatrix4(y), A.debugDrawLine(h, T, 255), A.debugDrawLine(h, x, 255), A.debugDrawLine(T, p, 255), A.debugDrawLine(x, p, 255);
+        }
+        let B = 999;
+        if (d && r.lastScreenCoverage > 0) {
+          for (let y = 0; y < d.length; y++)
+            if (d[y].density / r.lastScreenCoverage < i) {
+              B = y;
+              break;
+            }
+        }
+        B < s && (s = B);
+      }
+    }
+    return s;
+  }
+};
+let k = A;
+u(k, "corner0", new C()), u(k, "corner1", new C()), u(k, "corner2", new C()), u(k, "corner3", new C()), u(k, "debugDrawLine");
+class Oe {
+  constructor() {
+    u(this, "lastLodLevel", 0);
+    u(this, "lastScreenCoverage", 0);
+    u(this, "lastScreenspaceVolume", new C());
+    u(this, "lastCentrality", 0);
+  }
+}
+const re = Symbol("NEEDLE_mesh_lod"), K = Symbol("NEEDLE_texture_lod");
+function ve() {
+  const l = document.querySelector("model-viewer");
+  if (!l)
+    return;
+  let e = null;
+  for (let t = l; t != null; t = Object.getPrototypeOf(t)) {
+    const i = Object.getOwnPropertySymbols(t).find((o) => o.toString() == "Symbol(renderer)");
+    !e && i != null && (e = l[i].threeRenderer);
+  }
+  if (e) {
+    console.log("Adding Needle LODs to modelviewer");
+    const t = new k(e);
+    t.plugins.push(new Me(l)), t.enable();
+  }
+}
+class Me {
+  constructor(e) {
+    u(this, "modelviewer");
+    this.modelviewer = e;
+  }
+  onBeforeUpdateLOD(e, t, r, i) {
+    this.tryParseMeshLOD(t, i), this.tryParseTextureLOD(t, i);
+  }
+  getUrl() {
+    return this.modelviewer.getAttribute("src");
+  }
+  tryGetCurrentGLTF(e) {
+    return e._currentGLTF;
+  }
+  tryParseTextureLOD(e, t) {
+    if (t[K] == !0)
+      return;
+    t[K] = !0;
+    const r = this.tryGetCurrentGLTF(e), i = this.getUrl();
+    if (!i) {
+      console.error("No url found in modelviewer");
+      return;
+    }
+    if (r && t.material) {
+      let o = function(n) {
+        var d, f, L;
+        if (n[K] == !0)
+          return;
+        n[K] = !0, n.userData && (n.userData.LOD = -1);
+        const a = Object.keys(n);
+        for (let g = 0; g < a.length; g++) {
+          const w = a[g], D = n[w];
+          if ((D == null ? void 0 : D.isTexture) === !0) {
+            const P = (f = (d = D.userData) == null ? void 0 : d.associations) == null ? void 0 : f.textures, G = r.parser.json.textures[P];
+            if ((L = G.extensions) != null && L[R]) {
+              const m = G.extensions[R];
+              m && i && M.registerTexture(i, D, m.lods.length, m);
+            }
+          }
+        }
+      };
+      const s = t.material;
+      if (Array.isArray(s))
+        for (const n of s)
+          o(n);
+      else
+        o(s);
+    }
+  }
+  tryParseMeshLOD(e, t) {
+    var o, s;
+    if (t[re] == !0)
+      return;
+    t[re] = !0;
+    const r = this.getUrl();
+    if (!r) {
+      console.error("No url found in modelviewer");
+      return;
+    }
+    const i = (s = (o = t.userData) == null ? void 0 : o.gltfExtensions) == null ? void 0 : s[R];
+    if (i && r) {
+      const n = t.uuid;
+      M.registerMesh(r, n, t, 0, i.lods.length, i);
+    }
+  }
+}
+function Be(l, e, t) {
+  se(e), ie(t), t.register((i) => new M(i, l));
+  const r = new k(e);
+  return r.enable(), r;
+}
+document.addEventListener("DOMContentLoaded", () => {
+  ve();
+});
+export {
+  R as EXTENSION_NAME,
+  k as LODsManager,
+  M as NEEDLE_progressive,
+  ve as patchModelViewer,
+  ke as registerPlugin,
+  Be as useNeedleGLTFProgressive
+};