@voluma/vlam 0.3.2 → 0.3.4

package/dist/lod-scheduler-ChoZyEeq.js

@@ -0,0 +1,466 @@
+var y = Object.defineProperty;
+var G = (F, e, i) => e in F ? y(F, e, { enumerable: !0, configurable: !0, writable: !0, value: i }) : F[e] = i;
+var d = (F, e, i) => G(F, typeof e != "symbol" ? e + "" : e, i);
+import * as A from "three/webgpu";
+function M(F) {
+  return `${F.file}:${F.level}:${F.offset}:${F.count}`;
+}
+const I = -1, P = 128e3, S = 0.1, w = 500, N = 0.1, B = 3;
+class R {
+  constructor(e, i) {
+    /** World-unit distance inside which the finest level (0) is used. */
+    d(this, "lodBaseDistance");
+    /** Distance ratio between successive LOD levels. */
+    d(this, "lodMultiplier");
+    /** Maximum active splats; the desired set is demoted to fit. */
+    d(this, "budget");
+    d(this, "leaves");
+    d(this, "coarsest");
+    /** Per leaf: lowest/highest LOD level that has data. */
+    d(this, "minLevel");
+    d(this, "maxLevel");
+    /**
+     * Per leaf: the distance *ambition* - the finest level the camera distance
+     * asks for, with hysteresis/dwell applied. This is the hysteresis *state*:
+     * only {@link selectLevels} writes it, so budget demotion can never feed
+     * back into the dead-band/dwell logic and oscillate. With `fillPastDistance`
+     * false, {@link fillBudget} restores {@link resolved} only up to here.
+     */
+    d(this, "level");
+    /**
+     * Per leaf: the resolved target - the ambition capped to fit the budget by
+     * {@link enforceBudget}, then refilled from leftover headroom by
+     * {@link fillBudget} (or DROPPED). This is what {@link coalesceRuns} emits.
+     */
+    d(this, "resolved");
+    /** Per leaf: timestamp of the last distance-level change, for dwell. */
+    d(this, "changedAt");
+    d(this, "distance");
+    d(this, "inFrustum");
+    /** Leaves that must move through the budget cut together. */
+    d(this, "budgetGroups");
+    /** Per-leaf physical coverage group, when the manifest defines one. */
+    d(this, "coverageGroups");
+    /** Whether view-frustum membership affects distance and fill priority. */
+    d(this, "frustumAware");
+    /** Fraction of the usable budget that optional refinement may consume. */
+    d(this, "budgetFillFraction");
+    /** Absolute cap on optional refinement; distance-selected detail may exceed it. */
+    d(this, "budgetFillCap");
+    /** Whether a budget that holds every finest leaf forces a full-finest cut. */
+    d(this, "forceFinestWhenFits");
+    /**
+     * Leaves at or inside this camera distance always resolve to their finest
+     * available level (no hysteresis climb). Classic LCC uses a multi-band
+     * radius so adjacent broad cells do not paint coarse discs at startup.
+     */
+    d(this, "forceFinestWithin");
+    /**
+     * When false, {@link fillBudget} only restores toward each leaf's
+     * distance-selected {@link level} - never finer. Classic LCC sets this so
+     * a mid-range cell does not fetch L0 only to demote to L1 once the cut
+     * settles.
+     */
+    d(this, "fillPastDistance");
+    /**
+     * What the last cut actually decided, for the HUD.
+     *
+     * The resident splat count alone cannot distinguish "the scheduler asked for
+     * this" from "the scheduler asked for more and the mesh could not apply it",
+     * and those have opposite fixes. Measured rather than inferred after a
+     * zoomed-out `sandwijck` sat at exactly its coarsest total (190,730) with a
+     * 600k budget - 68% of the budget unspent, with no way to see which stage
+     * declined to spend it.
+     */
+    d(this, "stats", {
+      /** Leaves the frustum test accepted - `fillBudget`'s candidate set. */
+      inFrustum: 0,
+      /** Total leaves in the tree. */
+      leaves: 0,
+      /** Splats implied by the resolved cut, before the mesh applies anything. */
+      desired: 0,
+      /** Splats `fillBudget` added on top of the distance-chosen levels. */
+      filled: 0
+    });
+    d(this, "scratchBox", new A.Box3());
+    d(this, "scratchSize", new A.Vector3());
+    d(this, "scratchCenter", new A.Vector3());
+    d(this, "screenImportance");
+    /** Whether the last selection pass received a camera-forward vector. */
+    d(this, "hasScreenImportance", !1);
+    /**
+     * Persistent leaf-index ordering scratch for {@link enforceBudget} and
+     * {@link fillBudget}, sorted in place per call instead of allocating a
+     * fresh `[...keys]` array. Comparators break ties on the index itself so
+     * the order is identical to the stable `Array#sort` this replaces
+     * (`TypedArray#sort` stability is not guaranteed).
+     */
+    d(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)
+      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 n = [], a = /* @__PURE__ */ new Map();
+    for (let l = 0; l < s; l++) {
+      const o = this.leaves[l].budgetGroup;
+      if (o === void 0) {
+        n.push([l]);
+        continue;
+      }
+      let t = a.get(o);
+      t === void 0 && (t = n.length, a.set(o, t), n.push([])), n[t].push(l), this.coverageGroups[l] = o;
+    }
+    this.budgetGroups = n.map((l) => Uint32Array.from(l));
+    for (let l = 0; l < s; l++) {
+      const o = this.leaves[l].lods;
+      let t = this.coarsest, u = 0;
+      for (let r = 0; r < o.length; r++)
+        o[r] !== void 0 && (t = Math.min(t, r), u = Math.max(u, r));
+      this.minLevel[l] = t, this.maxLevel[l] = u, this.level[l] = u;
+    }
+  }
+  /**
+   * Recomputes the desired resident run set for the current camera.
+   *
+   * @param cameraLocal - Camera position in the mesh's local space.
+   * @param frustum - View frustum in the mesh's local space.
+   * @param now - Monotonic timestamp (ms) for dwell hysteresis.
+   */
+  computeDesiredRuns(e, i, s, n) {
+    if (this.selectLevels(e, i, s, n), this.forceFinestWhenFits && this.budget >= this.finestTotal()) {
+      for (let l = 0; l < this.leaves.length; l++)
+        this.resolved[l] = this.minLevel[l];
+      return this.stats.desired = this.activeTotal(), this.stats.filled = 0, this.coalesceRuns();
+    }
+    this.resolved.set(this.level), this.enforceBudget();
+    const a = this.activeTotal();
+    return this.fillBudget(), this.stats.desired = this.activeTotal(), this.stats.filled = this.stats.desired - a, 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 n = this.resolved[s];
+      n !== I && (e += ((i = this.leaves[s].lods[n]) == null ? void 0 : i.count) ?? 0);
+    }
+    return e;
+  }
+  /** 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 n = this.minLevel[s];
+      e += ((i = this.leaves[s].lods[n]) == null ? void 0 : i.count) ?? 0;
+    }
+    return e;
+  }
+  selectLevels(e, i, s, n) {
+    const { lodBaseDistance: a, lodMultiplier: l } = this;
+    this.hasScreenImportance = n !== void 0;
+    let o = 0;
+    this.stats.leaves = this.leaves.length;
+    for (let t = 0; t < this.leaves.length; t++) {
+      const u = this.leaves[t], r = u.bounds.distanceToPoint(e);
+      this.distance[t] = r;
+      const h = this.leafIntersectsFrustum(i, t);
+      if (this.inFrustum[t] = h ? 1 : 0, h && o++, n)
+        if (!(r === 0 || this.boxPokesForward(u.bounds, e, n)))
+          this.screenImportance[t] = Number.POSITIVE_INFINITY;
+        else if (r <= this.lodBaseDistance)
+          this.screenImportance[t] = -1 + r / (this.lodBaseDistance + 1);
+        else {
+          u.bounds.clampPoint(e, this.scratchCenter).sub(e);
+          const b = this.scratchCenter.dot(n), p = Math.max(0, this.scratchCenter.lengthSq() - b * b);
+          this.screenImportance[t] = b > 0 ? Math.sqrt(p) / Math.max(b, 0.25) : Number.POSITIVE_INFINITY;
+        }
+      else
+        this.screenImportance[t] = 0;
+      const c = this.level[t];
+      if (this.fillPastDistance && this.forceFinestWithin !== void 0 && r <= this.forceFinestWithin) {
+        const m = this.minLevel[t];
+        c !== m && (this.level[t] = m, this.changedAt[t] = s);
+        continue;
+      }
+      const f = !this.frustumAware || h ? r : r * B;
+      if (!this.fillPastDistance) {
+        const m = this.distanceBandLevel(t, f, a, l);
+        if (this.changedAt[t] === 0 && c === this.maxLevel[t]) {
+          m !== c && (this.level[t] = m, this.changedAt[t] = s);
+          continue;
+        }
+        if (m === c) continue;
+        const p = this.hysteresisLevel(t, f, a, l, c);
+        if (p === c) continue;
+        (p > c || s - this.changedAt[t] >= w) && (this.level[t] = p, this.changedAt[t] = s);
+        continue;
+      }
+      const g = this.hysteresisLevel(t, f, a, l, c);
+      if (g === c) continue;
+      (this.changedAt[t] === 0 && c === this.maxLevel[t] || s - this.changedAt[t] >= w) && (this.level[t] = g, this.changedAt[t] = s);
+    }
+    this.stats.inFrustum = o;
+  }
+  /**
+   * 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, n) {
+    const a = this.minLevel[e], l = this.maxLevel[e];
+    let o = a;
+    for (; o < l && i > s * n ** o * (1 + S); ) o++;
+    return this.resolveAvailable(e, o);
+  }
+  /**
+   * 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, n, a) {
+    const l = this.minLevel[e], o = this.maxLevel[e];
+    let t = Math.min(o, Math.max(l, a));
+    for (; t < o && i > s * n ** t * (1 + S); ) t++;
+    for (; t > l && i <= s * n ** (t - 1) * (1 - S); ) t--;
+    return this.resolveAvailable(e, t);
+  }
+  resolveAvailable(e, i) {
+    const s = this.leaves[e].lods;
+    for (let n = i; n <= this.maxLevel[e]; n++) if (s[n]) return n;
+    for (let n = i - 1; n >= this.minLevel[e]; n--) if (s[n]) return n;
+    return this.maxLevel[e];
+  }
+  /** Demotes/drops lowest-priority leaves until the total fits the budget. */
+  enforceBudget() {
+    var s, n, a;
+    let e = this.activeTotal();
+    if (e <= this.budget) return;
+    const i = this.orderScratch.subarray(0, this.budgetGroups.length);
+    for (let l = 0; l < i.length; l++) i[l] = l;
+    i.sort((l, o) => {
+      const t = this.budgetGroups[l][0], u = this.budgetGroups[o][0];
+      if (this.frustumAware) {
+        const r = this.inFrustum[t], h = this.inFrustum[u];
+        if (r !== h) return r - h;
+      }
+      return this.distance[u] - this.distance[t] || t - u;
+    });
+    for (const l of i) {
+      const o = this.budgetGroups[l];
+      for (; e > this.budget; ) {
+        let t = 0, u = !1;
+        for (const r of o) {
+          const h = this.resolved[r];
+          if (h >= this.maxLevel[r]) continue;
+          const c = this.leaves[r].lods, f = this.resolveAvailable(r, h + 1);
+          f !== h && (t += (((s = c[h]) == null ? void 0 : s.count) ?? 0) - (((n = c[f]) == null ? void 0 : n.count) ?? 0), this.resolved[r] = f, u = !0);
+        }
+        if (!u) break;
+        e -= t;
+      }
+      if (e <= this.budget) return;
+    }
+    for (const l of i) {
+      if (e <= this.budget) return;
+      for (const o of this.budgetGroups[l])
+        this.resolved[o] !== I && (e -= ((a = this.leaves[o].lods[this.resolved[o]]) == null ? void 0 : a.count) ?? 0, this.resolved[o] = I);
+    }
+  }
+  /**
+   * 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 / 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 a, l;
+    const e = 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;
+    for (let o = 0; o < this.budgetGroups.length; o++) {
+      const t = this.budgetGroups[o][0];
+      (!this.frustumAware || this.inFrustum[t] === 1) && this.resolved[t] !== I && (this.orderScratch[s++] = o);
+    }
+    const n = this.orderScratch.subarray(0, s);
+    n.sort((o, t) => {
+      const u = this.budgetGroups[o][0], r = this.budgetGroups[t][0];
+      return this.distance[u] - this.distance[r] || u - r;
+    });
+    for (const o of n) {
+      const t = this.budgetGroups[o];
+      for (; ; ) {
+        let u = 0, r = !1;
+        for (const h of t) {
+          const c = this.resolved[h], f = this.fillPastDistance ? this.minLevel[h] : this.level[h];
+          if (c <= f) continue;
+          const g = this.leaves[h];
+          let v = c - 1;
+          for (; v > f && !g.lods[v]; ) v--;
+          v < f || !g.lods[v] || (u += (((a = g.lods[v]) == null ? void 0 : a.count) ?? 0) - (((l = g.lods[c]) == null ? void 0 : l.count) ?? 0), r = !0);
+        }
+        if (!r || i + u > e) break;
+        for (const h of t) {
+          const c = this.resolved[h], f = this.fillPastDistance ? this.minLevel[h] : this.level[h];
+          if (c <= f) continue;
+          const g = this.leaves[h];
+          let v = c - 1;
+          for (; v > f && !g.lods[v]; ) v--;
+          v >= f && g.lods[v] && (this.resolved[h] = v);
+        }
+        i += u;
+      }
+    }
+  }
+  coalesceRuns() {
+    return this.buildRuns(0, this.leaves.length, (e) => this.resolved[e]);
+  }
+  /**
+   * 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]);
+  }
+  /**
+   * Covering runs for physical coverage groups currently in the camera frustum
+   * (or containing the camera). Classic LCC cells that split into sub-leaves
+   * share a group, so one in-view slice holds the whole cell. Leaves without a
+   * coverage group (Streamed SOG, the environment tile) are ignored. An empty
+   * frustum falls back to the nearest group so a skyward start still paints
+   * something.
+   *
+   * Classic cells tile X/Y and span the full scene Z. An AABB frustum test
+   * (especially with {@link FRUSTUM_MARGIN} on that diagonal) then hits the
+   * whole grid from any indoor pose. Unpadded intersection plus an AABB vs
+   * forward half-space test (support vertex along `cameraForward`) keeps the
+   * hold to cells that poke in front of the camera, including a neighbour
+   * whose centre sits behind the look. Cells within `lodBaseDistance` that
+   * poke forward are held even when the unpadded frustum misses — a 30 m
+   * PentHouse column 5 m away can fill the frame while the look is 60° off
+   * its face.
+   *
+   * Nearby groups (`distance ≤ lodBaseDistance · lodMultiplier`) freeze at
+   * finest+1 (L1 when L0 exists). Farther in-view groups freeze at coarsest.
+   * Startup never waits for L0.
+   */
+  coverageRunsFor(e, i, s) {
+    const n = this.leaves.length, a = /* @__PURE__ */ new Set();
+    let l = -1, o = Number.POSITIVE_INFINITY;
+    for (let h = 0; h < n; h++) {
+      const c = this.coverageGroups[h];
+      if (c < 0) continue;
+      const f = this.leaves[h], g = f.bounds.distanceToPoint(e);
+      if (g < o && (o = g, l = h), g === 0) {
+        a.add(c);
+        continue;
+      }
+      !(g <= this.lodBaseDistance) && !i.intersectsBox(f.bounds) || s && !this.boxPokesForward(f.bounds, e, s) || a.add(c);
+    }
+    if (a.size === 0) {
+      if (l < 0) return [];
+      a.add(this.coverageGroups[l]);
+    }
+    const t = this.lodBaseDistance * this.lodMultiplier, u = [];
+    let r = 0;
+    for (; r < n; ) {
+      const h = this.coverageGroups[r];
+      if (h < 0 || !a.has(h)) {
+        r++;
+        continue;
+      }
+      let c = r + 1;
+      for (; c < n && this.coverageGroups[c] === h; ) c++;
+      let f = Number.POSITIVE_INFINITY, g = this.minLevel[r];
+      for (let v = r; v < c; v++) {
+        const m = this.leaves[v].bounds.distanceToPoint(e);
+        m < f && (f = m);
+        const b = this.minLevel[v];
+        b < g && (g = b);
+      }
+      f <= t ? u.push(...this.runsAtLevelFor(r, c, g + 1)) : u.push(...this.coarsestRunsFor(r, c)), r = c;
+    }
+    return u;
+  }
+  /**
+   * True when any point of `box` sits strictly in front of the camera plane
+   * (`origin` + `forward`). Uses the AABB support vertex along `forward`, so a
+   * cell that straddles the camera still counts if it pokes into the view.
+   */
+  boxPokesForward(e, i, s) {
+    const n = s.x >= 0 ? e.max.x : e.min.x, a = s.y >= 0 ? e.max.y : e.min.y, l = s.z >= 0 ? e.max.z : e.min.z;
+    return (n - i.x) * s.x + (a - i.y) * s.y + (l - i.z) * s.z > 0;
+  }
+  /** Leaf AABB expanded by {@link FRUSTUM_MARGIN}, written into scratch. */
+  expandLeafBox(e) {
+    const i = this.leaves[e];
+    return this.scratchBox.copy(i.bounds), i.bounds.getSize(this.scratchSize), this.scratchBox.expandByScalar(this.scratchSize.length() * N), this.scratchBox;
+  }
+  leafIntersectsFrustum(e, i) {
+    return e.intersectsBox(this.expandLeafBox(i));
+  }
+  /**
+   * 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 n = Math.floor(s);
+    return this.buildRuns(e, i, (a) => this.clampLeafLevel(a, n));
+  }
+  /** 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 n = i + 1; n < s.lods.length; n++)
+      if (s.lods[n]) return n;
+    for (let n = i - 1; n >= 0; n--)
+      if (s.lods[n]) return n;
+    return I;
+  }
+  /** Coalesces leaves [from, to) at `levelOf(leaf)` into contiguous runs. */
+  buildRuns(e, i, s) {
+    const n = [];
+    let a = -1, l = -1, o = 0, t = 0, u = -1, r = -1, h = -1, c = Number.POSITIVE_INFINITY, f = !1, g = Number.POSITIVE_INFINITY;
+    const v = () => {
+      t > 0 && n.push({
+        file: a,
+        level: l,
+        offset: o,
+        count: t,
+        leafStart: u,
+        leafEnd: r,
+        distance: c,
+        inView: f,
+        ...this.hasScreenImportance ? { screenImportance: g } : {},
+        ...h >= 0 ? { coverageGroup: h } : {}
+      }), t = 0;
+    };
+    for (let m = e; m < i; m++) {
+      const b = s(m);
+      if (b === I) {
+        v();
+        continue;
+      }
+      const p = this.leaves[m].lods[b];
+      if (!p) {
+        v();
+        continue;
+      }
+      const L = this.coverageGroups[m], x = this.distance[m], T = this.inFrustum[m] === 1;
+      t > 0 && p.file === a && b === l && L === h && p.offset === o + t && t + p.count <= P ? (t += p.count, r = m + 1, x < c && (c = x), T && (f = !0), g = Math.min(g, this.screenImportance[m])) : (v(), a = p.file, l = b, o = p.offset, t = p.count, u = m, r = m + 1, h = L, c = x, f = T, g = this.screenImportance[m]);
+    }
+    return v(), n;
+  }
+}
+export {
+  R as L,
+  M as r
+};
+//# sourceMappingURL=lod-scheduler-ChoZyEeq.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"lod-scheduler-ChoZyEeq.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      const visible = this.leafIntersectsFrustum(frustum, i);\n      this.inFrustum[i] = visible ? 1 : 0;\n      if (visible) visibleCount++;\n\n      // Fetch-only. Distance still chooses LOD. Near-band cells (inside\n      // lodBaseDistance and in front) rank by distance so a 30 m neighbour\n      // 5 m away is not starved by a far cell whose centre sits on the look\n      // axis. Farther cells keep the closest-point angular metric.\n      if (cameraForward) {\n        const inFront = d === 0 || this.boxPokesForward(leaf.bounds, cameraLocal, cameraForward);\n        if (!inFront) {\n          this.screenImportance[i] = Number.POSITIVE_INFINITY;\n        } else if (d <= this.lodBaseDistance) {\n          this.screenImportance[i] = -1 + d / (this.lodBaseDistance + 1);\n        } else {\n          leaf.bounds.clampPoint(cameraLocal, 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\n              ? Math.sqrt(lateralSquared) / Math.max(depth, 0.25)\n              : Number.POSITIVE_INFINITY;\n        }\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   * Covering runs for physical coverage groups currently in the camera frustum\n   * (or containing the camera). Classic LCC cells that split into sub-leaves\n   * share a group, so one in-view slice holds the whole cell. Leaves without a\n   * coverage group (Streamed SOG, the environment tile) are ignored. An empty\n   * frustum falls back to the nearest group so a skyward start still paints\n   * something.\n   *\n   * Classic cells tile X/Y and span the full scene Z. An AABB frustum test\n   * (especially with {@link FRUSTUM_MARGIN} on that diagonal) then hits the\n   * whole grid from any indoor pose. Unpadded intersection plus an AABB vs\n   * forward half-space test (support vertex along `cameraForward`) keeps the\n   * hold to cells that poke in front of the camera, including a neighbour\n   * whose centre sits behind the look. Cells within `lodBaseDistance` that\n   * poke forward are held even when the unpadded frustum misses — a 30 m\n   * PentHouse column 5 m away can fill the frame while the look is 60° off\n   * its face.\n   *\n   * Nearby groups (`distance ≤ lodBaseDistance · lodMultiplier`) freeze at\n   * finest+1 (L1 when L0 exists). Farther in-view groups freeze at coarsest.\n   * Startup never waits for L0.\n   */\n  coverageRunsFor(\n    cameraLocal: THREE.Vector3,\n    frustum: THREE.Frustum,\n    cameraForward?: THREE.Vector3,\n  ): LodRun[] {\n    const n = this.leaves.length;\n    const picked = new Set<number>();\n    let nearestLeaf = -1;\n    let nearestDist = Number.POSITIVE_INFINITY;\n    for (let i = 0; i < n; i++) {\n      const group = this.coverageGroups[i] as number;\n      if (group < 0) continue;\n      const leaf = this.leaves[i] as LodLeaf;\n      const d = leaf.bounds.distanceToPoint(cameraLocal);\n      if (d < nearestDist) {\n        nearestDist = d;\n        nearestLeaf = i;\n      }\n      // Camera-inside is load-bearing: HiRes tiles often fail the frustum test\n      // when most of the cell sits behind the camera looking out.\n      if (d === 0) {\n        picked.add(group);\n        continue;\n      }\n      // 30 m classic cells: the camera can stand 5 m from a neighbour that\n      // fills the frame while the unpadded frustum misses the AABB (look 60°+\n      // off the face). Still hold that neighbour when it pokes forward.\n      const near = d <= this.lodBaseDistance;\n      if (!near && !frustum.intersectsBox(leaf.bounds)) continue;\n      if (cameraForward && !this.boxPokesForward(leaf.bounds, cameraLocal, cameraForward)) {\n        continue;\n      }\n      picked.add(group);\n    }\n    if (picked.size === 0) {\n      if (nearestLeaf < 0) return [];\n      picked.add(this.coverageGroups[nearestLeaf] as number);\n    }\n    const nearHorizon = this.lodBaseDistance * this.lodMultiplier;\n    const runs: LodRun[] = [];\n    let i = 0;\n    while (i < n) {\n      const group = this.coverageGroups[i] as number;\n      if (group < 0 || !picked.has(group)) {\n        i++;\n        continue;\n      }\n      let end = i + 1;\n      while (end < n && (this.coverageGroups[end] as number) === group) end++;\n      let groupDist = Number.POSITIVE_INFINITY;\n      let groupFinest = this.minLevel[i] as number;\n      for (let j = i; j < end; j++) {\n        const d = (this.leaves[j] as LodLeaf).bounds.distanceToPoint(cameraLocal);\n        if (d < groupDist) groupDist = d;\n        const finest = this.minLevel[j] as number;\n        if (finest < groupFinest) groupFinest = finest;\n      }\n      if (groupDist <= nearHorizon) {\n        runs.push(...this.runsAtLevelFor(i, end, groupFinest + 1));\n      } else {\n        runs.push(...this.coarsestRunsFor(i, end));\n      }\n      i = end;\n    }\n    return runs;\n  }\n\n  /**\n   * True when any point of `box` sits strictly in front of the camera plane\n   * (`origin` + `forward`). Uses the AABB support vertex along `forward`, so a\n   * cell that straddles the camera still counts if it pokes into the view.\n   */\n  private boxPokesForward(box: THREE.Box3, origin: THREE.Vector3, forward: THREE.Vector3): boolean {\n    const x = forward.x >= 0 ? box.max.x : box.min.x;\n    const y = forward.y >= 0 ? box.max.y : box.min.y;\n    const z = forward.z >= 0 ? box.max.z : box.min.z;\n    return (x - origin.x) * forward.x + (y - origin.y) * forward.y + (z - origin.z) * forward.z > 0;\n  }\n\n  /** Leaf AABB expanded by {@link FRUSTUM_MARGIN}, written into scratch. */\n  private expandLeafBox(index: number): THREE.Box3 {\n    const leaf = this.leaves[index] as LodLeaf;\n    this.scratchBox.copy(leaf.bounds);\n    leaf.bounds.getSize(this.scratchSize);\n    this.scratchBox.expandByScalar(this.scratchSize.length() * FRUSTUM_MARGIN);\n    return this.scratchBox;\n  }\n\n  private leafIntersectsFrustum(frustum: THREE.Frustum, index: number): boolean {\n    return frustum.intersectsBox(this.expandLeafBox(index));\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","picked","nearestLeaf","nearestDist","nearHorizon","runs","end","groupDist","groupFinest","j","box","origin","forward","x","y","z","wanted","leafIndex","levelOf","file","offset","count","leafStart","leafEnd","coverageGroup","distance","inView","screenImportance","flush","range","leafCoverageGroup","leafDistance","leafInView"],"mappings":"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"}

