@voluma/vlam 0.1.0 → 0.2.1

package/dist/formats/lcc.js

@@ -0,0 +1,969 @@
+var dt = Object.defineProperty;
+var wt = (e, t, n) => t in e ? dt(e, t, { enumerable: !0, configurable: !0, writable: !0, value: n }) : e[t] = n;
+var A = (e, t, n) => wt(e, typeof t != "symbol" ? t + "" : t, n);
+import { w as gt } from "../splat-data-BZM5dhhx.js";
+import { a as mt, r as pt } from "../sh-pack-D5wAe5gg.js";
+import * as E from "three/webgpu";
+import { M as Ct, L as yt } from "../splat-mesh-types-8QDjTbZO.js";
+import { t as ct, a as Q } from "../loading-wLo8vRbA.js";
+import { w as D } from "../logging-BfPdd7NJ.js";
+import { p as vt, a as xt, b as bt, c as k, d as W } from "../ply-header-BwgExCn-.js";
+const U = 32, O = 64, j = 1 << 24;
+function Lt(e) {
+  return e === 1 ? 3 : e === 2 ? 8 : 15;
+}
+function Et(e) {
+  const t = e, n = String(t.version ?? "");
+  if (!/^[2345]\./.test(n))
+    throw new Error(
+      `Unsupported LCC manifest version: "${n}" (expected 2.x, 3.x, 4.x or 5.x).`
+    );
+  const o = t.encoding;
+  if (o !== void 0 && o !== "COMPRESS")
+    throw new Error(`Unsupported LCC encoding: "${String(o)}" (expected COMPRESS).`);
+  const s = t.totalLevel;
+  if (!Number.isSafeInteger(s) || s < 1)
+    throw new Error(`LCC manifest declares an invalid totalLevel: ${String(s)}.`);
+  const i = s, r = t.indexDataSize, c = 4 + i * 16;
+  if (r !== c)
+    throw new Error(
+      `LCC manifest indexDataSize is ${String(r)}, but ${i} levels imply ${c}.`
+    );
+  const u = t.splats;
+  if (!Array.isArray(u) || u.length !== i)
+    throw new Error(`LCC manifest "splats" must list one count per level (${i}).`);
+  for (const w of u)
+    if (!Number.isSafeInteger(w) || w < 0)
+      throw new Error(`LCC manifest "splats" contains an invalid count: ${String(w)}.`);
+  const l = t.totalSplats;
+  if (!Number.isSafeInteger(l) || l < 0)
+    throw new Error(`LCC manifest declares an invalid totalSplats: ${String(l)}.`);
+  const a = Z(t, "cellLengthX"), f = Z(t, "cellLengthY");
+  if (a <= 0 || f <= 0)
+    throw new Error("LCC manifest cell lengths must be positive.");
+  const h = St(t), d = t.shift;
+  if (Array.isArray(d) && d.some((w) => w !== 0))
+    throw new Error(
+      `LCC manifest "shift" is non-zero (${JSON.stringify(d)}), which is not supported.`
+    );
+  const m = t.scale;
+  if (Array.isArray(m) && m.some((w) => w !== 1))
+    throw new Error(
+      `LCC manifest "scale" is non-identity (${JSON.stringify(m)}), which is not supported.`
+    );
+  const p = t.boundingBox, $ = N(p == null ? void 0 : p.min, "boundingBox.min"), b = N(p == null ? void 0 : p.max, "boundingBox.max"), g = t.attributes;
+  if (!Array.isArray(g)) throw new Error('LCC manifest is missing "attributes".');
+  const C = /* @__PURE__ */ new Map();
+  for (const w of g)
+    typeof (w == null ? void 0 : w.name) == "string" && (!Array.isArray(w.min) || w.min.length < 3 || C.set(w.name, {
+      min: N(w.min, `attributes.${w.name}.min`),
+      max: N(w.max, `attributes.${w.name}.max`)
+    }));
+  const x = (w) => {
+    const v = C.get(w);
+    if (!v) throw new Error(`LCC manifest is missing the "${w}" attribute range.`);
+    return v;
+  }, y = C.get("shcoef") ?? Y, L = $t(t.fileType, y);
+  return {
+    totalSplats: l,
+    totalLevel: i,
+    cellLengthX: a,
+    cellLengthY: f,
+    indexDataSize: c,
+    splats: u,
+    bounds: { min: $, max: b },
+    fileType: L,
+    scale: x("scale"),
+    // A Portable capture has no SH at all; keep a benign range so the type
+    // stays total rather than sprinkling optionality through the loader.
+    shcoef: y,
+    envScale: C.get("envscale") ?? Y,
+    envShcoef: C.get("envshcoef") ?? Y,
+    georeference: h
+  };
+}
+function St(e) {
+  const t = e.offset;
+  if (!Array.isArray(t) || !t.some((o) => o !== 0)) return;
+  const n = e.epsg;
+  return {
+    origin: N(t, "offset"),
+    epsg: Number.isSafeInteger(n) && n > 0 ? n : void 0
+  };
+}
+function $t(e, t) {
+  if (e === "Portable" || e === "Quality") return e;
+  if (e === void 0) return At(t) ? "Portable" : "Quality";
+  throw new Error(
+    `Unsupported LCC fileType: "${String(e)}" (expected Portable or Quality).`
+  );
+}
+function At(e) {
+  return e.min.every((t) => t === 0) && e.max.every((t) => t === 0 || t === 1);
+}
+const Y = { min: [0, 0, 0], max: [0, 0, 0] };
+function Mt(e, t) {
+  const { indexDataSize: n, totalLevel: o } = t;
+  if (e.byteLength === 0 || e.byteLength % n !== 0)
+    throw new Error(
+      `LCC index.bin is ${e.byteLength} bytes, not a multiple of indexDataSize ${n}.`
+    );
+  const s = new DataView(e), i = [];
+  for (let r = 0; r < e.byteLength; r += n) {
+    const c = [];
+    for (let u = 0; u < o; u++) {
+      const l = r + 4 + u * 16, a = s.getUint32(l, !0), f = s.getBigUint64(l + 4, !0);
+      if (f > BigInt(Number.MAX_SAFE_INTEGER))
+        throw new Error(
+          `LCC index.bin has a byte offset beyond Number.MAX_SAFE_INTEGER: ${f}.`
+        );
+      const h = s.getUint32(l + 12, !0);
+      if (h !== a * U)
+        throw new Error(
+          `LCC index.bin level ${u} declares ${a} splats but ${h} bytes (expected ${a * U}).`
+        );
+      c.push({ count: a, byteOffset: Number(f), byteSize: h });
+    }
+    i.push({
+      cellX: s.getUint16(r, !0),
+      cellY: s.getUint16(r + 2, !0),
+      levels: c
+    });
+  }
+  return i;
+}
+function Ut(e) {
+  const t = e >>> 30 & 3, n = [0, 0, 0, 0];
+  let o = 0;
+  for (let i = 0; i < 4; i++) {
+    if (i === t) continue;
+    const r = e >>> 10 * o & 1023;
+    n[i] = (r - 511) * Tt, o++;
+  }
+  const s = n[0] ** 2 + n[1] ** 2 + n[2] ** 2 + n[3] ** 2;
+  return n[t] = Math.sqrt(Math.max(0, 1 - s)), [n[3], n[0], n[1], n[2]];
+}
+const Tt = 1 / (511 * Math.SQRT2);
+async function re(e, t, n, o) {
+  var x;
+  const s = t.stride;
+  if (s !== U && s !== U + O)
+    throw new Error(`LCC chunk declares an unsupported ${s}-byte record.`);
+  if (((x = t.sh) == null ? void 0 : x.source) === "inline" && s === U)
+    throw new Error("LCC chunk asks for inline SH but its records have no room for it.");
+  if (e.byteLength % s !== 0)
+    throw new Error(
+      `LCC chunk is ${e.byteLength} bytes, not a multiple of the ${s}-byte record.`
+    );
+  const i = e.byteLength / s;
+  if (i > j)
+    throw new Error(
+      `LCC chunk holds ${i} splats, above the supported maximum of ${j}.`
+    );
+  const r = new DataView(e), c = new Float32Array(i * 3), u = new Uint8Array(i * 4), l = new Float32Array(i * 6), a = new Uint8Array(e), { min: f, max: h } = t.scale, d = f[0], m = f[1], p = f[2], $ = h[0] - f[0], b = h[1] - f[1], g = h[2] - f[2];
+  for (let y = 0; y < i; y++) {
+    o && (y & 65535) === 0 && y > 0 && (await new Promise((S) => setTimeout(S, 0)), o.throwIfAborted());
+    const L = y * s;
+    c[y * 3 + 0] = r.getFloat32(L, !0), c[y * 3 + 1] = r.getFloat32(L + 4, !0), c[y * 3 + 2] = r.getFloat32(L + 8, !0), u[y * 4 + 0] = a[L + 12], u[y * 4 + 1] = a[L + 13], u[y * 4 + 2] = a[L + 14], u[y * 4 + 3] = a[L + 15];
+    const [w, v, F, M] = Ut(r.getUint32(L + 22, !0));
+    gt(
+      l,
+      y,
+      d + $ * (r.getUint16(L + 16, !0) / 65535),
+      m + b * (r.getUint16(L + 18, !0) / 65535),
+      p + g * (r.getUint16(L + 20, !0) / 65535),
+      w,
+      v,
+      F,
+      M
+    );
+  }
+  o == null || o.throwIfAborted();
+  const C = t.sh ? Ft(e, n, t.sh, i, s) : void 0;
+  return {
+    count: i,
+    positions: c,
+    colors: u,
+    covariances: l,
+    ...C ? { shPacked: C } : {}
+  };
+}
+function Ft(e, t, n, o, s) {
+  const i = Lt(n.bands), r = new Uint32Array(o * i);
+  if (n.source === "inline") {
+    const l = new DataView(e);
+    for (let a = 0; a < o; a++) {
+      const f = a * s + U;
+      for (let h = 0; h < i; h++)
+        r[a * i + h] = l.getUint32(f + h * 4, !0);
+    }
+    return K(r, n);
+  }
+  if (!t) throw new Error("LCC chunk expected shcoef.bin bytes but none were fetched.");
+  const c = o * O;
+  if (t.byteLength !== c)
+    throw new Error(
+      `LCC shcoef.bin range is ${t.byteLength} bytes; expected ${c} for ${o} splats.`
+    );
+  const u = new DataView(t);
+  for (let l = 0; l < o; l++) {
+    const a = l * O;
+    for (let f = 0; f < i; f++)
+      r[l * i + f] = u.getUint32(a + f * 4, !0);
+  }
+  return K(r, n);
+}
+function K(e, t) {
+  const n = t.requantizeTo;
+  if (!n || mt(t.range, n))
+    return { bands: t.bands, packed: e, range: t.range };
+  for (let o = 0; o < e.length; o++)
+    e[o] = pt(e[o], t.range, n);
+  return { bands: t.bands, packed: e, range: n };
+}
+function Z(e, t) {
+  const n = e[t];
+  if (typeof n != "number" || !Number.isFinite(n))
+    throw new Error(`LCC manifest field "${t}" is not a finite number.`);
+  return n;
+}
+function N(e, t) {
+  if (!Array.isArray(e) || e.length < 3)
+    throw new Error(`LCC manifest "${t}" must have three numbers.`);
+  return e.slice(0, 3).map((o) => {
+    if (typeof o != "number" || !Number.isFinite(o))
+      throw new Error(`LCC manifest "${t}" has a non-finite entry.`);
+    return o;
+  });
+}
+function q() {
+  return new E.Matrix4().set(-1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1);
+}
+function le(e) {
+  e.matrix.copy(q()), e.matrix.decompose(e.position, e.quaternion, e.scale), e.matrixWorldNeedsUpdate = !0;
+}
+const Bt = 128e3;
+async function ce(e, t, n) {
+  const o = Et(e), s = (w) => {
+    const v = t.resolve(w);
+    if (v === null) throw new Error(`LCC dataset is missing "${w}".`);
+    return v;
+  }, i = s("data.bin"), r = t.resolve("environment.bin"), c = Mt(
+    await It(s("index.bin"), n, "manifest"),
+    o
+  );
+  Nt(c, o);
+  const u = o.fileType === "Quality" ? Ct : 0, l = n.shBands ?? u, a = Math.min(l, u), f = a === 0 ? void 0 : a, h = f === void 0 ? null : s("shcoef.bin"), d = [], m = [], p = (w, v) => (d.push(w), m.push(v), d.length - 1), $ = [], b = /* @__PURE__ */ new Set();
+  let g = 0;
+  const C = o.totalLevel;
+  for (let w = 0; w < c.length; w++) {
+    const v = c[w];
+    let F = 0;
+    for (let S = 0; S < C; S++) {
+      const T = v.levels[S].count;
+      if (T > 0) {
+        F = T;
+        break;
+      }
+    }
+    const M = Math.max(1, Math.ceil(F / Bt));
+    for (let S = 0; S < M; S++) {
+      const T = new Array(C).fill(
+        void 0
+      );
+      let B = -1, H = 0;
+      for (let P = 0; P < C; P++) {
+        const _ = v.levels[P];
+        if (_.count === 0) continue;
+        const R = Math.floor(S * _.count / M), I = Math.floor((S + 1) * _.count / M);
+        if (I === R) continue;
+        const ft = `${i}#c${v.cellX}_${v.cellY}-l${P}${M > 1 ? `.${S}` : ""}`, G = p(ft, {
+          format: "lcc-bin",
+          lcc: {
+            kind: "splats",
+            start: _.byteOffset + R * U,
+            length: (I - R) * U,
+            stride: U,
+            scale: o.scale,
+            ...f === void 0 ? {} : {
+              sh: {
+                bands: f,
+                range: o.shcoef,
+                source: "sidecar",
+                // shcoef.bin is aligned 2:1 with data.bin - 64 bytes per
+                // splat against 32 - so each slice's SH is its own doubled
+                // byte range, which the loader derives from `start`/`length`.
+                url: h
+              }
+            }
+          }
+        });
+        T[P] = { file: G, offset: 0, count: I - R }, B = G, H = I - R;
+      }
+      B >= 0 && (b.add(B), g += H), $.push({ bounds: Rt(v, o), lods: T, budgetGroup: w });
+    }
+  }
+  const x = await _t(t, o);
+  if (x > 0 && r !== null) {
+    const w = at(o), v = p(`${r}#env`, {
+      format: "lcc-bin",
+      lcc: {
+        kind: "environment",
+        start: 0,
+        length: x * w,
+        // From `fileType`, never from whether SH is enabled: a Quality
+        // environment record is 96 bytes even when its SH is being skipped.
+        stride: w,
+        scale: o.envScale,
+        ...f === void 0 ? {} : {
+          sh: {
+            bands: f,
+            range: o.envShcoef,
+            source: "inline",
+            // The environment quantizes SH against its own (wider) range;
+            // re-encode into the base range so the whole scene decodes
+            // through one pool uniform. See LccShParams.requantizeTo.
+            requantizeTo: o.shcoef
+          }
+        }
+      }
+    });
+    b.add(v), g += x, $.push({
+      bounds: V(o),
+      lods: [{ file: v, offset: 0, count: x }]
+    });
+  }
+  const y = {
+    leaves: $,
+    chunkUrls: d,
+    // Per-level splat totals; index 0 is the finest. Informational here (the
+    // pool and coverage floor are sized explicitly below), but kept accurate.
+    counts: o.splats.slice(0, C),
+    lodLevels: C,
+    bounds: V(o)
+  }, L = await Pt(t);
+  return {
+    // Classic LCC cells are broad XY tiles. Keep their priority independent of
+    // frustum crossings so an orbit does not demote a sharp tile as it leaves
+    // one edge, then rebuild it when the same tile re-enters the other edge.
+    source: new yt(y, {
+      ...n,
+      // Classic LCC cells are broad XY tiles. Keep their priority independent of
+      // frustum crossings so an orbit does not demote a sharp tile as it leaves
+      // one edge, then rebuild it when the same tile re-enters the other edge.
+      frustumAware: !1,
+      // Short range: distance bands pick the level (≤~9 m → L0, ≤20 m → L1,
+      // …). Do not blanket-force finest then re-promote after demotion - that
+      // loaded L0 for margin cells only to demote them with the camera still.
+      forceFinestWithin: void 0,
+      // Distance band is the fetch target. Do not fill past it.
+      fillPastDistance: !1,
+      // XGRIDS retains a little budget headroom and does not turn a raised
+      // ceiling into an all-finest distant cut. The cap limits only optional
+      // nearest-first restoration after demotion; the distance-selected cut
+      // can still spend the caller's full explicit budget when it needs it.
+      budgetFillFraction: 0.95,
+      budgetFillCap: 8e6,
+      forceFinestWhenFits: !1
+    }),
+    chunkUrls: d,
+    chunkOptions: m,
+    shBands: f ?? 0,
+    chunkKind: "file",
+    bounds: V(o),
+    pinnedFiles: b,
+    // Worst case is every cell resident at its finest level, plus the sky.
+    maxResidentSplats: (o.splats[0] ?? n.budget) + x,
+    // Full coarse coverage is each cell's coarsest level plus the sky - the
+    // budget floor below which even the substitute levels cannot all fit.
+    minimumCoverageSplats: Math.max(1, g),
+    // Same Z-up frame as .lcc2; bounds stay source-local and matrixWorld
+    // handles the conversion.
+    formatTransform: q(),
+    // Optional classic-LCC collision mesh file. One descriptor for the whole
+    // `.lci`; `loadCollisionMeshes` expands it into per-cell triangle tiles.
+    ...L !== null ? { collision: { meshes: [{ url: L }] } } : {}
+  };
+}
+async function Pt(e) {
+  for (const t of ["collision.lci", "Collision.lci"]) {
+    const n = await e.size(t);
+    if (n !== null && Number.isSafeInteger(n) && n > 0)
+      return e.resolve(t);
+  }
+  return null;
+}
+function at(e) {
+  return e.fileType === "Quality" ? U + O : U;
+}
+function Rt(e, t) {
+  const { min: n, max: o } = t.bounds, s = n[0] + e.cellX * t.cellLengthX, i = n[1] + e.cellY * t.cellLengthY;
+  return new E.Box3(
+    new E.Vector3(Math.min(s, o[0]), Math.min(i, o[1]), n[2]),
+    new E.Vector3(
+      Math.min(s + t.cellLengthX, o[0]),
+      Math.min(i + t.cellLengthY, o[1]),
+      o[2]
+    )
+  );
+}
+function V(e) {
+  const { min: t, max: n } = e.bounds;
+  return new E.Box3(
+    new E.Vector3(t[0], t[1], t[2]),
+    new E.Vector3(n[0], n[1], n[2])
+  );
+}
+function Nt(e, t) {
+  for (let n = 0; n < t.totalLevel; n++) {
+    let o = 0;
+    for (const c of e) o += c.levels[n].count;
+    const s = t.splats[n], i = s - o, r = Math.max(4, Math.ceil(s * 1e-3));
+    if (i < 0 || i > r)
+      throw new Error(
+        `LCC index.bin level ${n} totals ${o} splats, but the manifest declares ${String(t.splats[n])}.`
+      );
+  }
+}
+async function _t(e, t) {
+  const n = await e.size("environment.bin");
+  if (n === null || !Number.isSafeInteger(n) || n <= 0) return 0;
+  const o = at(t);
+  if (n % o !== 0)
+    throw new Error(
+      `LCC environment.bin is ${n} bytes, not a multiple of the ${o}-byte ${t.fileType} record.`
+    );
+  return n / o;
+}
+async function It(e, t, n) {
+  let o;
+  try {
+    o = await fetch(e, ct(t.request, t.signal));
+  } catch (s) {
+    throw Q(s, { phase: n, url: e });
+  }
+  if (!o.ok)
+    throw Q(new Error(`Failed to load ${e}: HTTP ${o.status}`), {
+      phase: n,
+      url: e,
+      status: o.status
+    });
+  return o.arrayBuffer();
+}
+const zt = 3, Dt = 0.1, J = 0.1, Ot = 500;
+function ae(e, t, n, o = 0) {
+  var $, b;
+  const s = e, i = s.root.splatFiles.map((g) => {
+    const C = t.resolve(g);
+    if (C === null) throw new Error(`LCC2 dataset is missing the tile "${g}".`);
+    return C;
+  }), r = [], c = [];
+  let u = 0;
+  const l = (g, C) => {
+    var M;
+    const x = (M = g.data) == null ? void 0 : M["3dgs"];
+    if (!x) throw new Error("LCC2 node is missing 3dgs data.");
+    const y = r.length;
+    r.push(null);
+    const L = u, w = [], v = g.child ? Object.values(g.child) : [];
+    if (v.length === 0)
+      c[u] = y, u++;
+    else
+      for (const S of v) w.push(l(S, C + 1));
+    const F = v.length === 0 ? L + 1 : u;
+    return r[y] = {
+      file: x.name,
+      offset: x.start,
+      count: x.count,
+      bounds: X(g.boundingBox),
+      level: s.totalLevels - C,
+      children: w,
+      leafStart: L,
+      leafEnd: F
+    }, y;
+  }, a = Object.values(s.root.child ?? {}).map((g) => l(g, 1)), f = new Yt(r, a, c, s.totalLevels - 1, n), h = new Set(a.map((g) => r[g].file)), d = (b = ($ = s.root.data) == null ? void 0 : $.env) == null ? void 0 : b.name, m = d !== void 0 && i[d] !== void 0 ? { file: d } : void 0;
+  d !== void 0 && m === void 0 && D(`LCC2 root references env tile #${d}, which the manifest does not list.`), m && h.add(m.file);
+  const p = o >= 1 ? o : void 0;
+  return {
+    source: f,
+    chunkUrls: i,
+    chunkKind: "file",
+    // LCC2 tiles are single bundled .sog (ZIP) files
+    // Explicit format: a dropped folder resolves tiles to `blob:` URLs with no
+    // `.sog` extension, so the chunk loader cannot sniff the parser from the URL.
+    chunkOptions: i.map(() => ({
+      format: "sog",
+      ...p ? { sog: { packShBands: p } } : {}
+    })),
+    bounds: X(s.root.boundingBox),
+    pinnedFiles: h,
+    maxResidentSplats: s.lodSplats[0] ?? n.budget,
+    minimumCoverageSplats: Math.max(
+      1,
+      a.reduce((g, C) => g + r[C].count, 0)
+    ),
+    ...kt(s, t),
+    ...m ? { environment: m } : {},
+    ...p ? { shBands: p } : {},
+    // Match the established XGRIDS LCC and Spark viewer coordinate frame.
+    // Bounds remain source-local and matrixWorld handles the conversion.
+    formatTransform: q()
+  };
+}
+function kt(e, t) {
+  const n = e.root.meshFiles;
+  if (!n || n.length === 0) return {};
+  const o = /* @__PURE__ */ new Map(), s = (c) => {
+    var l;
+    const u = (l = c.data) == null ? void 0 : l.mesh;
+    u && !o.has(u.name) && o.set(u.name, X(c.boundingBox));
+    for (const a of Object.values(c.child ?? {})) s(a);
+  };
+  s(e.root);
+  const i = o.size > 0 ? [...o].map(([c, u]) => ({ file: c, bounds: u })) : n.map((c, u) => ({ file: u })), r = [];
+  for (const { file: c, bounds: u } of i) {
+    const l = n[c];
+    if (l === void 0) {
+      D(`LCC2 node references mesh file ${c}, which the manifest does not list.`);
+      continue;
+    }
+    const a = t.resolve(l);
+    if (a === null) {
+      D(`LCC2 dataset is missing the collision mesh "${l}"; skipping it.`);
+      continue;
+    }
+    r.push({ url: a, ...u ? { bounds: u } : {} });
+  }
+  return r.length > 0 ? { collision: { meshes: r } } : {};
+}
+class Yt {
+  constructor(t, n, o, s, i) {
+    A(this, "budget");
+    A(this, "lodBaseDistance");
+    A(this, "lodMultiplier");
+    A(this, "nodes");
+    A(this, "rootChildren");
+    A(this, "cellNodes");
+    A(this, "coarsest");
+    /** Finest available level per cell (its own node's level). */
+    A(this, "cellFinestLevel");
+    /** Stable, dwelled desired level per cell. */
+    A(this, "cellLevel");
+    /** Timestamp of each cell's last level change, for dwell. */
+    A(this, "changedAt");
+    /** Index into {@link rootChildren} of the subtree containing each cell. */
+    A(this, "cellRootChild");
+    A(this, "scratchBox", new E.Box3());
+    A(this, "scratchSize", new E.Vector3());
+    this.nodes = t, this.rootChildren = n, this.cellNodes = o, this.coarsest = s, this.budget = i.budget, this.lodBaseDistance = i.lodBaseDistance, this.lodMultiplier = i.lodMultiplier;
+    const r = o.length;
+    this.cellFinestLevel = new Int32Array(r), this.cellLevel = new Int32Array(r).fill(s), this.changedAt = new Float64Array(r);
+    for (let c = 0; c < r; c++)
+      this.cellFinestLevel[c] = t[o[c]].level;
+    this.cellRootChild = new Uint32Array(r), n.forEach((c, u) => {
+      const l = t[c];
+      for (let a = l.leafStart; a < l.leafEnd; a++) this.cellRootChild[a] = u;
+    });
+  }
+  computeDesiredRuns(t, n, o) {
+    const s = this.updateCellLevels(t, n, o), i = Int32Array.from(this.cellLevel), r = this.rootChildren.map((h) => this.subtreeCutTotal(h, i));
+    let c = r.reduce((h, d) => h + d, 0);
+    const u = (h, d) => {
+      i[h] = i[h] + d;
+      const m = this.cellRootChild[h], p = this.subtreeCutTotal(this.rootChildren[m], i);
+      c += p - r[m], r[m] = p;
+    }, l = [...this.cellNodes.keys()].sort(
+      (h, d) => s[d] - s[h]
+    );
+    for (let h = 0; h < l.length && c > this.budget; ) {
+      const d = l[h];
+      i[d] < this.coarsest ? u(d, 1) : h++;
+    }
+    const a = this.budget * 0.85;
+    for (let h = l.length - 1; h >= 0 && c < a; ) {
+      const d = l[h];
+      if (i[d] > this.cellFinestLevel[d]) {
+        if (u(d, -1), c > this.budget) {
+          u(d, 1);
+          break;
+        }
+      } else
+        h--;
+    }
+    const f = [];
+    return this.collectCut(i, (h) => f.push(tt(this.nodes[h]))), f;
+  }
+  coarsestRunsFor(t, n) {
+    const o = [];
+    for (const s of this.rootChildren) {
+      const i = this.nodes[s];
+      i.leafStart < n && i.leafEnd > t && o.push(tt(i));
+    }
+    return o;
+  }
+  /** Distance (frustum-penalized) to each finest cell's node bounds. */
+  cellDistanceOf(t, n, o) {
+    const s = this.nodes[this.cellNodes[o]], i = s.bounds.distanceToPoint(t);
+    return this.scratchBox.copy(s.bounds), s.bounds.getSize(this.scratchSize), this.scratchBox.expandByScalar(this.scratchSize.length() * Dt), n.intersectsBox(this.scratchBox) ? i : i * zt;
+  }
+  /** Advances each cell's dwelled level toward the distance target. */
+  updateCellLevels(t, n, o) {
+    const { lodBaseDistance: s, lodMultiplier: i } = this, r = new Float64Array(this.cellNodes.length);
+    for (let c = 0; c < this.cellNodes.length; c++) {
+      const u = this.cellDistanceOf(t, n, c);
+      r[c] = u;
+      const l = this.cellFinestLevel[c];
+      let a = Math.min(this.coarsest, Math.max(l, this.cellLevel[c]));
+      for (; a < this.coarsest && u > s * i ** a * (1 + J); ) a++;
+      for (; a > l && u <= s * i ** (a - 1) * (1 - J); ) a--;
+      a !== this.cellLevel[c] && o - this.changedAt[c] >= Ot && (this.cellLevel[c] = a, this.changedAt[c] = o);
+    }
+    return r;
+  }
+  /** Splat total of one subtree's cut for the given per-cell levels. */
+  subtreeCutTotal(t, n) {
+    let o = 0;
+    return this.visitCut(t, n, (s) => {
+      o += this.nodes[s].count;
+    }), o;
+  }
+  /**
+   * Walks the tree emitting the cut for the given per-cell levels: a node is
+   * selected (stop) unless some cell in its subtree wants finer than the
+   * node provides, in which case its children are visited. Guarantees an
+   * antichain - exactly one node per root→leaf path.
+   */
+  collectCut(t, n) {
+    for (const o of this.rootChildren) this.visitCut(o, t, n);
+  }
+  /** {@link collectCut} restricted to one subtree. */
+  visitCut(t, n, o) {
+    const s = this.nodes[t];
+    if (s.children.length > 0) {
+      let i = this.coarsest;
+      for (let r = s.leafStart; r < s.leafEnd; r++) {
+        const c = n[r];
+        c < i && (i = c);
+      }
+      if (i < s.level) {
+        for (const r of s.children) this.visitCut(r, n, o);
+        return;
+      }
+    }
+    o(t);
+  }
+}
+function tt(e) {
+  return {
+    file: e.file,
+    level: e.level,
+    offset: e.offset,
+    count: e.count,
+    leafStart: e.leafStart,
+    leafEnd: e.leafEnd
+  };
+}
+function X(e) {
+  return new E.Box3(
+    new E.Vector3(e.min[0], e.min[1], e.min[2]),
+    new E.Vector3(e.max[0], e.max[1], e.max[2])
+  );
+}
+const et = ["vertex_indices", "vertex_index"];
+function Vt(e) {
+  const t = vt(e), n = t.element("vertex");
+  if (!n) throw new Error('Not a mesh PLY: no "vertex" element.');
+  xt(n, ["x", "y", "z"], ["float", "float32"], "Mesh PLY vertex"), bt(n, e.byteLength);
+  const o = Xt(e, n), s = t.element("face");
+  if (!s) throw new Error('Not a mesh PLY: no "face" element.');
+  const i = qt(e, s, n.count);
+  return {
+    vertexCount: n.count,
+    triangleCount: i.length / 3,
+    positions: o,
+    indices: i
+  };
+}
+function Xt(e, t) {
+  const n = new DataView(e, t.offset), o = k(t, "x"), s = k(t, "y"), i = k(t, "z"), r = new Float32Array(t.count * 3);
+  for (let c = 0; c < t.count; c++) {
+    const u = c * t.stride;
+    r[c * 3] = n.getFloat32(u + o, !0), r[c * 3 + 1] = n.getFloat32(u + s, !0), r[c * 3 + 2] = n.getFloat32(u + i, !0);
+  }
+  return r;
+}
+function qt(e, t, n) {
+  if (t.count === 0) return new Uint32Array(0);
+  if (t.offset < 0)
+    throw new Error(
+      'Unsupported PLY layout: the "face" element follows a list property, so its position cannot be determined.'
+    );
+  if (t.properties.size > 0)
+    throw new Error(
+      'Unsupported mesh PLY: the "face" element mixes scalar properties with its index list.'
+    );
+  const o = et.find((h) => t.listProperties.has(h)), s = o ? t.listProperties.get(o) : void 0;
+  if (!s)
+    throw new Error(
+      `Mesh PLY "face" element is missing an index list (${et.join(" or ")}).`
+    );
+  const i = W(s.countType), r = W(s.itemType), c = new DataView(e), u = e.byteLength;
+  let l = new Uint32Array(t.count * 3), a = 0, f = t.offset;
+  for (let h = 0; h < t.count; h++) {
+    if (f + i > u) throw new Error(nt(h));
+    const d = ot(c, f, s.countType, i);
+    if (d < 0)
+      throw new Error(`Mesh PLY face ${h} declares a negative vertex count (${d}).`);
+    if (f += i, f + d * r > u) throw new Error(nt(h));
+    const m = Math.max(0, d - 2);
+    if (a + m * 3 > l.length) {
+      const b = new Uint32Array(Math.max(l.length * 2, a + m * 3));
+      b.set(l.subarray(0, a)), l = b;
+    }
+    let p = 0, $ = 0;
+    for (let b = 0; b < d; b++) {
+      const g = ot(c, f + b * r, s.itemType, r);
+      if (g < 0 || g >= n)
+        throw new Error(
+          `Mesh PLY face ${h} references vertex ${g}, but the file has ${n}.`
+        );
+      b === 0 ? p = g : b >= 2 && (l[a++] = p, l[a++] = $, l[a++] = g), $ = g;
+    }
+    f += d * r;
+  }
+  return a === l.length ? l : l.slice(0, a);
+}
+function nt(e) {
+  return `Truncated PLY file: the "face" element ends inside face ${e}.`;
+}
+function ot(e, t, n, o) {
+  switch (n) {
+    case "char":
+    case "int8":
+      return e.getInt8(t);
+    case "uchar":
+    case "uint8":
+      return e.getUint8(t);
+    case "short":
+    case "int16":
+      return e.getInt16(t, !0);
+    case "ushort":
+    case "uint16":
+      return e.getUint16(t, !0);
+    case "int":
+    case "int32":
+      return e.getInt32(t, !0);
+    case "uint":
+    case "uint32":
+      return e.getUint32(t, !0);
+    default:
+      throw new Error(`Unsupported PLY index type: "${n}" (${o} bytes).`);
+  }
+}
+const Ht = 1819045731, st = 2, z = 48, it = 40, ut = 3, ht = 3, rt = ut * 4, Gt = ht * 4;
+function Qt(e) {
+  if (e.byteLength < z)
+    throw new Error(
+      `collision.lci is truncated: ${e.byteLength} bytes, need at least ${z}.`
+    );
+  const t = new DataView(e), n = t.getUint32(0, !0);
+  if (n !== Ht)
+    throw new Error(
+      `Not a collision.lci: expected magic "coll", got 0x${n.toString(16).padStart(8, "0")}.`
+    );
+  const o = t.getUint32(4, !0);
+  if (o !== st)
+    throw new Error(
+      `Unsupported collision.lci version ${o} (expected ${st}).`
+    );
+  const s = t.getUint32(8, !0), i = new E.Vector3(
+    t.getFloat32(12, !0),
+    t.getFloat32(16, !0),
+    t.getFloat32(20, !0)
+  ), r = new E.Vector3(
+    t.getFloat32(24, !0),
+    t.getFloat32(28, !0),
+    t.getFloat32(32, !0)
+  ), c = t.getFloat32(36, !0), u = t.getFloat32(40, !0), l = t.getUint32(44, !0), a = z + l * it;
+  if (s !== a)
+    throw new Error(
+      `collision.lci headerLen ${s} does not match ${l} mesh headers (expected ${a}).`
+    );
+  if (e.byteLength < s)
+    throw new Error(
+      `collision.lci is truncated: header claims ${s} bytes, file has ${e.byteLength}.`
+    );
+  if (!(c > 0) || !(u > 0))
+    throw new Error(
+      `collision.lci cell lengths must be positive (got ${c} × ${u}).`
+    );
+  const f = new E.Box3(i.clone(), r.clone()), h = [];
+  let d = s;
+  for (let m = 0; m < l; m++) {
+    const p = z + m * it, $ = t.getUint32(p, !0), b = t.getUint32(p + 4, !0), g = Number(t.getBigUint64(p + 8, !0)), C = Number(t.getBigUint64(p + 16, !0)), x = t.getUint32(p + 24, !0), y = t.getUint32(p + 28, !0), L = t.getUint32(p + 32, !0);
+    if (!Number.isSafeInteger(g) || !Number.isSafeInteger(C))
+      throw new Error(`collision.lci mesh ${m} has an unsafe data offset/size.`);
+    if (g !== d)
+      throw new Error(
+        `collision.lci mesh ${m} data offset ${g} is not contiguous (expected ${d}).`
+      );
+    if (x * rt + y * Gt + L !== C)
+      throw new Error(
+        `collision.lci mesh ${m} size ${C} != ${x}*12 + ${y}*12 + BVH ${L}.`
+      );
+    const v = g + C;
+    if (v > e.byteLength)
+      throw new Error(
+        `collision.lci mesh ${m} extends to byte ${v}, past file length ${e.byteLength}.`
+      );
+    const F = new Float32Array(e, g, x * ut), M = g + x * rt, S = new Uint32Array(e, M, y * ht);
+    for (let T = 0; T < S.length; T++) {
+      const B = S[T];
+      if (B >= x)
+        throw new Error(
+          `collision.lci mesh ${m} face index ${B} is out of range (vertexCount ${x}).`
+        );
+    }
+    h.push({
+      cellX: $,
+      cellY: b,
+      data: {
+        vertexCount: x,
+        triangleCount: y,
+        // Copy so the returned arrays outlive a transferred/detached buffer
+        // and are not views into the BVH-adjacent region.
+        positions: F.slice(),
+        indices: S.slice()
+      },
+      bounds: Wt($, b, c, u, f)
+    }), d = v;
+  }
+  if (d !== e.byteLength)
+    throw new Error(
+      `collision.lci has ${e.byteLength - d} trailing bytes after the last mesh.`
+    );
+  return {
+    version: o,
+    bounds: f,
+    cellLengthX: c,
+    cellLengthY: u,
+    tiles: h
+  };
+}
+function Wt(e, t, n, o, s) {
+  const i = s.min.x + e * n, r = s.min.y + t * o;
+  return new E.Box3(
+    new E.Vector3(Math.min(i, s.max.x), Math.min(r, s.max.y), s.min.z),
+    new E.Vector3(
+      Math.min(i + n, s.max.x),
+      Math.min(r + o, s.max.y),
+      s.max.z
+    )
+  );
+}
+async function ue(e, t = {}) {
+  var s;
+  const n = await Promise.allSettled(
+    e.meshes.map((i) => jt(i, t))
+  );
+  (s = t.signal) == null || s.throwIfAborted();
+  const o = [];
+  for (const i of n)
+    i.status === "fulfilled" ? o.push(...i.value) : D("Skipping a collision mesh that failed to load:", i.reason);
+  return o;
+}
+async function jt(e, t) {
+  const n = await fetch(e.url, ct(t.request, t.signal));
+  if (!n.ok)
+    throw new Error(`HTTP ${n.status} for collision mesh ${e.url}`);
+  const o = await n.arrayBuffer();
+  if (Kt(e.url))
+    return Qt(o).tiles.map((r) => ({
+      url: `${e.url}#c${r.cellX}_${r.cellY}`,
+      data: r.data,
+      bounds: r.bounds
+    }));
+  const s = Vt(o);
+  return [
+    {
+      url: e.url,
+      data: s,
+      ...e.bounds ? { bounds: e.bounds } : {}
+    }
+  ];
+}
+function Kt(e) {
+  try {
+    return new URL(e, "https://example.invalid/").pathname.toLowerCase().endsWith(".lci");
+  } catch {
+    return e.toLowerCase().includes(".lci");
+  }
+}
+function he(e, t) {
+  Zt(e);
+  const { positions: n, indices: o, vertexCount: s, triangleCount: i } = e, r = new Uint8Array(s);
+  for (let l = 0; l < s; l++)
+    r[l] = t.containsPoint(
+      n[l * 3],
+      n[l * 3 + 1],
+      n[l * 3 + 2]
+    ) ? 1 : 0;
+  const c = new Uint8Array(i);
+  let u = 0;
+  for (let l = 0; l < i; l++) {
+    const a = o[l * 3], f = o[l * 3 + 1], h = o[l * 3 + 2];
+    (r[a] === 1 || r[f] === 1 || r[h] === 1) && (c[l] = 1, u++);
+  }
+  return {
+    inside: lt(e, c, 1, u),
+    outside: lt(e, c, 0, i - u)
+  };
+}
+function Zt(e) {
+  if (e.positions.length < e.vertexCount * 3)
+    throw new Error(
+      `partitionTriangleMesh: positions hold ${e.positions.length} floats, too few for ${e.vertexCount} vertices.`
+    );
+  if (e.indices.length < e.triangleCount * 3)
+    throw new Error(
+      `partitionTriangleMesh: indices hold ${e.indices.length} entries, too few for ${e.triangleCount} triangles.`
+    );
+  for (let t = 0; t < e.triangleCount * 3; t++) {
+    const n = e.indices[t];
+    if (n >= e.vertexCount)
+      throw new Error(
+        `partitionTriangleMesh: index ${n} is out of range (${e.vertexCount} vertices).`
+      );
+  }
+}
+function lt(e, t, n, o) {
+  const s = new Int32Array(e.vertexCount).fill(-1), i = new Uint32Array(o * 3);
+  let r = 0, c = 0;
+  for (let l = 0; l < e.triangleCount; l++)
+    if (t[l] === n)
+      for (let a = 0; a < 3; a++) {
+        const f = e.indices[l * 3 + a];
+        let h = s[f];
+        h < 0 && (h = r++, s[f] = h), i[c++] = h;
+      }
+  const u = new Float32Array(r * 3);
+  for (let l = 0; l < e.vertexCount; l++) {
+    const a = s[l];
+    a < 0 || (u[a * 3] = e.positions[l * 3], u[a * 3 + 1] = e.positions[l * 3 + 1], u[a * 3 + 2] = e.positions[l * 3 + 2]);
+  }
+  return { vertexCount: r, triangleCount: o, positions: u, indices: i };
+}
+export {
+  le as applyLcc2ToThreeTransform,
+  ae as buildLcc2Scene,
+  ce as buildLccScene,
+  q as createLcc2ToThreeMatrix,
+  ue as loadCollisionMeshTiles,
+  Qt as parseCollisionLci,
+  re as parseLccChunk,
+  Mt as parseLccIndex,
+  Et as parseLccManifest,
+  Vt as parseMeshPly,
+  he as partitionTriangleMesh
+};
+//# sourceMappingURL=lcc.js.map