@voluma/vlam 0.2.3 → 0.3.0

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/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/lod-scheduler.d.ts

@@ -205,7 +205,7 @@ export declare class LodScheduler implements LodSource {
      * 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.

package/dist/lod-source.d.ts

@@ -106,7 +106,7 @@ export interface CollisionMeshDescriptor {
  * Coordinates are source-local, the same frame as {@link StreamedScene.bounds}:
  * {@link StreamedScene.formatTransform} maps them to world.
  */
-export interface SceneCollision {
+export interface SplatCollisionData {
     readonly meshes: readonly CollisionMeshDescriptor[];
 }
 /**
@@ -155,7 +155,7 @@ export interface StreamedScene {
      */
     readonly formatTransform?: THREE.Matrix4;
     /** Optional collision geometry the format ships; undefined when it has none. */
-    readonly collision?: SceneCollision;
+    readonly collision?: SplatCollisionData;
     /**
      * Optional always-resident environment tile the format ships outside its LOD
      * structure (the `.lcc2` sky) - present only when the dataset carries one.
@@ -175,13 +175,13 @@ export interface StreamedScene {
     /**
      * Splats per chunk file, so a `(file, localIndex)` pair maps to a stable global
      * splat index (`file * chunkSize + local`). Set by `.rad`; the page-table
-     * renderer (`foveationMode: 'pagetable'`) keys frontier splats by that global.
+     * renderer (`foveationMode: 'page-table'`) keys frontier splats by that global.
      */
     readonly chunkSize?: number;
     /**
      * A chunk the scene builder already fetched and decoded (`.rad` decodes chunk
      * 0 for the scene bounds and the SH codebook). Handing it straight to the
-     * renderer saves a second round trip - and in `pagetable` mode it is what
+     * renderer saves a second round trip - and in `page-table` mode it is what
      * seeds the worker's tree roots, without which the first traversals return an
      * empty frontier and the view stays blank until chunk 0 arrives a second time.
      */
@@ -191,7 +191,7 @@ export interface StreamedScene {
     };
     /**
      * Source-local xyz subsample of the coarsest overview (`.rad` chunk 0).
-     * Survives after pagetable mode transfers chunk-0 buffers to the worker, so
+     * Survives after page-table mode transfers chunk-0 buffers to the worker, so
      * a host can estimate terrain height before any later chunk decodes.
      */
     readonly overviewPositions?: Float32Array;