@voluma/vlam 0.2.4 → 0.3.2

package/dist/{splat-mesh-types-CTN_duw2.js → lod-scheduler-B0a_uBlv.js}

@@ -1,14 +1,13 @@
-var M = Object.defineProperty;
-var G = (b, e, i) => e in b ? M(b, e, { enumerable: !0, configurable: !0, writable: !0, value: i }) : b[e] = i;
-var h = (b, e, i) => G(b, typeof e != "symbol" ? e + "" : e, i);
+var G = Object.defineProperty;
+var M = (p, s, i) => s in p ? G(p, s, { enumerable: !0, configurable: !0, writable: !0, value: i }) : p[s] = i;
+var h = (p, s, i) => M(p, typeof s != "symbol" ? s + "" : s, i);
 import * as S from "three/webgpu";
-import { i as y, d as D } from "./splat-budget-DXew_86c.js";
-function E(b) {
-  return `${b.file}:${b.level}:${b.offset}:${b.count}`;
+function P(p) {
+  return `${p.file}:${p.level}:${p.offset}:${p.count}`;
 }
-const L = -1, P = 128e3, w = 0.1, T = 500, R = 0.1, B = 3;
-class W {
-  constructor(e, i) {
+const L = -1, y = 128e3, w = 0.1, T = 500, R = 0.1, D = 3;
+class N {
+  constructor(s, i) {
     /** World-unit distance inside which the finest level (0) is used. */
     h(this, "lodBaseDistance");
     /** Distance ratio between successive LOD levels. */
@@ -97,31 +96,31 @@ class W {
      * (`TypedArray#sort` stability is not guaranteed).
      */
     h(this, "orderScratch");
-    if (this.leaves = e.leaves, this.coarsest = e.lodLevels - 1, this.budget = i.budget, this.lodBaseDistance = i.lodBaseDistance, this.lodMultiplier = i.lodMultiplier, this.frustumAware = i.frustumAware !== !1, this.budgetFillFraction = i.budgetFillFraction ?? 0.9, this.budgetFillCap = i.budgetFillCap ?? Number.POSITIVE_INFINITY, this.forceFinestWhenFits = i.forceFinestWhenFits !== !1, this.forceFinestWithin = i.forceFinestWithin, this.fillPastDistance = i.fillPastDistance !== !1, this.budgetFillFraction <= 0 || this.budgetFillFraction > 1)
+    if (this.leaves = s.leaves, this.coarsest = s.lodLevels - 1, this.budget = i.budget, this.lodBaseDistance = i.lodBaseDistance, this.lodMultiplier = i.lodMultiplier, this.frustumAware = i.frustumAware !== !1, this.budgetFillFraction = i.budgetFillFraction ?? 0.9, this.budgetFillCap = i.budgetFillCap ?? Number.POSITIVE_INFINITY, this.forceFinestWhenFits = i.forceFinestWhenFits !== !1, this.forceFinestWithin = i.forceFinestWithin, this.fillPastDistance = i.fillPastDistance !== !1, this.budgetFillFraction <= 0 || this.budgetFillFraction > 1)
       throw new RangeError("LodScheduler budgetFillFraction must be in (0, 1].");
     if (!(this.budgetFillCap > 0))
       throw new RangeError("LodScheduler budgetFillCap must be positive.");
     if (this.forceFinestWithin !== void 0 && !(this.forceFinestWithin >= 0))
       throw new RangeError("LodScheduler forceFinestWithin must be >= 0.");
-    const s = this.leaves.length;
-    this.minLevel = new Int32Array(s), this.maxLevel = new Int32Array(s), this.level = new Int32Array(s).fill(this.coarsest), this.resolved = new Int32Array(s).fill(this.coarsest), this.changedAt = new Float64Array(s), this.distance = new Float64Array(s), this.inFrustum = new Uint8Array(s), this.screenImportance = new Float32Array(s), this.orderScratch = new Uint32Array(s), this.coverageGroups = new Int32Array(s).fill(-1);
-    const l = [], f = /* @__PURE__ */ new Map();
-    for (let n = 0; n < s; n++) {
+    const e = this.leaves.length;
+    this.minLevel = new Int32Array(e), this.maxLevel = new Int32Array(e), this.level = new Int32Array(e).fill(this.coarsest), this.resolved = new Int32Array(e).fill(this.coarsest), this.changedAt = new Float64Array(e), this.distance = new Float64Array(e), this.inFrustum = new Uint8Array(e), this.screenImportance = new Float32Array(e), this.orderScratch = new Uint32Array(e), this.coverageGroups = new Int32Array(e).fill(-1);
+    const l = [], d = /* @__PURE__ */ new Map();
+    for (let n = 0; n < e; n++) {
       const r = this.leaves[n].budgetGroup;
       if (r === void 0) {
         l.push([n]);
         continue;
       }
-      let t = f.get(r);
-      t === void 0 && (t = l.length, f.set(r, t), l.push([])), l[t].push(n), this.coverageGroups[n] = r;
+      let t = d.get(r);
+      t === void 0 && (t = l.length, d.set(r, t), l.push([])), l[t].push(n), this.coverageGroups[n] = r;
     }
     this.budgetGroups = l.map((n) => Uint32Array.from(n));
-    for (let n = 0; n < s; n++) {
+    for (let n = 0; n < e; n++) {
       const r = this.leaves[n].lods;
-      let t = this.coarsest, c = 0;
+      let t = this.coarsest, a = 0;
       for (let o = 0; o < r.length; o++)
-        r[o] !== void 0 && (t = Math.min(t, o), c = Math.max(c, o));
-      this.minLevel[n] = t, this.maxLevel[n] = c, this.level[n] = c;
+        r[o] !== void 0 && (t = Math.min(t, o), a = Math.max(a, o));
+      this.minLevel[n] = t, this.maxLevel[n] = a, this.level[n] = a;
     }
   }
   /**
@@ -131,73 +130,73 @@ class W {
    * @param frustum - View frustum in the mesh's local space.
    * @param now - Monotonic timestamp (ms) for dwell hysteresis.
    */
-  computeDesiredRuns(e, i, s, l) {
-    if (this.selectLevels(e, i, s, l), this.forceFinestWhenFits && this.budget >= this.finestTotal()) {
+  computeDesiredRuns(s, i, e, l) {
+    if (this.selectLevels(s, i, e, l), this.forceFinestWhenFits && this.budget >= this.finestTotal()) {
       for (let n = 0; n < this.leaves.length; n++)
         this.resolved[n] = this.minLevel[n];
       return this.stats.desired = this.activeTotal(), this.stats.filled = 0, this.coalesceRuns();
     }
     this.resolved.set(this.level), this.enforceBudget();
-    const f = this.activeTotal();
-    return this.fillBudget(), this.stats.desired = this.activeTotal(), this.stats.filled = this.stats.desired - f, this.coalesceRuns();
+    const d = this.activeTotal();
+    return this.fillBudget(), this.stats.desired = this.activeTotal(), this.stats.filled = this.stats.desired - d, this.coalesceRuns();
   }
   /** Total active splats implied by the current resolved levels. */
   activeTotal() {
     var i;
-    let e = 0;
-    for (let s = 0; s < this.leaves.length; s++) {
-      const l = this.resolved[s];
-      l !== L && (e += ((i = this.leaves[s].lods[l]) == null ? void 0 : i.count) ?? 0);
+    let s = 0;
+    for (let e = 0; e < this.leaves.length; e++) {
+      const l = this.resolved[e];
+      l !== L && (s += ((i = this.leaves[e].lods[l]) == null ? void 0 : i.count) ?? 0);
     }
-    return e;
+    return s;
   }
   /** Splats if every leaf sat at its finest available level (none dropped). */
   finestTotal() {
     var i;
-    let e = 0;
-    for (let s = 0; s < this.leaves.length; s++) {
-      const l = this.minLevel[s];
-      e += ((i = this.leaves[s].lods[l]) == null ? void 0 : i.count) ?? 0;
+    let s = 0;
+    for (let e = 0; e < this.leaves.length; e++) {
+      const l = this.minLevel[e];
+      s += ((i = this.leaves[e].lods[l]) == null ? void 0 : i.count) ?? 0;
     }
-    return e;
+    return s;
   }
-  selectLevels(e, i, s, l) {
-    const { lodBaseDistance: f, lodMultiplier: n } = this;
+  selectLevels(s, i, e, l) {
+    const { lodBaseDistance: d, lodMultiplier: n } = this;
     this.hasScreenImportance = l !== void 0;
     let r = 0;
     this.stats.leaves = this.leaves.length;
     for (let t = 0; t < this.leaves.length; t++) {
-      const c = this.leaves[t], o = c.bounds.distanceToPoint(e);
-      this.distance[t] = o, this.scratchBox.copy(c.bounds), c.bounds.getSize(this.scratchSize), this.scratchBox.expandByScalar(this.scratchSize.length() * R);
-      const a = i.intersectsBox(this.scratchBox);
-      if (this.inFrustum[t] = a ? 1 : 0, a && r++, l) {
-        c.bounds.getCenter(this.scratchCenter).sub(e);
-        const d = this.scratchCenter.dot(l), F = Math.max(0, this.scratchCenter.lengthSq() - d * d);
-        this.screenImportance[t] = d > 0 ? Math.sqrt(F) / Math.max(d, 0.25) : Number.POSITIVE_INFINITY;
+      const a = this.leaves[t], o = a.bounds.distanceToPoint(s);
+      this.distance[t] = o, this.scratchBox.copy(a.bounds), a.bounds.getSize(this.scratchSize), this.scratchBox.expandByScalar(this.scratchSize.length() * R);
+      const c = i.intersectsBox(this.scratchBox);
+      if (this.inFrustum[t] = c ? 1 : 0, c && r++, l) {
+        a.bounds.getCenter(this.scratchCenter).sub(s);
+        const f = this.scratchCenter.dot(l), F = Math.max(0, this.scratchCenter.lengthSq() - f * f);
+        this.screenImportance[t] = f > 0 ? Math.sqrt(F) / Math.max(f, 0.25) : Number.POSITIVE_INFINITY;
       } else
         this.screenImportance[t] = 0;
       const u = this.level[t];
       if (this.fillPastDistance && this.forceFinestWithin !== void 0 && o <= this.forceFinestWithin) {
-        const d = this.minLevel[t];
-        u !== d && (this.level[t] = d, this.changedAt[t] = s);
+        const f = this.minLevel[t];
+        u !== f && (this.level[t] = f, this.changedAt[t] = e);
         continue;
       }
-      const v = !this.frustumAware || a ? o : o * B;
+      const v = !this.frustumAware || c ? o : o * D;
       if (!this.fillPastDistance) {
-        const d = this.distanceBandLevel(t, v, f, n);
+        const f = this.distanceBandLevel(t, v, d, n);
         if (this.changedAt[t] === 0 && u === this.maxLevel[t]) {
-          d !== u && (this.level[t] = d, this.changedAt[t] = s);
+          f !== u && (this.level[t] = f, this.changedAt[t] = e);
           continue;
         }
-        if (d === u) continue;
-        const p = this.hysteresisLevel(t, v, f, n, u);
-        if (p === u) continue;
-        (p > u || s - this.changedAt[t] >= T) && (this.level[t] = p, this.changedAt[t] = s);
+        if (f === u) continue;
+        const b = this.hysteresisLevel(t, v, d, n, u);
+        if (b === u) continue;
+        (b > u || e - this.changedAt[t] >= T) && (this.level[t] = b, this.changedAt[t] = e);
         continue;
       }
-      const m = this.hysteresisLevel(t, v, f, n, u);
+      const m = this.hysteresisLevel(t, v, d, n, u);
       if (m === u) continue;
-      (this.changedAt[t] === 0 && u === this.maxLevel[t] || s - this.changedAt[t] >= T) && (this.level[t] = m, this.changedAt[t] = s);
+      (this.changedAt[t] === 0 && u === this.maxLevel[t] || e - this.changedAt[t] >= T) && (this.level[t] = m, this.changedAt[t] = e);
     }
     this.stats.inFrustum = r;
   }
@@ -205,186 +204,180 @@ class W {
    * Pure distance→level band (independent of the leaf's current level), so a
    * classic LCC cut never has to dwell through intermediate rungs.
    */
-  distanceBandLevel(e, i, s, l) {
-    const f = this.minLevel[e], n = this.maxLevel[e];
-    let r = f;
-    for (; r < n && i > s * l ** r * (1 + w); ) r++;
-    return this.resolveAvailable(e, r);
+  distanceBandLevel(s, i, e, l) {
+    const d = this.minLevel[s], n = this.maxLevel[s];
+    let r = d;
+    for (; r < n && i > e * l ** r * (1 + w); ) r++;
+    return this.resolveAvailable(s, r);
   }
   /**
    * Stable level from distance: coarsen only past `threshold·(1 + margin)`,
    * refine only within `threshold·(1 − margin)`. The available-level clamp
    * keeps leaves that lack a level on their nearest coarser one.
    */
-  hysteresisLevel(e, i, s, l, f) {
-    const n = this.minLevel[e], r = this.maxLevel[e];
-    let t = Math.min(r, Math.max(n, f));
-    for (; t < r && i > s * l ** t * (1 + w); ) t++;
-    for (; t > n && i <= s * l ** (t - 1) * (1 - w); ) t--;
-    return this.resolveAvailable(e, t);
+  hysteresisLevel(s, i, e, l, d) {
+    const n = this.minLevel[s], r = this.maxLevel[s];
+    let t = Math.min(r, Math.max(n, d));
+    for (; t < r && i > e * l ** t * (1 + w); ) t++;
+    for (; t > n && i <= e * l ** (t - 1) * (1 - w); ) t--;
+    return this.resolveAvailable(s, t);
   }
-  resolveAvailable(e, i) {
-    const s = this.leaves[e].lods;
-    for (let l = i; l <= this.maxLevel[e]; l++) if (s[l]) return l;
-    for (let l = i - 1; l >= this.minLevel[e]; l--) if (s[l]) return l;
-    return this.maxLevel[e];
+  resolveAvailable(s, i) {
+    const e = this.leaves[s].lods;
+    for (let l = i; l <= this.maxLevel[s]; l++) if (e[l]) return l;
+    for (let l = i - 1; l >= this.minLevel[s]; l--) if (e[l]) return l;
+    return this.maxLevel[s];
   }
   /** Demotes/drops lowest-priority leaves until the total fits the budget. */
   enforceBudget() {
-    var s, l, f;
-    let e = this.activeTotal();
-    if (e <= this.budget) return;
+    var e, l, d;
+    let s = this.activeTotal();
+    if (s <= this.budget) return;
     const i = this.orderScratch.subarray(0, this.budgetGroups.length);
     for (let n = 0; n < i.length; n++) i[n] = n;
     i.sort((n, r) => {
-      const t = this.budgetGroups[n][0], c = this.budgetGroups[r][0];
+      const t = this.budgetGroups[n][0], a = this.budgetGroups[r][0];
       if (this.frustumAware) {
-        const o = this.inFrustum[t], a = this.inFrustum[c];
-        if (o !== a) return o - a;
+        const o = this.inFrustum[t], c = this.inFrustum[a];
+        if (o !== c) return o - c;
       }
-      return this.distance[c] - this.distance[t] || t - c;
+      return this.distance[a] - this.distance[t] || t - a;
     });
     for (const n of i) {
       const r = this.budgetGroups[n];
-      for (; e > this.budget; ) {
-        let t = 0, c = !1;
+      for (; s > this.budget; ) {
+        let t = 0, a = !1;
         for (const o of r) {
-          const a = this.resolved[o];
-          if (a >= this.maxLevel[o]) continue;
-          const u = this.leaves[o].lods, v = this.resolveAvailable(o, a + 1);
-          v !== a && (t += (((s = u[a]) == null ? void 0 : s.count) ?? 0) - (((l = u[v]) == null ? void 0 : l.count) ?? 0), this.resolved[o] = v, c = !0);
+          const c = this.resolved[o];
+          if (c >= this.maxLevel[o]) continue;
+          const u = this.leaves[o].lods, v = this.resolveAvailable(o, c + 1);
+          v !== c && (t += (((e = u[c]) == null ? void 0 : e.count) ?? 0) - (((l = u[v]) == null ? void 0 : l.count) ?? 0), this.resolved[o] = v, a = !0);
         }
-        if (!c) break;
-        e -= t;
+        if (!a) break;
+        s -= t;
       }
-      if (e <= this.budget) return;
+      if (s <= this.budget) return;
     }
     for (const n of i) {
-      if (e <= this.budget) return;
+      if (s <= this.budget) return;
       for (const r of this.budgetGroups[n])
-        this.resolved[r] !== L && (e -= ((f = this.leaves[r].lods[this.resolved[r]]) == null ? void 0 : f.count) ?? 0, this.resolved[r] = L);
+        this.resolved[r] !== L && (s -= ((d = this.leaves[r].lods[this.resolved[r]]) == null ? void 0 : d.count) ?? 0, this.resolved[r] = L);
     }
   }
   /**
    * Uses leftover budget to restore detail after {@link enforceBudget}
    * demoted leaves, nearest first, while the total stays under the fill
    * target. By default this may also refine *past* the distance-chosen level
-   * when headroom remains (octree / pagetable streams). With
+   * when headroom remains (octree / page-table streams). With
    * {@link fillPastDistance} false (classic LCC), fill never goes finer than
    * each leaf's distance-selected level - so a cell at the L1 band does not
    * fetch L0 only to demote moments later with the camera still.
    */
   fillBudget() {
-    var f, n;
-    const e = this.forceFinestWhenFits && this.budget >= this.finestTotal() ? this.budget : Math.min(this.budget, this.budgetFillCap) * this.budgetFillFraction;
+    var d, n;
+    const s = this.forceFinestWhenFits && this.budget >= this.finestTotal() ? this.budget : Math.min(this.budget, this.budgetFillCap) * this.budgetFillFraction;
     let i = this.activeTotal();
-    if (i >= e) return;
-    let s = 0;
+    if (i >= s) return;
+    let e = 0;
     for (let r = 0; r < this.budgetGroups.length; r++) {
       const t = this.budgetGroups[r][0];
-      (!this.frustumAware || this.inFrustum[t] === 1) && this.resolved[t] !== L && (this.orderScratch[s++] = r);
+      (!this.frustumAware || this.inFrustum[t] === 1) && this.resolved[t] !== L && (this.orderScratch[e++] = r);
     }
-    const l = this.orderScratch.subarray(0, s);
+    const l = this.orderScratch.subarray(0, e);
     l.sort((r, t) => {
-      const c = this.budgetGroups[r][0], o = this.budgetGroups[t][0];
-      return this.distance[c] - this.distance[o] || c - o;
+      const a = this.budgetGroups[r][0], o = this.budgetGroups[t][0];
+      return this.distance[a] - this.distance[o] || a - o;
     });
     for (const r of l) {
       const t = this.budgetGroups[r];
       for (; ; ) {
-        let c = 0, o = !1;
-        for (const a of t) {
-          const u = this.resolved[a], v = this.fillPastDistance ? this.minLevel[a] : this.level[a];
+        let a = 0, o = !1;
+        for (const c of t) {
+          const u = this.resolved[c], v = this.fillPastDistance ? this.minLevel[c] : this.level[c];
           if (u <= v) continue;
-          const m = this.leaves[a];
+          const m = this.leaves[c];
           let g = u - 1;
           for (; g > v && !m.lods[g]; ) g--;
-          g < v || !m.lods[g] || (c += (((f = m.lods[g]) == null ? void 0 : f.count) ?? 0) - (((n = m.lods[u]) == null ? void 0 : n.count) ?? 0), o = !0);
+          g < v || !m.lods[g] || (a += (((d = m.lods[g]) == null ? void 0 : d.count) ?? 0) - (((n = m.lods[u]) == null ? void 0 : n.count) ?? 0), o = !0);
         }
-        if (!o || i + c > e) break;
-        for (const a of t) {
-          const u = this.resolved[a], v = this.fillPastDistance ? this.minLevel[a] : this.level[a];
+        if (!o || i + a > s) break;
+        for (const c of t) {
+          const u = this.resolved[c], v = this.fillPastDistance ? this.minLevel[c] : this.level[c];
           if (u <= v) continue;
-          const m = this.leaves[a];
+          const m = this.leaves[c];
           let g = u - 1;
           for (; g > v && !m.lods[g]; ) g--;
-          g >= v && m.lods[g] && (this.resolved[a] = g);
+          g >= v && m.lods[g] && (this.resolved[c] = g);
         }
-        i += c;
+        i += a;
       }
     }
   }
   coalesceRuns() {
-    return this.buildRuns(0, this.leaves.length, (e) => this.resolved[e]);
+    return this.buildRuns(0, this.leaves.length, (s) => this.resolved[s]);
   }
   /**
    * Runs covering [from, to) at each leaf's coarsest available level - used
    * to substitute always-cached coverage while a finer level is fetching.
    */
-  coarsestRunsFor(e, i) {
-    return this.buildRuns(e, i, (s) => this.maxLevel[s]);
+  coarsestRunsFor(s, i) {
+    return this.buildRuns(s, i, (e) => this.maxLevel[e]);
   }
   /**
    * Runs covering [from, to) at `level`, clamped per leaf to an available rung
    * (prefer the requested level, else the next coarser, else the next finer).
    */
-  runsAtLevelFor(e, i, s) {
-    const l = Math.floor(s);
-    return this.buildRuns(e, i, (f) => this.clampLeafLevel(f, l));
+  runsAtLevelFor(s, i, e) {
+    const l = Math.floor(e);
+    return this.buildRuns(s, i, (d) => this.clampLeafLevel(d, l));
   }
   /** Prefer `wanted`, else next coarser, else next finer; {@link DROPPED} if none. */
-  clampLeafLevel(e, i) {
-    const s = this.leaves[e];
-    if (s.lods[i]) return i;
-    for (let l = i + 1; l < s.lods.length; l++)
-      if (s.lods[l]) return l;
+  clampLeafLevel(s, i) {
+    const e = this.leaves[s];
+    if (e.lods[i]) return i;
+    for (let l = i + 1; l < e.lods.length; l++)
+      if (e.lods[l]) return l;
     for (let l = i - 1; l >= 0; l--)
-      if (s.lods[l]) return l;
+      if (e.lods[l]) return l;
     return L;
   }
   /** Coalesces leaves [from, to) at `levelOf(leaf)` into contiguous runs. */
-  buildRuns(e, i, s) {
+  buildRuns(s, i, e) {
     const l = [];
-    let f = -1, n = -1, r = 0, t = 0, c = -1, o = -1, a = -1, u = Number.POSITIVE_INFINITY, v = !1, m = Number.POSITIVE_INFINITY;
+    let d = -1, n = -1, r = 0, t = 0, a = -1, o = -1, c = -1, u = Number.POSITIVE_INFINITY, v = !1, m = Number.POSITIVE_INFINITY;
     const g = () => {
       t > 0 && l.push({
-        file: f,
+        file: d,
         level: n,
         offset: r,
         count: t,
-        leafStart: c,
+        leafStart: a,
         leafEnd: o,
         distance: u,
         inView: v,
         ...this.hasScreenImportance ? { screenImportance: m } : {},
-        ...a >= 0 ? { coverageGroup: a } : {}
+        ...c >= 0 ? { coverageGroup: c } : {}
       }), t = 0;
     };
-    for (let d = e; d < i; d++) {
-      const F = s(d);
+    for (let f = s; f < i; f++) {
+      const F = e(f);
       if (F === L) {
         g();
         continue;
       }
-      const p = this.leaves[d].lods[F];
-      if (!p) {
+      const b = this.leaves[f].lods[F];
+      if (!b) {
         g();
         continue;
       }
-      const I = this.coverageGroups[d], A = this.distance[d], x = this.inFrustum[d] === 1;
-      t > 0 && p.file === f && F === n && I === a && p.offset === r + t && t + p.count <= P ? (t += p.count, o = d + 1, A < u && (u = A), x && (v = !0), m = Math.min(m, this.screenImportance[d])) : (g(), f = p.file, n = F, r = p.offset, t = p.count, c = d, o = d + 1, a = I, u = A, v = x, m = this.screenImportance[d]);
+      const I = this.coverageGroups[f], A = this.distance[f], x = this.inFrustum[f] === 1;
+      t > 0 && b.file === d && F === n && I === c && b.offset === r + t && t + b.count <= y ? (t += b.count, o = f + 1, A < u && (u = A), x && (v = !0), m = Math.min(m, this.screenImportance[f])) : (g(), d = b.file, n = F, r = b.offset, t = b.count, a = f, o = f + 1, c = I, u = A, v = x, m = this.screenImportance[f]);
     }
     return g(), l;
   }
 }
-const _ = 3;
-function U(b, e = D()) {
-  return b ?? (y(e) ? "smooth" : "quality");
-}
 export {
-  W as L,
-  _ as M,
-  E as a,
-  U as r
+  N as L,
+  P as r
 };
-//# sourceMappingURL=splat-mesh-types-CTN_duw2.js.map
+//# sourceMappingURL=lod-scheduler-B0a_uBlv.js.map

package/dist/lod-scheduler-B0a_uBlv.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lod-scheduler-B0a_uBlv.js","sources":["../src/lib/streaming/lod-scheduler.ts"],"sourcesContent":["import * as THREE from 'three/webgpu';\nimport type { LodLeaf, LodManifest } from './lod-manifest';\nimport type { LodSource } from './lod-source';\n\n/**\n * A contiguous splat range within one chunk file, at one LOD level - the\n * unit the pool activates. Adjacent manifest leaves that resolve to the same\n * `(file, level)` and whose ranges abut are coalesced into one run, so the\n * pool sees a handful of large ranges instead of thousands of tiny leaves.\n */\nexport interface LodRun {\n  readonly file: number;\n  readonly level: number;\n  readonly offset: number;\n  readonly count: number;\n  /** First manifest-leaf index this run covers. */\n  readonly leafStart: number;\n  /** One past the last covered leaf index. */\n  readonly leafEnd: number;\n  /**\n   * Physical-coverage identity when several manifest leaves form one region.\n   * A classic LCC cell may be split into fetch-sized leaves, but its slices\n   * must still swap as one visible unit. Undefined retains interval-based\n   * grouping for hierarchical sources.\n   */\n  readonly coverageGroup?: number;\n  /**\n   * Camera distance (mesh-local) of the nearest leaf in this run, from the\n   * last {@link LodScheduler.computeDesiredRuns} pass. Streamed meshes use it\n   * to fetch near detail before far coarse coverage. Absent on sources that\n   * do not track per-leaf distance.\n   */\n  readonly distance?: number;\n  /**\n   * True when any leaf in this run intersects the view frustum (with the\n   * scheduler's edge margin). Used to rank classic-path fetches so in-view\n   * detail beats behind-camera work; absent when the source does not track it.\n   */\n  readonly inView?: boolean;\n  /**\n   * Fetch-only angular distance from the camera's forward axis. Smaller values\n   * are nearer the screen centre. It never affects LOD selection or budget.\n   */\n  readonly screenImportance?: number;\n}\n\n/** Stable identity of a run, for diffing desired vs. resident sets. */\nexport function runKey(run: LodRun): string {\n  return `${run.file}:${run.level}:${run.offset}:${run.count}`;\n}\n\n/** Sentinel level meaning \"this leaf is currently dropped (renders nothing)\". */\nconst DROPPED = -1;\n\n/**\n * Maximum splats in one run. Large contiguous regions are split into several\n * runs so no single pool append (and thus no single frame) does an unbounded\n * amount of copy + upload work. Split runs stay contiguous, so they still\n * upload as one coalesced rectangle.\n */\nconst MAX_RUN_SPLATS = 128_000;\n\n/** Hysteresis dead-band around each LOD distance threshold. */\nconst THRESHOLD_MARGIN = 0.1;\n/** Minimum time a leaf must hold a level before changing again, ms. */\nconst DWELL_MS = 500;\n/** Frustum test margin, as a fraction of each leaf's own size. */\nconst FRUSTUM_MARGIN = 0.1;\n/**\n * Out-of-frustum leaves act this many times farther away instead of being\n * hard-coarsened. Rotating the camera then re-ranks leaves smoothly (and\n * dwell applies), rather than mass-flipping edge leaves every frame -\n * PlayCanvas uses the same behind-camera-penalty idea.\n */\nconst FRUSTUM_PENALTY = 3;\n\n/**\n * Chooses a level of detail per spatial leaf from the camera, keeps the\n * total within a splat budget, and coalesces the result into runs.\n *\n * The scheduler is pure with respect to rendering: it takes a camera\n * position and frustum (both in the mesh's local space) and returns the set\n * of runs that should be resident. It owns only the small amount of state\n * needed for temporal stability (each leaf's current level and when it last\n * changed), so it is straightforward to drive from a test harness.\n *\n * LOD distance model (PlayCanvas-compatible): level 0 is used within\n * `lodBaseDistance`; each successive level covers a band `lodMultiplier`×\n * farther out. By default out-of-frustum leaves act {@link FRUSTUM_PENALTY}×\n * farther away. Formats with broad spatial cells can disable that bias so an\n * orbit does not churn already-refined cells at the frustum edges.\n *\n * The distance model only sets the *floor* and the *priority*: when the\n * distance-chosen set leaves budget unused, {@link fillBudget} promotes\n * in-frustum leaves nearest-first until its configured headroom target is\n * spent (90% by default). Formats can cap that optional refinement and avoid\n * a full-finest cut even when an explicitly large budget could hold it. The\n * budget\n * therefore decides how far refinement reaches - a desktop budget yields\n * full detail even with the whole scene in view, a mobile budget refines\n * only near the camera.\n */\nexport class LodScheduler implements LodSource {\n  /** World-unit distance inside which the finest level (0) is used. */\n  lodBaseDistance: number;\n  /** Distance ratio between successive LOD levels. */\n  lodMultiplier: number;\n  /** Maximum active splats; the desired set is demoted to fit. */\n  budget: number;\n\n  private readonly leaves: readonly LodLeaf[];\n  private readonly coarsest: number;\n  /** Per leaf: lowest/highest LOD level that has data. */\n  private readonly minLevel: Int32Array;\n  private readonly maxLevel: Int32Array;\n  /**\n   * Per leaf: the distance *ambition* - the finest level the camera distance\n   * asks for, with hysteresis/dwell applied. This is the hysteresis *state*:\n   * only {@link selectLevels} writes it, so budget demotion can never feed\n   * back into the dead-band/dwell logic and oscillate. With `fillPastDistance`\n   * false, {@link fillBudget} restores {@link resolved} only up to here.\n   */\n  private readonly level: Int32Array;\n  /**\n   * Per leaf: the resolved target - the ambition capped to fit the budget by\n   * {@link enforceBudget}, then refilled from leftover headroom by\n   * {@link fillBudget} (or DROPPED). This is what {@link coalesceRuns} emits.\n   */\n  private readonly resolved: Int32Array;\n  /** Per leaf: timestamp of the last distance-level change, for dwell. */\n  private readonly changedAt: Float64Array;\n\n  private readonly distance: Float64Array;\n  private readonly inFrustum: Uint8Array;\n  /** Leaves that must move through the budget cut together. */\n  private readonly budgetGroups: readonly Uint32Array[];\n  /** Per-leaf physical coverage group, when the manifest defines one. */\n  private readonly coverageGroups: Int32Array;\n  /** Whether view-frustum membership affects distance and fill priority. */\n  private readonly frustumAware: boolean;\n  /** Fraction of the usable budget that optional refinement may consume. */\n  private readonly budgetFillFraction: number;\n  /** Absolute cap on optional refinement; distance-selected detail may exceed it. */\n  private readonly budgetFillCap: number;\n  /** Whether a budget that holds every finest leaf forces a full-finest cut. */\n  private readonly forceFinestWhenFits: boolean;\n  /**\n   * Leaves at or inside this camera distance always resolve to their finest\n   * available level (no hysteresis climb). Classic LCC uses a multi-band\n   * radius so adjacent broad cells do not paint coarse discs at startup.\n   */\n  private readonly forceFinestWithin: number | undefined;\n  /**\n   * When false, {@link fillBudget} only restores toward each leaf's\n   * distance-selected {@link level} - never finer. Classic LCC sets this so\n   * a mid-range cell does not fetch L0 only to demote to L1 once the cut\n   * settles.\n   */\n  private readonly fillPastDistance: boolean;\n\n  /**\n   * What the last cut actually decided, for the HUD.\n   *\n   * The resident splat count alone cannot distinguish \"the scheduler asked for\n   * this\" from \"the scheduler asked for more and the mesh could not apply it\",\n   * and those have opposite fixes. Measured rather than inferred after a\n   * zoomed-out `sandwijck` sat at exactly its coarsest total (190,730) with a\n   * 600k budget - 68% of the budget unspent, with no way to see which stage\n   * declined to spend it.\n   */\n  readonly stats = {\n    /** Leaves the frustum test accepted - `fillBudget`'s candidate set. */\n    inFrustum: 0,\n    /** Total leaves in the tree. */\n    leaves: 0,\n    /** Splats implied by the resolved cut, before the mesh applies anything. */\n    desired: 0,\n    /** Splats `fillBudget` added on top of the distance-chosen levels. */\n    filled: 0,\n  };\n\n  private readonly scratchBox = new THREE.Box3();\n  private readonly scratchSize = new THREE.Vector3();\n  private readonly scratchCenter = new THREE.Vector3();\n  private readonly screenImportance: Float32Array;\n  /** Whether the last selection pass received a camera-forward vector. */\n  private hasScreenImportance = false;\n  /**\n   * Persistent leaf-index ordering scratch for {@link enforceBudget} and\n   * {@link fillBudget}, sorted in place per call instead of allocating a\n   * fresh `[...keys]` array. Comparators break ties on the index itself so\n   * the order is identical to the stable `Array#sort` this replaces\n   * (`TypedArray#sort` stability is not guaranteed).\n   */\n  private readonly orderScratch: Uint32Array;\n\n  constructor(\n    manifest: LodManifest,\n    options: {\n      budget: number;\n      lodBaseDistance: number;\n      lodMultiplier: number;\n      frustumAware?: boolean;\n      budgetFillFraction?: number;\n      budgetFillCap?: number;\n      forceFinestWhenFits?: boolean;\n      forceFinestWithin?: number;\n      /**\n       * When false, leftover-budget fill never refines past the distance-\n       * selected level (see {@link fillPastDistance}). Default true.\n       */\n      fillPastDistance?: boolean;\n    },\n  ) {\n    this.leaves = manifest.leaves;\n    this.coarsest = manifest.lodLevels - 1;\n    this.budget = options.budget;\n    this.lodBaseDistance = options.lodBaseDistance;\n    this.lodMultiplier = options.lodMultiplier;\n    this.frustumAware = options.frustumAware !== false;\n    this.budgetFillFraction = options.budgetFillFraction ?? 0.9;\n    this.budgetFillCap = options.budgetFillCap ?? Number.POSITIVE_INFINITY;\n    this.forceFinestWhenFits = options.forceFinestWhenFits !== false;\n    this.forceFinestWithin = options.forceFinestWithin;\n    this.fillPastDistance = options.fillPastDistance !== false;\n    if (this.budgetFillFraction <= 0 || this.budgetFillFraction > 1) {\n      throw new RangeError('LodScheduler budgetFillFraction must be in (0, 1].');\n    }\n    if (!(this.budgetFillCap > 0)) {\n      throw new RangeError('LodScheduler budgetFillCap must be positive.');\n    }\n    if (this.forceFinestWithin !== undefined && !(this.forceFinestWithin >= 0)) {\n      throw new RangeError('LodScheduler forceFinestWithin must be >= 0.');\n    }\n\n    const n = this.leaves.length;\n    this.minLevel = new Int32Array(n);\n    this.maxLevel = new Int32Array(n);\n    this.level = new Int32Array(n).fill(this.coarsest);\n    this.resolved = new Int32Array(n).fill(this.coarsest);\n    this.changedAt = new Float64Array(n);\n    this.distance = new Float64Array(n);\n    this.inFrustum = new Uint8Array(n);\n    this.screenImportance = new Float32Array(n);\n    this.orderScratch = new Uint32Array(n);\n    this.coverageGroups = new Int32Array(n).fill(-1);\n\n    const groups: number[][] = [];\n    const explicitGroups = new Map<number, number>();\n    for (let i = 0; i < n; i++) {\n      const key = (this.leaves[i] as LodLeaf).budgetGroup;\n      if (key === undefined) {\n        groups.push([i]);\n        continue;\n      }\n      let groupIndex = explicitGroups.get(key);\n      if (groupIndex === undefined) {\n        groupIndex = groups.length;\n        explicitGroups.set(key, groupIndex);\n        groups.push([]);\n      }\n      (groups[groupIndex] as number[]).push(i);\n      this.coverageGroups[i] = key;\n    }\n    this.budgetGroups = groups.map((members) => Uint32Array.from(members));\n\n    for (let i = 0; i < n; i++) {\n      const lods = (this.leaves[i] as LodLeaf).lods;\n      let min = this.coarsest;\n      let max = 0;\n      for (let l = 0; l < lods.length; l++) {\n        if (lods[l] === undefined) continue;\n        min = Math.min(min, l);\n        max = Math.max(max, l);\n      }\n      this.minLevel[i] = min;\n      this.maxLevel[i] = max;\n      this.level[i] = max; // start coarse\n    }\n  }\n\n  /**\n   * Recomputes the desired resident run set for the current camera.\n   *\n   * @param cameraLocal - Camera position in the mesh's local space.\n   * @param frustum - View frustum in the mesh's local space.\n   * @param now - Monotonic timestamp (ms) for dwell hysteresis.\n   */\n  computeDesiredRuns(\n    cameraLocal: THREE.Vector3,\n    frustum: THREE.Frustum,\n    now: number,\n    cameraForward?: THREE.Vector3,\n  ): LodRun[] {\n    this.selectLevels(cameraLocal, frustum, now, cameraForward);\n    // When the budget already holds every leaf's finest level, skip distance /\n    // frustum demotion entirely. Otherwise a small rotate marks leaves\n    // out-of-frustum (×{@link FRUSTUM_PENALTY}), coarsens them, and the mesh\n    // aborts fine fetches / swaps to coarse LCC discs - then has to climb\n    // back when they re-enter the view.\n    if (this.forceFinestWhenFits && this.budget >= this.finestTotal()) {\n      for (let i = 0; i < this.leaves.length; i++) {\n        this.resolved[i] = this.minLevel[i] as number;\n      }\n      this.stats.desired = this.activeTotal();\n      this.stats.filled = 0;\n      return this.coalesceRuns();\n    }\n    // Copy the ambition into the resolved target, cap it to the budget, then\n    // refill leftover headroom. Budget stages touch only `resolved`, never the\n    // ambition/hysteresis state - a stationary camera therefore resolves the\n    // same cut every pass instead of oscillating red↔orange.\n    this.resolved.set(this.level);\n    this.enforceBudget();\n    const beforeFill = this.activeTotal();\n    this.fillBudget();\n    this.stats.desired = this.activeTotal();\n    this.stats.filled = this.stats.desired - beforeFill;\n    return this.coalesceRuns();\n  }\n\n  /** Total active splats implied by the current resolved levels. */\n  private activeTotal(): number {\n    let total = 0;\n    for (let i = 0; i < this.leaves.length; i++) {\n      const level = this.resolved[i] as number;\n      if (level === DROPPED) continue;\n      total += (this.leaves[i] as LodLeaf).lods[level]?.count ?? 0;\n    }\n    return total;\n  }\n\n  /** Splats if every leaf sat at its finest available level (none dropped). */\n  private finestTotal(): number {\n    let total = 0;\n    for (let i = 0; i < this.leaves.length; i++) {\n      const level = this.minLevel[i] as number;\n      total += (this.leaves[i] as LodLeaf).lods[level]?.count ?? 0;\n    }\n    return total;\n  }\n\n  private selectLevels(\n    cameraLocal: THREE.Vector3,\n    frustum: THREE.Frustum,\n    now: number,\n    cameraForward?: THREE.Vector3,\n  ): void {\n    const { lodBaseDistance: base, lodMultiplier: m } = this;\n    this.hasScreenImportance = cameraForward !== undefined;\n    let visibleCount = 0;\n    this.stats.leaves = this.leaves.length;\n    for (let i = 0; i < this.leaves.length; i++) {\n      const leaf = this.leaves[i] as LodLeaf;\n      const d = leaf.bounds.distanceToPoint(cameraLocal);\n      this.distance[i] = d;\n\n      // Widen the box by a fraction of its own size for edge stability.\n      this.scratchBox.copy(leaf.bounds);\n      leaf.bounds.getSize(this.scratchSize);\n      this.scratchBox.expandByScalar(this.scratchSize.length() * FRUSTUM_MARGIN);\n      const visible = frustum.intersectsBox(this.scratchBox);\n      this.inFrustum[i] = visible ? 1 : 0;\n      if (visible) visibleCount++;\n\n      // Broad classic-LCC tiles frequently all intersect the frustum, so the\n      // boolean above cannot tell the centre of the screen from its edges.\n      // This is deliberately fetch metadata only: distance remains the source\n      // of truth for the resolved LOD and the budget cut.\n      if (cameraForward) {\n        leaf.bounds.getCenter(this.scratchCenter).sub(cameraLocal);\n        const depth = this.scratchCenter.dot(cameraForward);\n        const lateralSquared = Math.max(0, this.scratchCenter.lengthSq() - depth * depth);\n        this.screenImportance[i] =\n          depth > 0 ? Math.sqrt(lateralSquared) / Math.max(depth, 0.25) : Number.POSITIVE_INFINITY;\n      } else {\n        this.screenImportance[i] = 0;\n      }\n\n      const current = this.level[i] as number;\n      // Blanket force-finest only when fill may still climb past the distance\n      // band (octree / page-table). Classic LCC never uses this path.\n      if (\n        this.fillPastDistance &&\n        this.forceFinestWithin !== undefined &&\n        d <= this.forceFinestWithin\n      ) {\n        const finest = this.minLevel[i] as number;\n        if (current !== finest) {\n          this.level[i] = finest;\n          this.changedAt[i] = now;\n        }\n        continue;\n      }\n\n      const effectiveDistance = !this.frustumAware || visible ? d : d * FRUSTUM_PENALTY;\n\n      // Classic LCC: the ambition tracks the pure distance band only. Budget\n      // demotions live in `resolved`, never here, so they cannot feed back\n      // into hysteresis. A cold cell snaps straight to its band (no dwell\n      // climb through intermediate LODs); afterward only a band *crossing*\n      // moves the ambition - a stationary camera in the same band holds,\n      // even if the budget just demoted its resolved level.\n      if (!this.fillPastDistance) {\n        const band = this.distanceBandLevel(i, effectiveDistance, base, m);\n        const coldStart =\n          (this.changedAt[i] as number) === 0 && current === (this.maxLevel[i] as number);\n        if (coldStart) {\n          if (band !== current) {\n            this.level[i] = band;\n            this.changedAt[i] = now;\n          }\n          continue;\n        }\n        if (band === current) continue;\n        const proposed = this.hysteresisLevel(i, effectiveDistance, base, m, current);\n        if (proposed === current) continue;\n        // Coarsen immediately (moving away should not linger over budget);\n        // only refinement waits out the dwell window.\n        const coarsening = proposed > current;\n        if (coarsening || now - (this.changedAt[i] as number) >= DWELL_MS) {\n          this.level[i] = proposed;\n          this.changedAt[i] = now;\n        }\n        continue;\n      }\n\n      const proposed = this.hysteresisLevel(i, effectiveDistance, base, m, current);\n      if (proposed === current) continue;\n      const coldSnap =\n        (this.changedAt[i] as number) === 0 && current === (this.maxLevel[i] as number);\n      if (coldSnap || now - (this.changedAt[i] as number) >= DWELL_MS) {\n        this.level[i] = proposed;\n        this.changedAt[i] = now;\n      }\n    }\n    this.stats.inFrustum = visibleCount;\n  }\n\n  /**\n   * Pure distance→level band (independent of the leaf's current level), so a\n   * classic LCC cut never has to dwell through intermediate rungs.\n   */\n  private distanceBandLevel(index: number, d: number, base: number, m: number): number {\n    const min = this.minLevel[index] as number;\n    const max = this.maxLevel[index] as number;\n    let level = min;\n    while (level < max && d > base * m ** level * (1 + THRESHOLD_MARGIN)) level++;\n    return this.resolveAvailable(index, level);\n  }\n\n  /**\n   * Stable level from distance: coarsen only past `threshold·(1 + margin)`,\n   * refine only within `threshold·(1 − margin)`. The available-level clamp\n   * keeps leaves that lack a level on their nearest coarser one.\n   */\n  private hysteresisLevel(\n    index: number,\n    d: number,\n    base: number,\n    m: number,\n    current: number,\n  ): number {\n    const min = this.minLevel[index] as number;\n    const max = this.maxLevel[index] as number;\n    let level = Math.min(max, Math.max(min, current));\n    // threshold(L) = base·m^L is the boundary between level L and L+1.\n    while (level < max && d > base * m ** level * (1 + THRESHOLD_MARGIN)) level++;\n    while (level > min && d <= base * m ** (level - 1) * (1 - THRESHOLD_MARGIN)) level--;\n    // Resolve to the nearest available level (prefer coarser) if this exact\n    // one has no data (leaves need not carry every level).\n    return this.resolveAvailable(index, level);\n  }\n\n  private resolveAvailable(index: number, target: number): number {\n    const lods = (this.leaves[index] as LodLeaf).lods;\n    for (let l = target; l <= (this.maxLevel[index] as number); l++) if (lods[l]) return l;\n    for (let l = target - 1; l >= (this.minLevel[index] as number); l--) if (lods[l]) return l;\n    return this.maxLevel[index] as number;\n  }\n\n  /** Demotes/drops lowest-priority leaves until the total fits the budget. */\n  private enforceBudget(): void {\n    let total = this.activeTotal();\n    if (total <= this.budget) return;\n\n    // Demote lowest priority first. When frustum-aware: out-of-frustum before\n    // in-frustum, then farthest. Classic LCC sets frustumAware false - broad\n    // XY cells often sit mostly behind the camera while the user stands in\n    // them (d≈0); frustum demotion would coarsen that cell first and let\n    // thinner cells ahead keep fine detail (backwards load). Distance only.\n    const order = this.orderScratch.subarray(0, this.budgetGroups.length);\n    for (let i = 0; i < order.length; i++) order[i] = i;\n    order.sort((a, b) => {\n      const ia = (this.budgetGroups[a] as Uint32Array)[0] as number;\n      const ib = (this.budgetGroups[b] as Uint32Array)[0] as number;\n      if (this.frustumAware) {\n        const fa = this.inFrustum[ia] as number;\n        const fb = this.inFrustum[ib] as number;\n        if (fa !== fb) return fa - fb; // out-of-frustum (0) first\n      }\n      return (this.distance[ib] as number) - (this.distance[ia] as number) || ia - ib;\n    });\n\n    // Pass 1: coarsen toward the coarsest available level.\n    for (const groupIndex of order) {\n      const group = this.budgetGroups[groupIndex] as Uint32Array;\n      while (total > this.budget) {\n        let reduction = 0;\n        let changed = false;\n        for (const i of group) {\n          const current = this.resolved[i] as number;\n          if (current >= (this.maxLevel[i] as number)) continue;\n          const lods = (this.leaves[i] as LodLeaf).lods;\n          const nextLevel = this.resolveAvailable(i, current + 1);\n          if (nextLevel === current) continue;\n          reduction += (lods[current]?.count ?? 0) - (lods[nextLevel]?.count ?? 0);\n          this.resolved[i] = nextLevel;\n          changed = true;\n        }\n        if (!changed) break;\n        total -= reduction;\n      }\n      if (total <= this.budget) return;\n    }\n\n    // Pass 2 (last resort): drop groups entirely, lowest priority first.\n    for (const groupIndex of order) {\n      if (total <= this.budget) return;\n      for (const i of this.budgetGroups[groupIndex] as Uint32Array) {\n        if ((this.resolved[i] as number) === DROPPED) continue;\n        total -= (this.leaves[i] as LodLeaf).lods[this.resolved[i] as number]?.count ?? 0;\n        this.resolved[i] = DROPPED;\n      }\n    }\n  }\n\n  /**\n   * Uses leftover budget to restore detail after {@link enforceBudget}\n   * demoted leaves, nearest first, while the total stays under the fill\n   * target. By default this may also refine *past* the distance-chosen level\n   * when headroom remains (octree / page-table streams). With\n   * {@link fillPastDistance} false (classic LCC), fill never goes finer than\n   * each leaf's distance-selected level - so a cell at the L1 band does not\n   * fetch L0 only to demote moments later with the camera still.\n   */\n  private fillBudget(): void {\n    const target =\n      this.forceFinestWhenFits && this.budget >= this.finestTotal()\n        ? this.budget\n        : Math.min(this.budget, this.budgetFillCap) * this.budgetFillFraction;\n    let total = this.activeTotal();\n    if (total >= target) return;\n\n    // Candidate in-frustum groups, nearest first (ties keep manifest order),\n    // packed into the front of the shared index scratch.\n    let candidateCount = 0;\n    for (let groupIndex = 0; groupIndex < this.budgetGroups.length; groupIndex++) {\n      const first = (this.budgetGroups[groupIndex] as Uint32Array)[0] as number;\n      if (\n        (!this.frustumAware || this.inFrustum[first] === 1) &&\n        (this.resolved[first] as number) !== DROPPED\n      ) {\n        this.orderScratch[candidateCount++] = groupIndex;\n      }\n    }\n    const order = this.orderScratch.subarray(0, candidateCount);\n    order.sort((a, b) => {\n      const ia = (this.budgetGroups[a] as Uint32Array)[0] as number;\n      const ib = (this.budgetGroups[b] as Uint32Array)[0] as number;\n      return (this.distance[ia] as number) - (this.distance[ib] as number) || ia - ib;\n    });\n\n    // Nearest groups refine first (up to the distance floor when capped).\n    for (const groupIndex of order) {\n      const group = this.budgetGroups[groupIndex] as Uint32Array;\n      while (true) {\n        let growth = 0;\n        let canPromote = false;\n        for (const i of group) {\n          const current = this.resolved[i] as number;\n          const floor = this.fillPastDistance\n            ? (this.minLevel[i] as number)\n            : (this.level[i] as number);\n          if (current <= floor) continue;\n          const leaf = this.leaves[i] as LodLeaf;\n          let finer = current - 1;\n          while (finer > floor && !leaf.lods[finer]) finer--;\n          if (finer < floor || !leaf.lods[finer]) continue;\n          growth += (leaf.lods[finer]?.count ?? 0) - (leaf.lods[current]?.count ?? 0);\n          canPromote = true;\n        }\n        if (!canPromote || total + growth > target) break;\n        for (const i of group) {\n          const current = this.resolved[i] as number;\n          const floor = this.fillPastDistance\n            ? (this.minLevel[i] as number)\n            : (this.level[i] as number);\n          if (current <= floor) continue;\n          const leaf = this.leaves[i] as LodLeaf;\n          let finer = current - 1;\n          while (finer > floor && !leaf.lods[finer]) finer--;\n          if (finer >= floor && leaf.lods[finer]) this.resolved[i] = finer;\n        }\n        total += growth;\n      }\n    }\n  }\n\n  private coalesceRuns(): LodRun[] {\n    return this.buildRuns(0, this.leaves.length, (i) => this.resolved[i] as number);\n  }\n\n  /**\n   * Runs covering [from, to) at each leaf's coarsest available level - used\n   * to substitute always-cached coverage while a finer level is fetching.\n   */\n  coarsestRunsFor(from: number, to: number): LodRun[] {\n    return this.buildRuns(from, to, (i) => this.maxLevel[i] as number);\n  }\n\n  /**\n   * Runs covering [from, to) at `level`, clamped per leaf to an available rung\n   * (prefer the requested level, else the next coarser, else the next finer).\n   */\n  runsAtLevelFor(from: number, to: number, level: number): LodRun[] {\n    const wanted = Math.floor(level);\n    return this.buildRuns(from, to, (i) => this.clampLeafLevel(i, wanted));\n  }\n\n  /** Prefer `wanted`, else next coarser, else next finer; {@link DROPPED} if none. */\n  private clampLeafLevel(leafIndex: number, wanted: number): number {\n    const leaf = this.leaves[leafIndex] as LodLeaf;\n    if (leaf.lods[wanted]) return wanted;\n    for (let l = wanted + 1; l < leaf.lods.length; l++) {\n      if (leaf.lods[l]) return l;\n    }\n    for (let l = wanted - 1; l >= 0; l--) {\n      if (leaf.lods[l]) return l;\n    }\n    return DROPPED;\n  }\n\n  /** Coalesces leaves [from, to) at `levelOf(leaf)` into contiguous runs. */\n  private buildRuns(from: number, to: number, levelOf: (index: number) => number): LodRun[] {\n    const runs: LodRun[] = [];\n    let file = -1;\n    let level = -1;\n    let offset = 0;\n    let count = 0;\n    let leafStart = -1;\n    let leafEnd = -1;\n    let coverageGroup = -1;\n    let distance = Number.POSITIVE_INFINITY;\n    let inView = false;\n    let screenImportance = Number.POSITIVE_INFINITY;\n    const flush = (): void => {\n      if (count > 0) {\n        runs.push({\n          file,\n          level,\n          offset,\n          count,\n          leafStart,\n          leafEnd,\n          distance,\n          inView,\n          ...(this.hasScreenImportance ? { screenImportance } : {}),\n          ...(coverageGroup >= 0 ? { coverageGroup } : {}),\n        });\n      }\n      count = 0;\n    };\n\n    for (let i = from; i < to; i++) {\n      const l = levelOf(i);\n      if (l === DROPPED) {\n        flush();\n        continue;\n      }\n      const range = (this.leaves[i] as LodLeaf).lods[l];\n      if (!range) {\n        flush();\n        continue;\n      }\n      const leafCoverageGroup = this.coverageGroups[i] as number;\n      const leafDistance = this.distance[i] as number;\n      const leafInView = (this.inFrustum[i] as number) === 1;\n      if (\n        count > 0 &&\n        range.file === file &&\n        l === level &&\n        leafCoverageGroup === coverageGroup &&\n        range.offset === offset + count &&\n        count + range.count <= MAX_RUN_SPLATS\n      ) {\n        count += range.count; // extend the current run\n        leafEnd = i + 1;\n        if (leafDistance < distance) distance = leafDistance;\n        if (leafInView) inView = true;\n        screenImportance = Math.min(screenImportance, this.screenImportance[i] as number);\n      } else {\n        flush();\n        file = range.file;\n        level = l;\n        offset = range.offset;\n        count = range.count;\n        leafStart = i;\n        leafEnd = i + 1;\n        coverageGroup = leafCoverageGroup;\n        distance = leafDistance;\n        inView = leafInView;\n        screenImportance = this.screenImportance[i] as number;\n      }\n    }\n    flush();\n    return runs;\n  }\n}\n"],"names":["runKey","run","DROPPED","MAX_RUN_SPLATS","THRESHOLD_MARGIN","DWELL_MS","FRUSTUM_MARGIN","FRUSTUM_PENALTY","LodScheduler","manifest","options","__publicField","THREE","n","groups","explicitGroups","i","key","groupIndex","members","lods","min","max","l","cameraLocal","frustum","now","cameraForward","beforeFill","total","level","_a","base","m","visibleCount","leaf","d","visible","depth","lateralSquared","current","finest","effectiveDistance","band","proposed","index","target","order","a","b","ia","ib","fa","fb","group","reduction","changed","nextLevel","_b","_c","candidateCount","first","growth","canPromote","floor","finer","from","to","wanted","leafIndex","levelOf","runs","file","offset","count","leafStart","leafEnd","coverageGroup","distance","inView","screenImportance","flush","range","leafCoverageGroup","leafDistance","leafInView"],"mappings":"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"}

package/dist/logging-BfPdd7NJ.js.map

@@ -1 +1 @@
-{"version":3,"file":"logging-BfPdd7NJ.js","sources":["../src/lib/logging.ts"],"sourcesContent":["/**\n * The library's diagnostic output, behind one replaceable hook.\n *\n * A library that writes straight to the host console gives embedders no way\n * out - and some of these sites are per-item (a malformed chunk in a large\n * streamed scene can warn on every tick). Everything routes through\n * {@link setVlamLogHandler} instead, so a host can forward VLAM! diagnostics\n * into its own logger, or silence them entirely.\n *\n * Worker scopes are the deliberate exception: `load-worker.ts` and\n * `sort-worker.ts` run in a separate realm with no access to this module's\n * state, and plumbing a handler across `postMessage` would mean serializing\n * user callbacks. Neither worker logs today - failures travel back as\n * structured messages - so there is nothing to route.\n */\n\n/** Severity of a library diagnostic. */\nexport type VlamLogLevel = 'warn' | 'error';\n\n/**\n * Receives library diagnostics. `message` is already prefixed with `vlam:`;\n * `details` carries any extra values the call site passed.\n */\nexport type VlamLogHandler = (level: VlamLogLevel, message: string, ...details: unknown[]) => void;\n\nconst defaultHandler: VlamLogHandler = (level, message, ...details) => {\n  if (level === 'error') console.error(message, ...details);\n  else console.warn(message, ...details);\n};\n\nlet handler: VlamLogHandler | null = defaultHandler;\n\n/**\n * Redirects (or silences) every diagnostic the library emits.\n *\n * @param next - A handler to receive diagnostics, `null` to drop them\n * silently, or omitted/`undefined` to restore the default console handler.\n *\n * @example\n * setVlamLogHandler((level, message) => myLogger.log(level, message));\n * setVlamLogHandler(null); // silence VLAM! entirely\n */\nexport function setVlamLogHandler(next?: VlamLogHandler | null): void {\n  handler = next === undefined ? defaultHandler : next;\n}\n\n/** Emits a `vlam:`-prefixed warning through the current handler. */\nexport function warn(message: string, ...details: unknown[]): void {\n  handler?.('warn', `vlam: ${message}`, ...details);\n}\n\n/** Emits a `vlam:`-prefixed error through the current handler. */\nexport function logError(message: string, ...details: unknown[]): void {\n  handler?.('error', `vlam: ${message}`, ...details);\n}\n"],"names":["defaultHandler","level","message","details","handler","setVlamLogHandler","next","warn","logError"],"mappings":"AAyBA,MAAMA,IAAiC,CAACC,GAAOC,MAAYC,MAAY;AACrE,EAAIF,MAAU,UAAS,QAAQ,MAAMC,GAAS,GAAGC,CAAO,IACnD,QAAQ,KAAKD,GAAS,GAAGC,CAAO;AACvC;AAEA,IAAIC,IAAiCJ;AAY9B,SAASK,EAAkBC,GAAoC;AACpE,EAAAF,IAAUE,MAAS,SAAYN,IAAiBM;AAClD;AAGO,SAASC,EAAKL,MAAoBC,GAA0B;AACjE,EAAAC,KAAA,QAAAA,EAAU,QAAQ,SAASF,CAAO,IAAI,GAAGC;AAC3C;AAGO,SAASK,EAASN,MAAoBC,GAA0B;AACrE,EAAAC,KAAA,QAAAA,EAAU,SAAS,SAASF,CAAO,IAAI,GAAGC;AAC5C;"}
+{"version":3,"file":"logging-BfPdd7NJ.js","sources":["../src/lib/core/logging.ts"],"sourcesContent":["/**\n * The library's diagnostic output, behind one replaceable hook.\n *\n * A library that writes straight to the host console gives embedders no way\n * out - and some of these sites are per-item (a malformed chunk in a large\n * streamed scene can warn on every tick). Everything routes through\n * {@link setVlamLogHandler} instead, so a host can forward VLAM! diagnostics\n * into its own logger, or silence them entirely.\n *\n * Worker scopes are the deliberate exception: `load-worker.ts` and\n * `sort-worker.ts` run in a separate realm with no access to this module's\n * state, and plumbing a handler across `postMessage` would mean serializing\n * user callbacks. Neither worker logs today - failures travel back as\n * structured messages - so there is nothing to route.\n */\n\n/** Severity of a library diagnostic. */\nexport type VlamLogLevel = 'warn' | 'error';\n\n/**\n * Receives library diagnostics. `message` is already prefixed with `vlam:`;\n * `details` carries any extra values the call site passed.\n */\nexport type VlamLogHandler = (level: VlamLogLevel, message: string, ...details: unknown[]) => void;\n\nconst defaultHandler: VlamLogHandler = (level, message, ...details) => {\n  if (level === 'error') console.error(message, ...details);\n  else console.warn(message, ...details);\n};\n\nlet handler: VlamLogHandler | null = defaultHandler;\n\n/**\n * Redirects (or silences) every diagnostic the library emits.\n *\n * @param next - A handler to receive diagnostics, `null` to drop them\n * silently, or omitted/`undefined` to restore the default console handler.\n *\n * @example\n * setVlamLogHandler((level, message) => myLogger.log(level, message));\n * setVlamLogHandler(null); // silence VLAM! entirely\n */\nexport function setVlamLogHandler(next?: VlamLogHandler | null): void {\n  handler = next === undefined ? defaultHandler : next;\n}\n\n/** Emits a `vlam:`-prefixed warning through the current handler. */\nexport function warn(message: string, ...details: unknown[]): void {\n  handler?.('warn', `vlam: ${message}`, ...details);\n}\n\n/** Emits a `vlam:`-prefixed error through the current handler. */\nexport function logError(message: string, ...details: unknown[]): void {\n  handler?.('error', `vlam: ${message}`, ...details);\n}\n"],"names":["defaultHandler","level","message","details","handler","setVlamLogHandler","next","warn","logError"],"mappings":"AAyBA,MAAMA,IAAiC,CAACC,GAAOC,MAAYC,MAAY;AACrE,EAAIF,MAAU,UAAS,QAAQ,MAAMC,GAAS,GAAGC,CAAO,IACnD,QAAQ,KAAKD,GAAS,GAAGC,CAAO;AACvC;AAEA,IAAIC,IAAiCJ;AAY9B,SAASK,EAAkBC,GAAoC;AACpE,EAAAF,IAAUE,MAAS,SAAYN,IAAiBM;AAClD;AAGO,SAASC,EAAKL,MAAoBC,GAA0B;AACjE,EAAAC,KAAA,QAAAA,EAAU,QAAQ,SAASF,CAAO,IAAI,GAAGC;AAC3C;AAGO,SAASK,EAASN,MAAoBC,GAA0B;AACrE,EAAAC,KAAA,QAAAA,EAAU,SAAS,SAASF,CAAO,IAAI,GAAGC;AAC5C;"}

package/dist/{ply-header-BwgExCn-.js → ply-header-B9WllbPg.js}

@@ -118,8 +118,8 @@ function Y(t, s, o, p) {
 export {
   Y as a,
   $ as b,
-  E as c,
+  P as c,
   L as d,
-  P as p
+  E as p
 };
-//# sourceMappingURL=ply-header-BwgExCn-.js.map
+//# sourceMappingURL=ply-header-B9WllbPg.js.map

package/dist/ply-header-B9WllbPg.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ply-header-B9WllbPg.js","sources":["../src/lib/loaders/ply-header.ts"],"sourcesContent":["/**\n * Shared PLY header reader.\n *\n * PLY is a container, not a format: the same `.ply` extension carries the\n * uncompressed \"INRIA flavor\" 3DGS export (see `parse-splat-ply.ts`) and\n * SuperSplat/PlayCanvas's compressed flavor (`parse-compressed-ply.ts`).\n * Both need the same thing first - the element list, their property layouts,\n * and where each element's records start - so that lives here.\n */\n\n/** Byte size of each scalar type PLY can declare. */\nconst PROPERTY_SIZES: Record<string, number> = {\n  float: 4,\n  float32: 4,\n  double: 8,\n  float64: 8,\n  int: 4,\n  int32: 4,\n  uint: 4,\n  uint32: 4,\n  short: 2,\n  int16: 2,\n  ushort: 2,\n  uint16: 2,\n  char: 1,\n  int8: 1,\n  uchar: 1,\n  uint8: 1,\n};\n\n/** One scalar property of an element. */\nexport interface PlyProperty {\n  readonly type: string;\n  /** Byte offset within one record of the element. */\n  readonly offset: number;\n}\n\n/**\n * One list property (`property list <countType> <itemType> <name>`), such as a\n * mesh's `face` indices. Only the types are recorded - the data is variable-size\n * and must be walked record by record (see `parse-mesh-ply.ts`).\n */\nexport interface PlyListProperty {\n  /** Type of the per-record item count, e.g. `uchar`. */\n  readonly countType: string;\n  /** Type of each item, e.g. `int`. */\n  readonly itemType: string;\n}\n\n/** One PLY element (`element <name> <count>`) and its record layout. */\nexport interface PlyElement {\n  readonly name: string;\n  readonly count: number;\n  readonly properties: ReadonlyMap<string, PlyProperty>;\n  /** Property names in declaration order. */\n  readonly propertyNames: readonly string[];\n  /** List properties by name; empty unless {@link hasListProperty}. */\n  readonly listProperties: ReadonlyMap<string, PlyListProperty>;\n  /**\n   * Bytes per record - meaningless when {@link hasListProperty}, since a list\n   * makes each record's size depend on its contents.\n   */\n  readonly stride: number;\n  /**\n   * Byte offset of this element's first record within the file, or -1 when a\n   * preceding element has a variable-size record and no arithmetic can find it.\n   */\n  readonly offset: number;\n  /** A list property makes this element's records variable-size. */\n  readonly hasListProperty: boolean;\n}\n\n/** A parsed PLY header. */\nexport interface PlyHeader {\n  readonly elements: readonly PlyElement[];\n  /** The element of that name, or undefined. */\n  element(name: string): PlyElement | undefined;\n}\n\n/**\n * Reads a binary little-endian PLY header and resolves every element's byte\n * offset by walking the elements in declaration order.\n *\n * Whether the declared records actually fit in the buffer is deliberately not\n * checked here - call {@link assertPlyElementFits} once the caller has\n * validated the properties it needs, so a wrong property type is reported as\n * such rather than as the truncation it happens to imply.\n *\n * @throws {Error} if the file is not a binary little-endian PLY, or declares a\n * property type this reader cannot size.\n */\nexport function parsePlyHeader(buffer: ArrayBuffer): PlyHeader {\n  const headerBytes = new Uint8Array(buffer, 0, Math.min(buffer.byteLength, 64 * 1024));\n  const headerText = new TextDecoder('ascii').decode(headerBytes);\n  const endMatch = /end_header\\r?\\n/.exec(headerText);\n  if (!/^ply\\r?\\n/.test(headerText)) {\n    throw new Error('Not a PLY file (missing \"ply\" magic).');\n  }\n  if (!endMatch) {\n    throw new Error(\n      'Unsupported PLY file: no \"end_header\" within the first 64 KiB - the header exceeds the ' +\n        'supported window, or the file is truncated.',\n    );\n  }\n  if (!headerText.includes('format binary_little_endian 1.0')) {\n    throw new Error('Unsupported PLY format; expected binary_little_endian 1.0.');\n  }\n\n  interface Building {\n    name: string;\n    count: number;\n    properties: Map<string, PlyProperty>;\n    propertyNames: string[];\n    listProperties: Map<string, PlyListProperty>;\n    stride: number;\n    hasListProperty: boolean;\n  }\n  const building: Building[] = [];\n\n  for (const line of headerText.slice(0, endMatch.index).split('\\n')) {\n    const tokens = line.trim().split(/\\s+/);\n    if (tokens[0] === 'element') {\n      const name = tokens[1];\n      const count = Number(tokens[2]);\n      if (name === undefined) throw new Error(`Malformed PLY element: \"${line.trim()}\"`);\n      if (!Number.isSafeInteger(count) || count < 0) {\n        throw new Error(`Invalid PLY ${name} count: ${tokens[2]}.`);\n      }\n      building.push({\n        name,\n        count,\n        properties: new Map(),\n        propertyNames: [],\n        listProperties: new Map(),\n        stride: 0,\n        hasListProperty: false,\n      });\n    } else if (tokens[0] === 'property') {\n      const element = building[building.length - 1];\n      if (!element) throw new Error(`PLY property declared before any element: \"${line.trim()}\"`);\n      if (tokens[1] === 'list') {\n        // A list makes this element's records variable-size. That is fine for\n        // the element itself (a trailing `face` list is common) - it only\n        // costs later elements their computable offset. The types are recorded\n        // so a reader that does want the data can walk it record by record.\n        const countType = tokens[2] ?? '';\n        const itemType = tokens[3] ?? '';\n        const listName = tokens[4];\n        if (\n          PROPERTY_SIZES[countType] === undefined ||\n          PROPERTY_SIZES[itemType] === undefined ||\n          listName === undefined\n        ) {\n          throw new Error(`Unsupported PLY property: \"${line.trim()}\"`);\n        }\n        if (element.properties.has(listName) || element.listProperties.has(listName)) {\n          throw new Error(`Duplicate PLY property \"${listName}\" in element \"${element.name}\".`);\n        }\n        element.listProperties.set(listName, { countType, itemType });\n        element.hasListProperty = true;\n        continue;\n      }\n      const type = tokens[1] ?? '';\n      const size = PROPERTY_SIZES[type];\n      const name = tokens[2];\n      if (size === undefined || name === undefined) {\n        throw new Error(`Unsupported PLY property: \"${line.trim()}\"`);\n      }\n      if (element.properties.has(name) || element.listProperties.has(name)) {\n        // A duplicate name would let the later offset overwrite the earlier\n        // one while the stride counts both - every read after it lands on\n        // the wrong bytes.\n        throw new Error(`Duplicate PLY property \"${name}\" in element \"${element.name}\".`);\n      }\n      element.properties.set(name, { type, offset: element.stride });\n      element.propertyNames.push(name);\n      element.stride += size;\n    }\n  }\n\n  // Records are laid out back to back in element order, starting right after\n  // the header - so each element begins where the previous one ended, until a\n  // variable-size element makes the rest unreachable by arithmetic.\n  let offset = endMatch.index + endMatch[0].length;\n  let resolved = true;\n  const elements: PlyElement[] = [];\n  for (const element of building) {\n    elements.push({\n      name: element.name,\n      count: element.count,\n      properties: element.properties,\n      propertyNames: element.propertyNames,\n      listProperties: element.listProperties,\n      stride: element.stride,\n      offset: resolved ? offset : -1,\n      hasListProperty: element.hasListProperty,\n    });\n    if (element.hasListProperty) resolved = false;\n    else offset += element.count * element.stride;\n  }\n\n  return {\n    elements,\n    element: (name: string) => elements.find((candidate) => candidate.name === name),\n  };\n}\n\n/**\n * Asserts an element's records are actually present in a file of `totalBytes`.\n *\n * Takes a size rather than a buffer so it works for a streamed parse, which\n * only ever holds a window of the file.\n *\n * @throws {Error} if the element sits behind a variable-size one, or its\n * records run past the end of the file.\n */\nexport function assertPlyElementFits(element: PlyElement, totalBytes: number): void {\n  if (element.offset < 0) {\n    throw new Error(\n      `Unsupported PLY layout: element \"${element.name}\" follows a list property, so its ` +\n        'position cannot be determined.',\n    );\n  }\n  const end = element.offset + element.count * element.stride;\n  if (end > totalBytes) {\n    throw new Error(\n      `Truncated PLY file: element \"${element.name}\" needs ${end} bytes but the file is ` +\n        `${totalBytes}.`,\n    );\n  }\n}\n\n/**\n * Byte size of a PLY scalar type.\n *\n * @throws {Error} if the type is not one PLY can declare.\n */\nexport function plyTypeSize(type: string): number {\n  const size = PROPERTY_SIZES[type];\n  if (size === undefined) throw new Error(`Unsupported PLY property type: \"${type}\".`);\n  return size;\n}\n\n/** The byte offset of `property` within `element`'s record. */\nexport function plyPropertyOffset(element: PlyElement, property: string): number {\n  const found = element.properties.get(property);\n  if (!found) {\n    throw new Error(`PLY element \"${element.name}\" is missing property \"${property}\".`);\n  }\n  return found.offset;\n}\n\n/** Asserts every named property exists on `element` with the given type. */\nexport function assertPlyPropertyTypes(\n  element: PlyElement,\n  properties: readonly string[],\n  types: readonly string[],\n  what: string,\n): void {\n  for (const name of properties) {\n    const property = element.properties.get(name);\n    if (!property) {\n      throw new Error(`${what}: missing property \"${name}\".`);\n    }\n    if (!types.includes(property.type)) {\n      throw new Error(\n        `Unsupported PLY property type for \"${name}\": expected ${types.join(' or ')}, ` +\n          `got ${property.type}.`,\n      );\n    }\n  }\n}\n"],"names":["PROPERTY_SIZES","parsePlyHeader","buffer","headerBytes","headerText","endMatch","building","line","tokens","name","count","element","countType","itemType","listName","type","size","offset","resolved","elements","candidate","assertPlyElementFits","totalBytes","end","plyTypeSize","plyPropertyOffset","property","found","assertPlyPropertyTypes","properties","types","what"],"mappings":"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"}