package/dist/streaming/lod-scheduler.d.ts

@@ -217,6 +217,38 @@ export declare class LodScheduler implements LodSource {
      * to substitute always-cached coverage while a finer level is fetching.
      */
     coarsestRunsFor(from: number, to: number): LodRun[];
+    /**
+     * Covering runs for physical coverage groups currently in the camera frustum
+     * (or containing the camera). Classic LCC cells that split into sub-leaves
+     * share a group, so one in-view slice holds the whole cell. Leaves without a
+     * coverage group (Streamed SOG, the environment tile) are ignored. An empty
+     * frustum falls back to the nearest group so a skyward start still paints
+     * something.
+     *
+     * Classic cells tile X/Y and span the full scene Z. An AABB frustum test
+     * (especially with {@link FRUSTUM_MARGIN} on that diagonal) then hits the
+     * whole grid from any indoor pose. Unpadded intersection plus an AABB vs
+     * forward half-space test (support vertex along `cameraForward`) keeps the
+     * hold to cells that poke in front of the camera, including a neighbour
+     * whose centre sits behind the look. Cells within `lodBaseDistance` that
+     * poke forward are held even when the unpadded frustum misses — a 30 m
+     * PentHouse column 5 m away can fill the frame while the look is 60° off
+     * its face.
+     *
+     * Nearby groups (`distance ≤ lodBaseDistance · lodMultiplier`) freeze at
+     * finest+1 (L1 when L0 exists). Farther in-view groups freeze at coarsest.
+     * Startup never waits for L0.
+     */
+    coverageRunsFor(cameraLocal: THREE.Vector3, frustum: THREE.Frustum, cameraForward?: THREE.Vector3): LodRun[];
+    /**
+     * True when any point of `box` sits strictly in front of the camera plane
+     * (`origin` + `forward`). Uses the AABB support vertex along `forward`, so a
+     * cell that straddles the camera still counts if it pokes into the view.
+     */
+    private boxPokesForward;
+    /** Leaf AABB expanded by {@link FRUSTUM_MARGIN}, written into scratch. */
+    private expandLeafBox;
+    private leafIntersectsFrustum;
     /**
      * 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).