@woosh/meep-engine 3.33.0 → 3.34.0

package/src/shade/renderer/geometry/virtual/runtime/VGeoViewCut.js

@@ -2,6 +2,12 @@ import { assert } from "../../../../../core/assert.js";
 import { VGEO_CUT_FLAG_COARSEN } from "./cut/VGEO_CUT_FLAG_COARSEN.js";
 import { VGEO_CUT_FLAG_CULL } from "./cut/VGEO_CUT_FLAG_CULL.js";
 import { VGEO_CUT_PARAMS_STRUCT } from "./cut/VGEO_CUT_PARAMS_STRUCT.js";
+import {
+    vgeo_feedback_slot_stats,
+    vgeo_feedback_slot_want_count,
+    vgeo_feedback_slot_wants
+} from "./cut/vgeo_cut_feedback_layout.js";
+import { VGEO_CUT_STAT_COUNT } from "./layout/VGEO_CUT_STAT_COUNT.js";
 import { vgeo_frontier_words } from "./vgeo_frontier_words.js";
 import { write_gpu_typed_buffer } from "../../../shader/type/serde/write_gpu_typed_buffer.js";
 
@@ -27,8 +33,9 @@ let ZEROES = new Uint8Array(0);
  *
  * ## Why the params are here and not on the runtime
  *
- * `projection_k` is `screen_height / (2·tan(fov_y/2))`: a property of a render target and a camera,
- * which is to say of a view. One buffer on the runtime meant one value for the frame, written from
+ * `projection_k` is pixels per unit — `screen_height / (2·tan(fov_y/2))` for a perspective view:
+ * a property of a render target and a camera, which is to say of a view. One buffer on the runtime
+ * meant one value for the frame, written from
  * whichever view opened it — so a shadow cascade cut against the main view's projection and
  * selected a level for a screen it is not drawn to. That is a live defect independent of anything
  * a kept cut needs, and the fix is that each view writes its own.
