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

package/gltf-progressive.js

@@ -0,0 +1,679 @@
+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, Texture as U, TextureLoader as ue, Matrix4 as j, Frustum as ce, Sphere as fe, Box3 as ee, Vector3 as R } from "three";
+import { GLTFLoader as de } from "three/examples/jsm/loaders/GLTFLoader.js";
+import { MeshoptDecoder as ge } from "three/examples/jsm/libs/meshopt_decoder.module.js";
+import { DRACOLoader as he } from "three/examples/jsm/loaders/DRACOLoader.js";
+import { KTX2Loader as pe } from "three/examples/jsm/loaders/KTX2Loader.js";
+const ye = "https://www.gstatic.com/draco/versioned/decoders/1.4.1/", me = "https://www.gstatic.com/basis-universal/versioned/2021-04-15-ba1c3e4/";
+let F, H, W;
+function se(l) {
+  F || (F = new he(), F.setDecoderPath(ye), F.setDecoderConfig({ type: "js" })), W || (W = new pe(), W.setTranscoderPath(me)), H || (H = ge), l ? W.detectSupport(l) : console.warn("No renderer provided to detect ktx2 support - loading KTX2 textures will probably fail");
+}
+function ie(l) {
+  l.dracoLoader || l.setDRACOLoader(F), l.ktx2Loader || l.setKTX2Loader(W), l.meshoptDecoder || l.setMeshoptDecoder(H);
+}
+function Z(l) {
+  const t = new URL(window.location.href).searchParams.get(l);
+  return t == null || t === "0" || t === "false" ? !1 : t === "" ? !0 : t;
+}
+function Le(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 J = new Array();
+function _e(l) {
+  J.push(l);
+}
+const k = "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) => {
+      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));
+        } else if (n.isMaterial === !0) {
+          n["DEBUG:LOD"] = e, v.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) => {
+      n.name != "BackgroundCubeMaterial" && "wireframe" in n && (n.wireframe = r);
+    }));
+  });
+}
+function te(l, e, t) {
+  var i;
+  if (!S)
+    return;
+  z.has(l) || z.set(l, { keys: [], sourceId: t });
+  const r = z.get(l);
+  ((i = r == null ? void 0 : r.keys) == null ? void 0 : i.includes(e)) == !1 && r.keys.push(e);
+}
+const M = 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 k;
+  }
+  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 n;
+    if (e.isMaterial === !0) {
+      for (const s of Object.keys(e)) {
+        const o = e[s];
+        if (o.isTexture && this.hasLODLevelAvailable(o, 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 && (n = r == null ? void 0 : r.userData) != null && n.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 q || e.isMesh === !0) {
+      const i = e.geometry, n = this.getAssignedLODInformation(i);
+      if (!n)
+        return Promise.resolve(null);
+      for (const s of J)
+        (r = s.onBeforeGetLODMesh) == null || r.call(s, e, t);
+      return e["LOD:requested level"] = t, M.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));
+        }
+        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 = [], n = new Array();
+      if (S && Q.add(r), r.uniforms && r.isRawShaderMaterial || r.isShaderMaterial === !0) {
+        const s = r;
+        for (const o of Object.keys(s.uniforms)) {
+          const a = s.uniforms[o].value;
+          if ((a == null ? void 0 : a.isTexture) === !0) {
+            const h = this.assignTextureLODForSlot(a, t, r, o);
+            i.push(h), n.push(o);
+          }
+        }
+      } 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);
+          }
+        }
+      return Promise.all(i).then((s) => {
+        const o = new Array();
+        for (let a = 0; a < s.length; a++) {
+          const h = s[a], g = n[a];
+          h && h.isTexture === !0 ? o.push({ material: r, slot: g, texture: h, level: t }) : o.push({ material: r, slot: g, texture: null, level: t });
+        }
+        return o;
+      });
+    }
+    if (e instanceof U || 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))
+        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);
+        }
+        return n;
+      } else
+        S == "verbose" && console.warn("No LOD found for", e, t);
+      return null;
+    }).catch((n) => (console.error("Error loading LOD", e, n), null));
+  }
+  afterRoot(e) {
+    var t, r;
+    return S && 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[k];
+        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);
+          });
+        }
+      }
+    }), (r = this.parser.json.meshes) == null || r.forEach((i, n) => {
+      if (i != null && i.extensions) {
+        const s = i == null ? void 0 : i.extensions[k];
+        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);
+            }
+        }
+      }
+    }), null;
+  }
+  static async getOrLoadLOD(e, t) {
+    var o, a, h;
+    const r = S == "verbose", i = e.userData.LODS;
+    if (!i)
+      return null;
+    const n = i == null ? void 0 : i.key;
+    let s;
+    if (e.isTexture === !0) {
+      const g = e;
+      g.source && g.source[V] && (s = g.source[V]);
+    }
+    if (s || (s = M.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)
+          return this.lowresCache.get(n);
+      }
+      const g = Array.isArray(s.lods) ? s.lods[t].path : s.lods;
+      if (!g)
+        return S && !s["missing:uri"] && (s["missing:uri"] = !0, console.warn("Missing uri for progressive asset for LOD " + t, s)), null;
+      const c = Le(i.url, g);
+      if (c.endsWith(".glb") || c.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 L = s, A = new Promise(async (D, C) => {
+          const I = new de();
+          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 p = await I.loadAsync(m).catch((y) => (console.error(`Error loading LOD ${t} from ${c}
+`, y), null));
+          if (!p)
+            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 d of p.parser.json.textures) {
+              if (d != null && d.extensions) {
+                const O = d == null ? void 0 : d.extensions[k];
+                if (O != null && O.guid && O.guid === L.guid) {
+                  y = !0;
+                  break;
+                }
+              }
+              x++;
+            }
+            if (y) {
+              let d = await b.getDependency("texture", x);
+              return r && console.log('change "' + e.name + '" → "' + d.name + '"', c, x, d, f), e instanceof U && (d = this.copySettings(e, d)), d && (d.guid = L.guid), D(d);
+            }
+          }
+          if (x = 0, p.parser.json.meshes) {
+            let y = !1;
+            for (const d of p.parser.json.meshes) {
+              if (d != null && d.extensions) {
+                const O = d == null ? void 0 : d.extensions[k];
+                if (O != null && O.guid && O.guid === L.guid) {
+                  y = !0;
+                  break;
+                }
+              }
+              x++;
+            }
+            if (y) {
+              const d = await b.getDependency("mesh", x), O = L;
+              if (r && console.log(`Loaded Mesh "${d.name}"`, c, x, d, f), d.isMesh === !0) {
+                const P = d.geometry;
+                return M.assignLODInformation(i.url, P, n, t, void 0, O.density), D(P);
+              } else {
+                const P = new Array();
+                for (let _ = 0; _ < d.children.length; _++) {
+                  const E = d.children[_];
+                  if (E instanceof q) {
+                    const N = E.geometry;
+                    M.assignLODInformation(i.url, N, n, t, _, O.density), P.push(N);
+                  }
+                }
+                return D(P);
+              }
+            }
+          }
+          return D(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 ue().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;
+      }
+    } else
+      S && 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 De(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;
+  }
+  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 v = M;
+/**
+ * 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);
+  const n = i.guid;
+  M.assignLODInformation(e, t, n, 0, 0, void 0), M.lodInfos.set(n, i), M.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);
+  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 g of J)
+    (h = g.onRegisteredNewMesh) == null || h.call(g, 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 De {
+  constructor(e, t, r, i, n) {
+    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), n != null && (this.density = n);
+  }
+}
+const Y = Z("debugprogressive"), xe = Z("noprogressive"), T = class {
+  constructor(e) {
+    u(this, "renderer");
+    u(this, "projectionScreenMatrix", new j());
+    u(this, "cameraFrustrum", new ce());
+    /**
+     * 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);
+    /**
+     * If set to true, the LODsManager will not update the LODs.
+     */
+    u(this, "pause", !1);
+    u(this, "plugins", []);
+    u(this, "_frame", 0);
+    u(this, "_originalRender");
+    // private testIfLODLevelsAreAvailable() {
+    u(this, "_sphere", new fe());
+    u(this, "_tempBox", new ee());
+    u(this, "tempMatrix", new j());
+    u(this, "_tempWorldPosition", new R());
+    u(this, "_tempBoxSize", new R());
+    u(this, "_tempBox2Size", new R());
+    this.renderer = e;
+  }
+  /** @internal */
+  static getObjectLODState(e) {
+    var t;
+    return (t = e.userData) == null ? void 0 : t.LOD_state;
+  }
+  /**
+   * Enable the LODsManager. This will replace the render method of the renderer with a method that updates the LODs.
+   */
+  enable() {
+    if (this._originalRender)
+      return;
+    let e = 0;
+    this._originalRender = this.renderer.render;
+    const t = this;
+    se(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() {
+    this._originalRender && (this.renderer.render = this._originalRender, this._originalRender = void 0);
+  }
+  onBeforeRender(e, t, r, i) {
+  }
+  onAfterRender(e, t, r, i) {
+    var n, s;
+    if (!this.pause && r == 0) {
+      if (xe || 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, a = this.renderer.renderLists.get(e, r), h = a.opaque;
+      for (const c of h) {
+        if (c.material && (((n = c.geometry) == null ? void 0 : n.type) === "BoxGeometry" || ((s = c.geometry) == null ? void 0 : s.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, o);
+      }
+      const g = a.transparent;
+      for (const c of g) {
+        const f = c.object;
+        (f instanceof q || f.isMesh) && this.updateLODs(e, t, f, o);
+      }
+    }
+  }
+  /** Update the LOD levels for the renderer. */
+  updateLODs(e, t, r, i) {
+    var a, h;
+    for (const g of this.plugins)
+      (a = g.onBeforeUpdateLOD) == null || a.call(g, this.renderer, e, t, r);
+    let n = r.userData.LOD_state;
+    n || (n = new we(), 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 g = r["DEBUG:LOD"];
+      if (g != null && (o = g), Array.isArray(r.material))
+        for (const c of r.material)
+          this.loadProgressiveTextures(c, o);
+      else
+        this.loadProgressiveTextures(r.material, o);
+    }
+    for (const g of this.plugins)
+      (h = g.onAfterUpdatedLOD) == null || h.call(g, this.renderer, e, t, r, s);
+    n.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, v.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 v.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 g = t.geometry.boundingBox;
+      if (g && 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(g), 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, d = 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 + _, d = (d - E) * O + E;
+          const N = b < 0 && y > 0 ? 0 : Math.min(Math.abs(m.x), Math.abs(p.x)), ne = x < 0 && d > 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(g), 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 d = (p.z + y.z) * 0.5;
+          p.z = b.z = x.z = y.z = d, 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;
+            }
+        }
+        C < s && (s = C);
+      }
+    }
+    return s;
+  }
+};
+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 R()), u(B, "corner1", new R()), u(B, "corner2", new R()), u(B, "corner3", new R());
+class we {
+  constructor() {
+    u(this, "lastLodLevel", 0);
+    u(this, "lastScreenCoverage", 0);
+    u(this, "lastScreenspaceVolume", new R());
+    u(this, "lastCentrality", 0);
+  }
+}
+const re = Symbol("NEEDLE_mesh_lod"), $ = Symbol("NEEDLE_texture_lod");
+function Oe(l) {
+  if (!l)
+    return null;
+  let e = null, t = null;
+  for (let r = l; 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]);
+  }
+  if (e) {
+    console.log("Adding Needle LODs to modelviewer");
+    const r = new B(e);
+    if (r.plugins.push(new Me(l)), r.enable(), t) {
+      const i = t.camera || t.traverse((n) => n.type == "PerspectiveCamera")[0];
+      i && e.render(t, i);
+    }
+    return () => {
+      r.disable();
+    };
+  }
+  return null;
+}
+class Me {
+  constructor(e) {
+    u(this, "modelviewer");
+    u(this, "_didWarnAboutMissingUrl", !1);
+    this.modelviewer = e;
+  }
+  onBeforeUpdateLOD(e, t, r, i) {
+    this.tryParseMeshLOD(t, i), this.tryParseTextureLOD(t, i);
+  }
+  getUrl() {
+    let e = this.modelviewer.getAttribute("src");
+    return e || (e = this.modelviewer.src), e || (this._didWarnAboutMissingUrl || console.warn("No url found in modelviewer", this.modelviewer), this._didWarnAboutMissingUrl = !0), e;
+  }
+  tryGetCurrentGLTF(e) {
+    return e._currentGLTF;
+  }
+  tryParseTextureLOD(e, t) {
+    if (t[$] == !0)
+      return;
+    t[$] = !0;
+    const r = this.tryGetCurrentGLTF(e), i = this.getUrl();
+    if (i && r && t.material) {
+      let n = function(o) {
+        var h, g, c;
+        if (o[$] == !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 = (g = (h = L.userData) == null ? void 0 : h.associations) == null ? void 0 : g.textures, G = r.parser.json.textures[A];
+            if ((c = G.extensions) != null && c[k]) {
+              const D = G.extensions[k];
+              D && i && v.registerTexture(i, L, D.lods.length, D);
+            }
+          }
+        }
+      };
+      const s = t.material;
+      if (Array.isArray(s))
+        for (const o of s)
+          n(o);
+      else
+        n(s);
+    }
+  }
+  tryParseMeshLOD(e, t) {
+    var n, s;
+    if (t[re] == !0)
+      return;
+    t[re] = !0;
+    const r = this.getUrl();
+    if (!r)
+      return;
+    const i = (s = (n = t.userData) == null ? void 0 : n.gltfExtensions) == null ? void 0 : s[k];
+    if (i && r) {
+      const o = t.uuid;
+      v.registerMesh(r, o, t, 0, i.lods.length, i);
+    }
+  }
+}
+function Be(l, e, t, r) {
+  se(e), ie(t), t.register((n) => new v(n, l));
+  const i = new B(e);
+  return (r == null ? void 0 : r.enableLODsManager) !== !1 && i.enable(), i;
+}
+document.addEventListener("DOMContentLoaded", () => {
+  Oe(document.querySelector("model-viewer"));
+});
+export {
+  k as EXTENSION_NAME,
+  B as LODsManager,
+  v as NEEDLE_progressive,
+  Oe as patchModelViewer,
+  _e as registerPlugin,
+  Be as useNeedleProgressive
+};