@@ -63,11 +70,18 @@ export class VGeoViewCut {
     #scratch;
 
     /**
-     * `screen_height / (2 · tan(fov_y / 2))`, this view's.
+     * Pixels per unit, this view's; see {@link set_projection}.
      * @type {number}
      */
     #projection_k = 1;
 
+    /**
+     * 1 when distance divides this view's projected error, 0 when it does not; see
+     * {@link set_projection}.
+     * @type {number}
+     */
+    #distance_weight = 1;
+
     /**
      * One bit per page row: the pages this view's cut drew from, kept between frames.
      * Undefined until the first frame that knows how big the tier is.
@@ -80,6 +94,36 @@ export class VGeoViewCut {
      */
     #frontier_word_count = 0;
 
+    /**
+     * How much coarser than the runtime's threshold this view cuts: its τ is `runtime.tau ×
+     * tau_scale`. A scale rather than a τ of its own, so the runtime's τ stays the one lever — a
+     * view set to twice the error stays twice it wherever the lever goes. Nothing in the runtime
+     * knows what kind of view this is; whoever owns the view may set it.
+     *
+     * @type {number}
+     */
+    tau_scale = 1;
+
+    /**
+     * This view's wavefront bound as its own readings have raised it; 0 until one has. The view cuts
+     * at the larger of this and the runtime's starting bound — see {@link iterations_under}.
+     *
+     * @type {number}
+     */
+    #max_iterations = 0;
+
+    /**
+     * @type {number}
+     */
+    #iteration_escalations = 0;
+
+    /**
+     * What the last reading of this view's slot said, indexed by `VGEO_CUT_STAT`.
+     *
+     * @type {Uint32Array}
+     */
+    stats = new Uint32Array(VGEO_CUT_STAT_COUNT);
+
     /**
      * @param {Object} options
      * @param {GPUDevice} options.device
@@ -116,6 +160,13 @@ export class VGeoViewCut {
         return this.#projection_k;
     }
 
+    /**
+     * @returns {number}
+     */
+    get distance_weight() {
+        return this.#distance_weight;
+    }
+
     /**
      * Where this view's last cut stood, as one bit per page row.
      *
@@ -192,53 +243,148 @@ export class VGeoViewCut {
     }
 
     /**
-     * Take this view's projection from the target it draws to and the camera it draws with.
+     * Take this view's projection from the target it draws to and the matrix it draws with.
+     *
+     * **From the matrix, not from the camera's kind.** `P[0]` and `P[5]` are clip units per view
+     * unit on each axis for a perspective and an orthographic projection alike, so half of pixels
+     * times either is pixels per unit: `height / (2·tan(fov_y/2))` for this engine's infinite
+     * reverse-Z perspective, and `height / (top − bottom)` for its reverse-Z orthographic. The finer
+     * of the two axes is taken, which is the one a cascade needs — its rect is square and its
+     * extent is not — and which for a perspective view whose aspect matches its target is the
+     * same number either way. `−P[11]` is 1 for perspective, whose clip w is the view depth, and 0
+     * for orthographic, whose is not; that is the weight distance divides the error by.
+     *
+     * Anything else is refused: an oblique or otherwise unusual projection has no single pixels per
+     * unit, and a cut selected against a guess at one draws a level for a screen nobody has.
      *
      * @param {Object} options
-     * @param {number} options.screen_height pixels of the render target
-     * @param {number} options.fov_y radians
+     * @param {number} options.width pixels of the render target
+     * @param {number} options.height pixels of the render target
+     * @param {ArrayLike<number>} options.projection_matrix column-major, as `Camera.projection_matrix`
      * @returns {void}
      */
-    set_projection({ screen_height, fov_y }) {
-        assert.isNumber(screen_height, 'screen_height');
-        assert.greaterThan(screen_height, 0, 'screen_height');
-        assert.isNumber(fov_y, 'fov_y');
-        assert.greaterThan(fov_y, 0, 'fov_y');
+    set_projection({ width, height, projection_matrix }) {
+        assert.isNumber(width, 'width');
+        assert.greaterThan(width, 0, 'width');
+        assert.isNumber(height, 'height');
+        assert.greaterThan(height, 0, 'height');
+        assert.defined(projection_matrix, 'projection_matrix');
+
+        const m = projection_matrix;
+
+        assert.ok(
+            (m[11] === -1 && m[15] === 0) || (m[11] === 0 && m[15] === 1),
+            `projection is neither perspective nor orthographic: P[11] = ${m[11]}, P[15] = ${m[15]}`
+        );
+
+        this.#projection_k = 0.5 * Math.max(width * Math.abs(m[0]), height * Math.abs(m[5]));
+        // written out rather than negated, which would make an orthographic weight −0
+        this.#distance_weight = m[11] === -1 ? 1 : 0;
+    }
+
+    /**
+     * Wavefronts this view's descent may run in a frame of `runtime`: the runtime's starting bound,
+     * or what this view's own readings have raised it to.
+     *
+     * @param {GPUVirtualGeometryRuntime} runtime
+     * @returns {number}
+     */
+    iterations_under(runtime) {
+        return Math.max(this.#max_iterations, runtime.max_iterations);
+    }
+
+    /**
+     * Times this view's bound has been raised. Zero for the life of almost every view.
+     *
+     * @returns {number}
+     */
+    get iteration_escalations() {
+        return this.#iteration_escalations;
+    }
+
+    /**
+     * A reading of this view's slot saying its descent stopped with work still queued — raise this
+     * view's bound and keep it raised.
+     *
+     * **This is the only place the engine can learn it.** How many wavefronts a cut needs is a
+     * function of the frontier's *breadth*, which is a function of the scene, the viewpoint and the
+     * render target together; the kernel cannot know it before it runs and the host cannot know it
+     * at all. So the bound is guessed low, and the one reading that says the guess was wrong —
+     * `VGEO_CUT_STAT.QUEUE_REMAINING`, non-zero exactly when items were abandoned — pays for
+     * correcting it. It is the same shape as the rasterizer's meshlet counts, which cannot be known
+     * before the expansion runs either and are grown from what the frame reported.
+     *
+     * **Per view.** One bound for the frame let one hungry view — a far cascade, a point face in the
+     * shadow budget for one frame — double every site's ladder for the life of the scene
+     * (SHADOW_PLAN_2026_09_28 §2.4).
+     *
+     * **Doubling, because the reading does not say how much more was needed.** A remainder is a
+     * count of *items*, and what they cost in wavefronts depends on how they spill; there is no
+     * ratio to convert one into the other. So it goes up by a factor until it drains, which is at
+     * most three steps from 8 to the ceiling.
+     *
+     * **Never lowered.** A frame that drained is evidence about that frame, not that the scene got
+     * smaller — and a bound that fell back would re-learn the same lesson every time the camera
+     * turned away and back, at a hole a time. An unused wavefront is an empty indirect dispatch,
+     * which is the cheap side of that trade.
+     *
+     * @param {number} remaining items the descent still held when it was abandoned
+     * @param {GPUVirtualGeometryRuntime} runtime whose starting bound and ceiling apply
+     * @returns {boolean} whether the bound moved
+     */
+    note_incomplete_descent(remaining, runtime) {
+        assert.isNonNegativeInteger(remaining, 'remaining');
+        assert.defined(runtime, 'runtime');
+
+        const current = this.iterations_under(runtime);
+
+        if (remaining === 0 || current >= runtime.iteration_ceiling) {
+            return false;
+        }
+
+        this.#max_iterations = Math.min(current * 2, runtime.iteration_ceiling);
+        this.#iteration_escalations++;
 
-        this.#projection_k = screen_height / (2 * Math.tan(fov_y * 0.5));
+        return true;
     }
 
     /**
      * Publish the frame's shared settings and this view's own, as one uniform.
      *
-     * Everything but `projection_k` and `flags` is a property of the runtime or the frame, so it is
-     * read from the runtime at write time rather than mirrored here — a second copy of `tau` is a
-     * second thing to forget to update.
+     * Everything but the projection, the threshold's scale, the slot and `flags` is a property of the
+     * runtime or the frame, so it is read from the runtime at write time rather than mirrored here —
+     * a second copy of `tau` is a second thing to forget to update.
      *
      * @param {Object} options
      * @param {GPUVirtualGeometryRuntime} options.runtime inside an open frame
+     * @param {number} options.slot this view's slot in the frame's feedback
      * @param {boolean} [options.coarsen] whether this view's cut may walk up
      * @returns {void}
      */
-    write_params({ runtime, coarsen = false }) {
+    write_params({ runtime, slot, coarsen = false }) {
         assert.defined(runtime, 'runtime');
+        assert.isNonNegativeInteger(slot, 'slot');
 
         const layout = runtime.feedback_layout;
 
         assert.defined(layout, 'runtime.feedback_layout — begin_frame must have run');
+        assert.lessThan(slot, layout.slot_count, 'slot');
 
         write_gpu_typed_buffer({
-            tau: runtime.tau,
+            tau: runtime.tau * this.tau_scale,
             projection_k: this.#projection_k,
+            distance_weight: this.#distance_weight,
             queue_capacity: runtime.queue_capacity,
             claim_word_count: runtime.claim_word_capacity,
             descent_steps: runtime.descent_steps,
             page_slot_words: runtime.pool.page_slot_words,
             touch_bits_base: layout.touch_bits_base,
-            want_base: layout.want_base,
-            want_capacity: runtime.want_capacity,
+            stats_base: vgeo_feedback_slot_stats(slot),
+            want_count_offset: vgeo_feedback_slot_want_count(slot),
+            want_base: vgeo_feedback_slot_wants(layout, slot),
+            want_capacity: layout.slot_want_capacity,
             frontier_word_count: this.#frontier_word_count,
-            frame_tag: runtime.pool.frame,
+            frame_tag: runtime.frame_tag_of(slot),
             instance_capacity: runtime.instance_capacity,
             meshlet_capacity: runtime.meshlet_capacity,
             flags: (runtime.cull_enabled ? VGEO_CUT_FLAG_CULL : 0)

package/src/shade/renderer/geometry/virtual/runtime/cut/VGEO_CUT_PARAMS_STRUCT.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"VGEO_CUT_PARAMS_STRUCT.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/runtime/cut/VGEO_CUT_PARAMS_STRUCT.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;GAeG;AACH,kDAiF2B;6BAnGE,yCAAyC"}
+{"version":3,"file":"VGEO_CUT_PARAMS_STRUCT.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/runtime/cut/VGEO_CUT_PARAMS_STRUCT.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;GAeG;AACH,kDAwG2B;6BA1HE,yCAAyC"}

package/src/shade/renderer/geometry/virtual/runtime/cut/VGEO_CUT_PARAMS_STRUCT.js

@@ -19,17 +19,24 @@ import { WebGPUStruct } from "../../../../shader/type/WebGPUStruct.js";
  */
 export const VGEO_CUT_PARAMS_STRUCT = WebGPUStruct.from({
     /**
-     * Pixels of permitted error — design §4's single quality/perf lever, defaulting to 1.
+     * Pixels of permitted error for this view — design §4's single quality/perf lever, the
+     * runtime's `tau` times the view's `tau_scale`.
      */
     tau: f32,
     /**
-     * `screen_height / (2 * tan(fov_y / 2))` — the projection's numerator, which is a property of
-     * the render target and the camera rather than of any instance.
+     * Pixels per unit — `screen_height / (2 * tan(fov_y / 2))` for a perspective view, pixels over
+     * extent for an orthographic one; see `VGeoViewCut.set_projection`. A property of the render
+     * target and the camera rather than of any instance.
      *
      * The collect pass multiplies it by each instance's own scale correction and stores the result
      * per instance, so the traversal reads one number and never touches a transform.
      */
     projection_k: f32,
+    /**
+     * 1 for a perspective view, 0 for an orthographic one. Read by the collect pass alone, which
+     * copies it into every instance record — see `VGEO_INSTANCE_OFFSET.DISTANCE_WEIGHT`.
+     */
+    distance_weight: f32,
     /**
      * Items one queue holds. The wavefront clamps its own count to this, so an overflowing
      * iteration loses work rather than dispatching over a buffer's end.
@@ -74,14 +81,30 @@ export const VGEO_CUT_PARAMS_STRUCT = WebGPUStruct.from({
      * is no list to overflow and nothing per row to clear beyond the transient itself.
      */
     touch_bits_base: u32,
+    /**
+     * Word offset of this view's counters in the feedback buffer — its slot's, so each view's
+     * reading says what its own cut did.
+     */
+    stats_base: u32,
+    /**
+     * Word offset of this view's want counter, and the next two: where its want slice starts and
+     * how many records it holds. A slice per view, so a view recording early in the frame cannot
+     * fill the list a later one records into.
+     */
+    want_count_offset: u32,
     want_base: u32,
     want_capacity: u32,
     /**
-     * What this frame writes into the want-stamp buffer to claim a want, and what it compares
+     * What this view writes into the want-stamp buffer to claim a want, and what it compares
      * against to dedup one. The stamps are persistent and one per lookup word — one per page of
-     * every registered geometry — so they are not cleared per frame; a stamp holding this frame's
-     * tag was written this frame, and any other value was not. Never zero, which is what a fresh
-     * buffer holds.
+     * every registered geometry — so they are not cleared per frame; a stamp holding this tag was
+     * written by this view this frame, and any other value was not. Never zero, which is what a
+     * fresh buffer holds.
+     *
+     * **Per view, not per frame.** One tag for the frame let the first view to reach a page stamp it
+     * whether or not its list had room — so a full slice silenced every later view's want for that
+     * page. With a tag each, each view dedups its own wants into its own slice, and a page two views
+     * want is written twice and collapsed by the residency, which finds it pending the second time.
      */
     frame_tag: u32,
     /**

package/src/shade/renderer/geometry/virtual/runtime/cut/chunk_vgeo_cut_access.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_vgeo_cut_access.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/runtime/cut/chunk_vgeo_cut_access.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;GAeG;AACH,oCAFU,SAAS,CAiHQ;0BAnID,0CAA0C"}
+{"version":3,"file":"chunk_vgeo_cut_access.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/runtime/cut/chunk_vgeo_cut_access.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;GAeG;AACH,oCAFU,SAAS,CAwHQ;0BA1ID,0CAA0C"}

package/src/shade/renderer/geometry/virtual/runtime/cut/chunk_vgeo_cut_access.js

@@ -44,9 +44,16 @@ fn vg_instance_eye(instance_base: u32) -> vec3<f32> {
 }
 
 /**
- * \`err_px = r_e * screen_height / (2 * tan(fov_y / 2) * d)\`, with \`d\` the distance to the
- * **closest point** of the sphere — design §4, and written in that order so that it agrees with
- * \`vgeo_select_cut\` term for term rather than merely in the limit.
+ * \`err_px = r_e * k / d\`, with \`d\` the distance to the **closest point** of the sphere — design
+ * §4, and written in that order so that it agrees with \`vgeo_select_cut\` term for term rather than
+ * merely in the limit.
+ *
+ * **One expression for both projections.** The divisor is \`w * d + (1 - w)\`: at a perspective
+ * view's w = 1 it is \`d\`, exactly, and at an orthographic view's w = 0 it is 1 — a parallel
+ * projection's error covers the same pixels wherever the cluster is. The inside-the-sphere rule is on
+ * the divisor rather than on \`d\`, because an orthographic camera's position is the centre of a box
+ * rather than an eye: a cascade's centre usually sits inside a root sphere, and testing \`d\` there
+ * would refine the whole asset to its leaves.
  *
  * Two conventions carry real weight. A zero error projects to zero **unconditionally**, so a leaf
  * — whose error is exactly zero — does not become undrawable the moment the camera enters its
@@ -54,7 +61,7 @@ fn vg_instance_eye(instance_base: u32) -> vec3<f32> {
  * cluster refines; the two rules meet at the same \`if\` and disagreeing about which comes first is
  * how a leaf disappears at point-blank range.
  */
-fn vg_project(error: f32, sphere: vec4<f32>, eye: vec3<f32>, k: f32) -> f32 {
+fn vg_project(error: f32, sphere: vec4<f32>, eye: vec3<f32>, k: f32, w: f32) -> f32 {
     if (error == 0.0) {
         return 0.0;
     }
@@ -63,7 +70,7 @@ fn vg_project(error: f32, sphere: vec4<f32>, eye: vec3<f32>, k: f32) -> f32 {
         return VG_PROJECTION_MAX;
     }
 
-    let distance = length(eye - sphere.xyz) - sphere.w;
+    let distance = w * (length(eye - sphere.xyz) - sphere.w) + (1.0 - w);
 
     if (distance <= 0.0) {
         return VG_PROJECTION_MAX;

package/src/shade/renderer/geometry/virtual/runtime/cut/chunk_vgeo_cut_claim.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_vgeo_cut_claim.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/runtime/cut/chunk_vgeo_cut_claim.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,mCAFU,SAAS,CAiEQ;0BAlGD,0CAA0C"}
+{"version":3,"file":"chunk_vgeo_cut_claim.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/runtime/cut/chunk_vgeo_cut_claim.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,mCAFU,SAAS,CAkEQ;0BAlGD,0CAA0C"}

package/src/shade/renderer/geometry/virtual/runtime/cut/chunk_vgeo_cut_claim.js

@@ -1,6 +1,5 @@
 import { CodeChunk } from "../../../../shader/compiler/CodeChunk.js";
 import { VGEO_CUT_STAT } from "../layout/VGEO_CUT_STAT.js";
-import { VGEO_FEEDBACK_OFFSET } from "../layout/VGEO_FEEDBACK_OFFSET.js";
 import { VGEO_INSTANCE_OFFSET } from "../layout/VGEO_INSTANCE_OFFSET.js";
 import { VGEO_PAGE_ROW_OFFSET } from "../layout/VGEO_PAGE_ROW_OFFSET.js";
 import { chunk_vgeo_cut_arena } from "./chunk_vgeo_cut_arena.js";
@@ -37,7 +36,8 @@ export const chunk_vgeo_cut_claim = CodeChunk.from(
     //language=WGSL
     `
 fn vg_stat(slot: u32, amount: u32) {
-    atomicAdd(&feedback[${VGEO_FEEDBACK_OFFSET.STATS}u + slot], amount);
+    // this view's counters: every view of a frame has its own, so a reading says what its cut did
+    atomicAdd(&feedback[params.stats_base + slot], amount);
 }
 
 /**

package/src/shade/renderer/geometry/virtual/runtime/cut/shader_vgeo_cut_collect.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_vgeo_cut_collect.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/runtime/cut/shader_vgeo_cut_collect.js"],"names":[],"mappings":"AA2QA,oDAIG;8BAzQ2B,qCAAqC"}
+{"version":3,"file":"shader_vgeo_cut_collect.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/runtime/cut/shader_vgeo_cut_collect.js"],"names":[],"mappings":"AAqRA,oDAIG;8BAnR2B,qCAAqC"}

package/src/shade/renderer/geometry/virtual/runtime/cut/shader_vgeo_cut_collect.js

@@ -11,7 +11,6 @@ import { chunk_mat4_inverse } from "../../../../shader/chunk/geometry/mat4/chunk
 import { chunk_scene_database_access } from "../../../../scene/chunk_scene_database_access.js";
 import { ShaderResourceSetDescriptor } from "../../../../shader/resource/ShaderResourceSetDescriptor.js";
 import { VGEO_CUT_STAT } from "../layout/VGEO_CUT_STAT.js";
-import { VGEO_FEEDBACK_OFFSET } from "../layout/VGEO_FEEDBACK_OFFSET.js";
 import { VGEO_GEOMETRY_ROW_NONE } from "../layout/VGEO_GEOMETRY_ROW_NONE.js";
 import { VGEO_GEOMETRY_ROW_OFFSET } from "../layout/VGEO_GEOMETRY_ROW_OFFSET.js";
 import { VGEO_GEOMETRY_ROW_WORDS } from "../layout/VGEO_GEOMETRY_ROW_WORDS.js";
@@ -73,9 +72,11 @@ fn vg_store(base: u32, field: u32, value: f32) {
  * One frustum plane out of a row combination of the object-space view-projection, normalized so a
  * sphere test is a plain signed distance.
  *
- * Gribb-Hartmann, and the far plane is simply not extracted: the projection is infinite reverse-Z,
- * so its row is degenerate and normalizing it produces nothing a test can use. Ordering near last
- * is what makes the traversal's "test the first five" true by construction.
+ * Gribb-Hartmann, and the far plane is simply not extracted: a perspective projection is infinite
+ * reverse-Z, so its row is degenerate and normalizing it produces nothing a test can use. An
+ * orthographic one — a shadow cascade — has a real far plane, and skipping it is conservative:
+ * what lies behind a cascade's far plane casts onto nothing it covers, and rasterization clips it.
+ * Ordering near last is what makes the traversal's "test the first five" true by construction.
  *
  * **The near plane is w − z, and it was w + z here.** Under reverse-Z the near plane is the one
  * clip space bounds by z <= w; w + z is the row an *infinite* projection makes degenerate, which is
@@ -141,12 +142,16 @@ fn main(@builtin(global_invocation_id) global_id: vec3<u32>) {
     );
 
     /*
-     Error and distance are both object-space, so a **uniform** scale cancels out of r_e * k / d
-     exactly and needs no term at all. A non-uniform one does not, and the correction is the ratio
-     of the largest stretch this transform applies to any direction to the smallest — which is the
-     ratio of its singular values, not of its column lengths. A shear has unit columns and stretches
-     space without bound, so column lengths report 1 and under-refine, which is the direction a
-     conservative correction is not allowed to fail in.
+     In perspective, error and distance are both object-space, so a **uniform** scale cancels out of
+     r_e * k / d exactly and needs no term at all. A non-uniform one does not, and the correction is
+     the ratio of the largest stretch this transform applies to any direction to the smallest —
+     which is the ratio of its singular values, not of its column lengths. A shear has unit columns
+     and stretches space without bound, so column lengths report 1 and under-refine, which is the
+     direction a conservative correction is not allowed to fail in.
+
+     An orthographic view has no distance for a scale to cancel against: an object-space error
+     becomes world units by the largest stretch, and the correction is sigma_max alone. The weight
+     picks between them without a branch, and at w = 1 the expression is today's x / y exactly.
      */
     let stretch = mat3_singular_values(linear);
 
@@ -177,7 +182,7 @@ fn main(@builtin(global_invocation_id) global_id: vec3<u32>) {
          everything — is caught rather than passed through.
          */
         atomicAdd(
-            &feedback[${VGEO_FEEDBACK_OFFSET.STATS}u + ${VGEO_CUT_STAT.INSTANCES_DROPPED}u], 1u
+            &feedback[params.stats_base + ${VGEO_CUT_STAT.INSTANCES_DROPPED}u], 1u
         );
 
         return;
@@ -194,7 +199,7 @@ fn main(@builtin(global_invocation_id) global_id: vec3<u32>) {
          slice draws every page once per parent that reaches it.
          */
         atomicAdd(
-            &feedback[${VGEO_FEEDBACK_OFFSET.STATS}u + ${VGEO_CUT_STAT.INSTANCES_DROPPED}u], 1u
+            &feedback[params.stats_base + ${VGEO_CUT_STAT.INSTANCES_DROPPED}u], 1u
         );
 
         return;
@@ -211,11 +216,16 @@ fn main(@builtin(global_invocation_id) global_id: vec3<u32>) {
     vg_store(base, ${VGEO_INSTANCE_OFFSET.EYE + 1}u, eye.y / eye.w);
     vg_store(base, ${VGEO_INSTANCE_OFFSET.EYE + 2}u, eye.z / eye.w);
 
+    let w = params.distance_weight;
+
     vg_store(
         base, ${VGEO_INSTANCE_OFFSET.PROJECTION_K}u,
-        params.projection_k * (stretch.x / stretch.y)
+        params.projection_k * (stretch.x / (w * stretch.y + (1.0 - w)))
     );
 
+    // with the record rather than read from the params again, so the traversal binds no view's copy
+    vg_store(base, ${VGEO_INSTANCE_OFFSET.DISTANCE_WEIGHT}u, w);
+
     // one matrix multiply, and every plane below comes out of it
     let object_view_projection = camera.view_projection_matrix * node.global;
 

package/src/shade/renderer/geometry/virtual/runtime/cut/shader_vgeo_cut_queue_remainder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_vgeo_cut_queue_remainder.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/runtime/cut/shader_vgeo_cut_queue_remainder.js"],"names":[],"mappings":"AAwEA,4DAIG;8BAxE2B,qCAAqC"}
+{"version":3,"file":"shader_vgeo_cut_queue_remainder.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/runtime/cut/shader_vgeo_cut_queue_remainder.js"],"names":[],"mappings":"AAuEA,4DAIG;8BAvE2B,qCAAqC"}

package/src/shade/renderer/geometry/virtual/runtime/cut/shader_vgeo_cut_queue_remainder.js

@@ -5,7 +5,6 @@ import { COLLECTION_U32_STRUCT_READ } from "../../../../gpu_primitive/COLLECTION
 import { ComputeShader } from "../../../../shader/ComputeShader.js";
 import { ShaderResourceSetDescriptor } from "../../../../shader/resource/ShaderResourceSetDescriptor.js";
 import { VGEO_CUT_STAT } from "../layout/VGEO_CUT_STAT.js";
-import { VGEO_FEEDBACK_OFFSET } from "../layout/VGEO_FEEDBACK_OFFSET.js";
 import { VGEO_CUT_PARAMS_STRUCT } from "./VGEO_CUT_PARAMS_STRUCT.js";
 
 /**
@@ -64,7 +63,7 @@ fn main() {
     }
 
     atomicAdd(
-        &feedback[${VGEO_FEEDBACK_OFFSET.STATS}u + ${VGEO_CUT_STAT.QUEUE_REMAINING}u],
+        &feedback[params.stats_base + ${VGEO_CUT_STAT.QUEUE_REMAINING}u],
         outstanding
     );
 }

package/src/shade/renderer/geometry/virtual/runtime/cut/shader_vgeo_cut_seed.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_vgeo_cut_seed.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/runtime/cut/shader_vgeo_cut_seed.js"],"names":[],"mappings":"AAsIA,iDAIG;8BArI2B,qCAAqC"}
+{"version":3,"file":"shader_vgeo_cut_seed.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/runtime/cut/shader_vgeo_cut_seed.js"],"names":[],"mappings":"AAqIA,iDAIG;8BApI2B,qCAAqC"}

package/src/shade/renderer/geometry/virtual/runtime/cut/shader_vgeo_cut_seed.js

@@ -8,7 +8,6 @@ import { ShaderResourceSetDescriptor } from "../../../../shader/resource/ShaderR
 import { chunk_vgeo_cut_claim } from "./chunk_vgeo_cut_claim.js";
 import { chunk_vgeo_cut_queue } from "./chunk_vgeo_cut_queue.js";
 import { VGEO_CUT_STAT } from "../layout/VGEO_CUT_STAT.js";
-import { VGEO_FEEDBACK_OFFSET } from "../layout/VGEO_FEEDBACK_OFFSET.js";
 import { VGEO_INSTANCE_OFFSET } from "../layout/VGEO_INSTANCE_OFFSET.js";
 import { VGEO_INSTANCE_WORDS } from "../layout/VGEO_INSTANCE_WORDS.js";
 import { VGEO_PAGE_ROW_NONE } from "../layout/VGEO_PAGE_ROW_NONE.js";
@@ -89,7 +88,7 @@ fn main(@builtin(global_invocation_id) global_id: vec3<u32>) {
 
     if ((claim_base + capacity + 31u) >> 5u > params.claim_word_count) {
         atomicAdd(
-            &feedback[${VGEO_FEEDBACK_OFFSET.STATS}u + ${VGEO_CUT_STAT.INSTANCES_DROPPED}u], 1u
+            &feedback[params.stats_base + ${VGEO_CUT_STAT.INSTANCES_DROPPED}u], 1u
         );
 
         // left with a capacity of zero, so nothing downstream can claim on its behalf either

package/src/shade/renderer/geometry/virtual/runtime/cut/shader_vgeo_cut_traverse.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_vgeo_cut_traverse.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/runtime/cut/shader_vgeo_cut_traverse.js"],"names":[],"mappings":"AAm4BA,qDAIG;8BAp4B2B,qCAAqC"}
+{"version":3,"file":"shader_vgeo_cut_traverse.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/runtime/cut/shader_vgeo_cut_traverse.js"],"names":[],"mappings":"AAu4BA,qDAIG;8BAx4B2B,qCAAqC"}

package/src/shade/renderer/geometry/virtual/runtime/cut/shader_vgeo_cut_traverse.js

@@ -10,7 +10,6 @@ import { MESHLET_COLLECTION_WRITE_STRUCT } from "../../../../rasterize/MESHLET_C
 import { MESHLET_DEFINITION_STRUCT } from "../../../meshlet/encoding/MESHLET_DEFINITION_STRUCT.js";
 import { VGEO_CLUSTER_ROW_OFFSET } from "../layout/VGEO_CLUSTER_ROW_OFFSET.js";
 import { VGEO_CUT_STAT } from "../layout/VGEO_CUT_STAT.js";
-import { VGEO_FEEDBACK_OFFSET } from "../layout/VGEO_FEEDBACK_OFFSET.js";
 import { VGEO_GROUP_FLAG_SELECTABLE } from "../layout/VGEO_GROUP_FLAG_SELECTABLE.js";
 import { VGEO_GROUP_ROW_OFFSET } from "../layout/VGEO_GROUP_ROW_OFFSET.js";
 import { VGEO_INSTANCE_OFFSET } from "../layout/VGEO_INSTANCE_OFFSET.js";
@@ -272,7 +271,8 @@ fn vg_want(source_page_row: u32, child_ref: u32, child_page_index: u32, lookup_b
         return;
     }
 
-    let slot = atomicAdd(&feedback[${VGEO_FEEDBACK_OFFSET.WANT_COUNT}u], 1u);
+    // this view's slice and this view's counter, so an earlier view's full list takes no room here
+    let slot = atomicAdd(&feedback[params.want_count_offset], 1u);
 
     if (slot >= params.want_capacity) {
         vg_stat(${VGEO_CUT_STAT.WANTS_DROPPED}u, 1u);
@@ -284,7 +284,9 @@ fn vg_want(source_page_row: u32, child_ref: u32, child_page_index: u32, lookup_b
     atomicStore(&feedback[base], source_page_row);
     atomicStore(&feedback[base + 1u], child_ref);
     atomicStore(&feedback[base + 2u], child_page_index);
-    atomicStore(&feedback[base + 3u], bitcast<u32>(projected));
+    // over this view's own threshold, so the residency can rank wants from views that count in
+    // different units at different thresholds on one scale
+    atomicStore(&feedback[base + 3u], bitcast<u32>(projected / params.tau));
 }
 
 /**
@@ -354,6 +356,7 @@ fn vg_visit_node(instance_base: u32, page_row: u32, node: u32) -> VGExpand {
 
     let eye = vg_instance_eye(instance_base);
     let k = vg_instance_f32(instance_base, ${VGEO_INSTANCE_OFFSET.PROJECTION_K}u);
+    let w = vg_instance_f32(instance_base, ${VGEO_INSTANCE_OFFSET.DISTANCE_WEIGHT}u);
 
     /*
      Format §6.2's load-bearing field. A cluster draws only while project(parent) > tau, so if the
@@ -376,7 +379,7 @@ fn vg_visit_node(instance_base: u32, page_row: u32, node: u32) -> VGExpand {
      one, and why the frontier is what makes this affordable rather than this pass.
     */
     if ((params.flags & ${VGEO_CUT_FLAG_COARSEN}u) == 0u
-        && vg_project(vg_arena_f32(row + ${VGEO_NODE_ROW_OFFSET.MAX_PARENT_ERROR}u), sphere, eye, k)
+        && vg_project(vg_arena_f32(row + ${VGEO_NODE_ROW_OFFSET.MAX_PARENT_ERROR}u), sphere, eye, k, w)
             <= params.tau) {
         vg_stat(${VGEO_CUT_STAT.CULLED_LOD}u, 1u);
         return vg_expand_none();
@@ -473,6 +476,7 @@ fn vg_visit_cluster(
 
     let eye = vg_instance_eye(instance_base);
     let k = vg_instance_f32(instance_base, ${VGEO_INSTANCE_OFFSET.PROJECTION_K}u);
+    let w = vg_instance_f32(instance_base, ${VGEO_INSTANCE_OFFSET.DISTANCE_WEIGHT}u);
     let mesh_index = instances[instance_base + ${VGEO_INSTANCE_OFFSET.MESH_INDEX}u];
     let lookup_base = instances[instance_base + ${VGEO_INSTANCE_OFFSET.LOOKUP_WORD_OFFSET}u];
 
@@ -481,7 +485,7 @@ fn vg_visit_cluster(
     let parent_projected = vg_project(
         vg_arena_f32(row + ${VGEO_CLUSTER_ROW_OFFSET.PARENT_ERROR}u),
         vg_sphere_at(row + ${VGEO_CLUSTER_ROW_OFFSET.PARENT_SPHERE}u),
-        eye, k
+        eye, k, w
     );
 
     if (parent_projected <= params.tau) {
@@ -556,7 +560,7 @@ fn vg_visit_cluster(
     let self_projected = vg_project(
         vg_arena_f32(row + ${VGEO_CLUSTER_ROW_OFFSET.SELF_ERROR}u),
         vg_sphere_at(row + ${VGEO_CLUSTER_ROW_OFFSET.SELF_SPHERE}u),
-        eye, k
+        eye, k, w
     );
 
     let child_page_index = vg_arena[row + ${VGEO_CLUSTER_ROW_OFFSET.CHILD_PAGE_INDEX}u];