@woosh/meep-engine 3.58.0 → 3.59.0

package/src/shade/renderer/extension/ViewTextures.js

@@ -38,7 +38,8 @@ export class ViewTextures extends FrameRecord {
     }
 
     /**
-     * Last frame's depth, which reprojection-shaped effects need.
+     * Last frame's depth, which reprojection-shaped effects need. At the size last frame was drawn
+     * at, which after a resolution change is not {@link depth}'s: address it in its own grid.
      *
      * @returns {number}
      */

package/src/shade/renderer/fluid/GPUFluidCascade.d.ts

@@ -143,7 +143,7 @@ export class GPUFluidCascade {
      * @param {*} _resources
      * @param {{encoder: ShadeGPUCommandContext}} context
      */
-    static "__#275@#execute_restrict"(record: object, _resources: any, context: {
+    static "__#277@#execute_restrict"(record: object, _resources: any, context: {
         encoder: ShadeGPUCommandContext;
     }): void;
     /**
@@ -151,7 +151,7 @@ export class GPUFluidCascade {
      * @param {*} _resources
      * @param {{encoder: ShadeGPUCommandContext}} context
      */
-    static "__#275@#execute_fill"(record: object, _resources: any, context: {
+    static "__#277@#execute_fill"(record: object, _resources: any, context: {
         encoder: ShadeGPUCommandContext;
     }): void;
     /**
@@ -159,7 +159,7 @@ export class GPUFluidCascade {
      * @param {import("../../../engine/graphics/render/frame_graph/FramePassResources.js").FramePassResources} resources
      * @param {{encoder: ShadeGPUCommandContext}} context
      */
-    static "__#275@#execute"(record: object, resources: import("../../../engine/graphics/render/frame_graph/FramePassResources.js").FramePassResources, context: {
+    static "__#277@#execute"(record: object, resources: import("../../../engine/graphics/render/frame_graph/FramePassResources.js").FramePassResources, context: {
         encoder: ShadeGPUCommandContext;
     }): void;
     /**

package/src/shade/renderer/fluid/GPUFluidCascadeStack.d.ts

@@ -63,7 +63,7 @@ export class GPUFluidCascadeStack {
      * @param {*} _resources
      * @param {{encoder: import("../../device/ShadeGPUCommandContext.js").ShadeGPUCommandContext}} context
      */
-    static "__#277@#execute_publish"(pass: object, _resources: any, context: {
+    static "__#279@#execute_publish"(pass: object, _resources: any, context: {
         encoder: import("../../device/ShadeGPUCommandContext.js").ShadeGPUCommandContext;
     }): void;
     /**

package/src/shade/renderer/fluid/forcing/GPUFluidForcing.d.ts

@@ -90,19 +90,19 @@ export class GPUFluidForcing {
      * @param {number} clear_size bytes cleared from 0 when the pool reuses the buffer
      * @returns {BufferResourceDescriptor}
      */
-    static "__#278@#descriptor"(kept: BufferResourceDescriptor[], role: number, size: number, usage: number, clear_size: number): BufferResourceDescriptor;
+    static "__#280@#descriptor"(kept: BufferResourceDescriptor[], role: number, size: number, usage: number, clear_size: number): BufferResourceDescriptor;
     /**
      * @param {object} record
      * @param {FramePassResources} resources
      * @param {{encoder: ShadeGPUCommandContext}} context
      */
-    static "__#278@#execute_extract"(record: object, resources: FramePassResources, context: {
+    static "__#280@#execute_extract"(record: object, resources: FramePassResources, context: {
         encoder: ShadeGPUCommandContext;
     }): void;
-    static "__#278@#execute_clear"(record: any, _resources: any, context: any): void;
-    static "__#278@#execute_query"(record: any, resources: any, context: any): void;
-    static "__#278@#execute_command"(record: any, resources: any, context: any): void;
-    static "__#278@#execute_apply"(record: any, resources: any, context: any): void;
+    static "__#280@#execute_clear"(record: any, _resources: any, context: any): void;
+    static "__#280@#execute_query"(record: any, resources: any, context: any): void;
+    static "__#280@#execute_command"(record: any, resources: any, context: any): void;
+    static "__#280@#execute_apply"(record: any, resources: any, context: any): void;
     /**
      * @param {object} options
      * @param {GPUDevice} options.device

package/src/shade/renderer/fluid/pressure/GPUFluidPressureSolve.d.ts

@@ -41,7 +41,7 @@ export class GPUFluidPressureSolve {
      * @param {*} _resources
      * @param {{encoder: ShadeGPUCommandContext}} context
      */
-    static "__#274@#execute"(data: {
+    static "__#276@#execute"(data: {
         solve: GPUFluidPressureSolve;
         arm: number;
         count: number;

package/src/shade/renderer/fluid/query/GPUFluidQueries.d.ts

@@ -49,7 +49,7 @@ export class GPUFluidQueries {
      * @param {import("../../../../engine/graphics/render/frame_graph/FramePassResources.js").FramePassResources} resources
      * @param {{encoder: import("../../../device/ShadeGPUCommandContext.js").ShadeGPUCommandContext}} context
      */
-    static "__#279@#execute"(pass: object, resources: import("../../../../engine/graphics/render/frame_graph/FramePassResources.js").FramePassResources, context: {
+    static "__#281@#execute"(pass: object, resources: import("../../../../engine/graphics/render/frame_graph/FramePassResources.js").FramePassResources, context: {
         encoder: import("../../../device/ShadeGPUCommandContext.js").ShadeGPUCommandContext;
     }): void;
     /**

package/src/shade/renderer/geometry/virtual/runtime/GPUVirtualGeometryRuntime.d.ts

@@ -17,7 +17,8 @@
  *
  * **Every view that cuts takes a slot** (§2.4): its own counters, its own want slice and its own
  * stamp tag, so one view's list running out cannot silence another's, and a reading can say which
- * view needed more wavefronts. The view the frame is opened for is slot 0.
+ * view needed more wavefronts. The view the frame is opened for is slot 0. A slot's taker is any
+ * {@link VGeoFeedbackConsumer}, a view's cut or a cut that is not a view's.
  *
  * @author Alex Goldring
  * @copyright Company Named Limited (c) 2026
@@ -165,17 +166,17 @@ export class GPUVirtualGeometryRuntime {
         view: VGeoViewCut;
     }): void;
     /**
-     * This frame's slot for a view, taking the next one the first time the view cuts in the frame.
+     * This frame's slot for a consumer, taking the next one the first time it cuts in the frame.
      *
-     * A view past the slots the frame was laid out for shares the last one — never slot 0, which is
-     * the frame's own view's — and the next frame is laid out with room for it. A shared slot's
-     * counters are the sum of its views', so its reading lands on each of them but escalates none
-     * (see `VGeoFeedbackLoop`).
+     * A consumer past the slots the frame was laid out for shares the last one — never slot 0, which
+     * is the frame's own view's — and the next frame is laid out with room for it. A shared slot's
+     * counters are the sum of its consumers', so its reading lands on each of them, told it was
+     * shared (see `VGeoFeedbackLoop`).
      *
-     * @param {VGeoViewCut} view
+     * @param {VGeoFeedbackConsumer} view
      * @returns {number}
      */
-    slot_of(view: VGeoViewCut): number;
+    slot_of(view: VGeoFeedbackConsumer): number;
     /**
      * The tag a slot's view writes into the want stamps, unique to that view in this frame and never
      * zero — see `VGEO_CUT_PARAMS_STRUCT.frame_tag`.
@@ -185,12 +186,22 @@ export class GPUVirtualGeometryRuntime {
      */
     frame_tag_of(slot: number): number;
     /**
-     * This frame's views, by slot — what a reading of this frame's feedback is about. A copy, since
-     * the reading lands frames later and the table is rebuilt every frame.
+     * Fill the fields of a cut's `VGEO_CUT_PARAMS_STRUCT` that are the frame's and its slot's rather
+     * than the cut's own: the arena's stride, where the frame's touch bits and the slot's counters and
+     * wants are, and the slot's stamp tag.
      *
-     * @returns {VGeoViewCut[][]}
+     * @param {Object} params written in place
+     * @param {number} slot this frame's, from {@link slot_of}
+     * @returns {Object} params
      */
-    frame_slots(): VGeoViewCut[][];
+    fill_slot_params(params: any, slot: number): any;
+    /**
+     * This frame's consumers, by slot — what a reading of this frame's feedback is about. A copy,
+     * since the reading lands frames later and the table is rebuilt every frame.
+     *
+     * @returns {VGeoFeedbackConsumer[][]}
+     */
+    frame_slots(): VGeoFeedbackConsumer[][];
     /**
      * The feedback buffer as a resource of `graph`, at the version that graph last wrote.
      *
@@ -267,4 +278,15 @@ export class GPUVirtualGeometryRuntime {
 export type GPUVirtualGeometryPool = import("./GPUVirtualGeometryPool.js").GPUVirtualGeometryPool;
 export type VGeoViewCut = import("./VGeoViewCut.js").VGeoViewCut;
 export type FrameGraph = import("../../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph;
+/**
+ * What takes a slot of a frame's feedback ({@link GPUVirtualGeometryRuntimeslot_of }): a cut that writes its
+ * counters and its wants there, and reads its counters back when the reading lands.
+ */
+export type VGeoFeedbackConsumer = {
+    /**
+     * the reading,
+     * where its slot's counters start in it, whether another consumer shared the slot, and the runtime
+     */
+    read_feedback: (arg0: Uint32Array, arg1: number, arg2: boolean, arg3: GPUVirtualGeometryRuntime) => void;
+};
 //# sourceMappingURL=GPUVirtualGeometryRuntime.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"GPUVirtualGeometryRuntime.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/runtime/GPUVirtualGeometryRuntime.js"],"names":[],"mappings":"AAoBA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH;IAmHI;;;;;;;;;;;;;;;OAeG;IACH;QAd2C,IAAI,EAApC,sBAAsB;QACL,aAAa,GAA9B,MAAM;QACW,qBAAqB,GAAtC,MAAM;QAEW,mBAAmB,GAApC,MAAM;QAEW,cAAc,GAA/B,MAAM;QACW,cAAc,GAA/B,MAAM;QAEW,qBAAqB,GAAtC,MAAM;QACW,aAAa,GAA9B,MAAM;OAgFhB;IA3KD;;;;OAIG;IACH,KAFU,MAAM,CAER;IAER;;OAEG;IACH,cAFU,OAAO,CAEG;IAmKpB;;OAEG;IACH,yEAEC;IAED;;;;OAIG;IACH,4BAEC;IAED;;OAEG;IACH,6BAEC;IAED;;OAEG;IACH,kCAEC;IAED;;;;;OAKG;IACH,6BAEC;IAED;;;;OAIG;IACH,gCAEC;IAWD;;;;;;OAMG;IACH,iCAKC;IArBD;;;;OAIG;IACH,4BAEC;IAgBD;;;;OAIG;IACH,0BAEC;IAED;;;;OAIG;IACH,yDAEC;IAED;;;;;OAKG;IACH,2BAEC;IAED;;OAEG;IACH;;;;;;;;MAEC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH;QAHgC,IAAI,EAAzB,WAAW;QACT,IAAI,CAqChB;IAwBD;;;;;;;;;;OAUG;IACH,cAHW,WAAW,GACT,MAAM,CA0BlB;IAED;;;;;;OAMG;IACH,mBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;OAKG;IACH,eAFa,WAAW,EAAE,EAAE,CAI3B;IAED;;;;;;;;;OASG;IACH,mBAHW,UAAU,GACR,MAAM,CAkClB;IAED;;;;;;;;;;;;OAYG;IACH,wBAJW,UAAU,UACV,MAAM,GACJ,IAAI,CAOhB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH;QAJ2B,iBAAiB,EAAjC,MAAM;QACU,gBAAgB,EAAhC,MAAM;QACJ,IAAI,CAgBhB;IAED;;OAEG;IACH,gCAEC;IAED;;OAEG;IACH,+BAEC;IAED;;;;;OAKG;IACH,aAFa,IAAI,CAKhB;IAED;;;;;;;;OAQG;IACH,WAFa,IAAI,CAOhB;;CACJ;qCA3nBY,OAAO,6BAA6B,EAAE,sBAAsB;0BAC5D,OAAO,kBAAkB,EAAE,WAAW;yBACtC,OAAO,iEAAiE,EAAE,UAAU"}
+{"version":3,"file":"GPUVirtualGeometryRuntime.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/runtime/GPUVirtualGeometryRuntime.js"],"names":[],"mappings":"AAkCA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH;IAmHI;;;;;;;;;;;;;;;OAeG;IACH;QAd2C,IAAI,EAApC,sBAAsB;QACL,aAAa,GAA9B,MAAM;QACW,qBAAqB,GAAtC,MAAM;QAEW,mBAAmB,GAApC,MAAM;QAEW,cAAc,GAA/B,MAAM;QACW,cAAc,GAA/B,MAAM;QAEW,qBAAqB,GAAtC,MAAM;QACW,aAAa,GAA9B,MAAM;OAgFhB;IA3KD;;;;OAIG;IACH,KAFU,MAAM,CAER;IAER;;OAEG;IACH,cAFU,OAAO,CAEG;IAmKpB;;OAEG;IACH,yEAEC;IAED;;;;OAIG;IACH,4BAEC;IAED;;OAEG;IACH,6BAEC;IAED;;OAEG;IACH,kCAEC;IAED;;;;;OAKG;IACH,6BAEC;IAED;;;;OAIG;IACH,gCAEC;IAWD;;;;;;OAMG;IACH,iCAKC;IArBD;;;;OAIG;IACH,4BAEC;IAgBD;;;;OAIG;IACH,0BAEC;IAED;;;;OAIG;IACH,yDAEC;IAED;;;;;OAKG;IACH,2BAEC;IAED;;OAEG;IACH;;;;;;;;MAEC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH;QAHgC,IAAI,EAAzB,WAAW;QACT,IAAI,CAqChB;IAwBD;;;;;;;;;;OAUG;IACH,cAHW,oBAAoB,GAClB,MAAM,CA0BlB;IAED;;;;;;OAMG;IACH,mBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;;;OAQG;IACH,oCAHW,MAAM,OAkBhB;IAED;;;;;OAKG;IACH,eAFa,oBAAoB,EAAE,EAAE,CAIpC;IAED;;;;;;;;;OASG;IACH,mBAHW,UAAU,GACR,MAAM,CAkClB;IAED;;;;;;;;;;;;OAYG;IACH,wBAJW,UAAU,UACV,MAAM,GACJ,IAAI,CAOhB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH;QAJ2B,iBAAiB,EAAjC,MAAM;QACU,gBAAgB,EAAhC,MAAM;QACJ,IAAI,CAgBhB;IAED;;OAEG;IACH,gCAEC;IAED;;OAEG;IACH,+BAEC;IAED;;;;;OAKG;IACH,aAFa,IAAI,CAKhB;IAED;;;;;;;;OAQG;IACH,WAFa,IAAI,CAOhB;;CACJ;qCA/pBY,OAAO,6BAA6B,EAAE,sBAAsB;0BAC5D,OAAO,kBAAkB,EAAE,WAAW;yBACtC,OAAO,iEAAiE,EAAE,UAAU;;;;;;;;;;0BAQ1E,WAAW,QAAE,MAAM,QAAE,OAAO,QAAE,yBAAyB,KAAG,IAAI"}

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

@@ -1,6 +1,11 @@
 import { assert } from "../../../../../core/assert.js";
 import { BufferResourceDescriptor } from "../../../../device/graph/BufferResourceDescriptor.js";
-import { vgeo_cut_feedback_layout } from "./cut/vgeo_cut_feedback_layout.js";
+import {
+    vgeo_cut_feedback_layout,
+    vgeo_feedback_slot_stats,
+    vgeo_feedback_slot_want_count,
+    vgeo_feedback_slot_wants
+} from "./cut/vgeo_cut_feedback_layout.js";
 
 /**
  * @typedef {import("./GPUVirtualGeometryPool.js").GPUVirtualGeometryPool} GPUVirtualGeometryPool
@@ -8,6 +13,15 @@ import { vgeo_cut_feedback_layout } from "./cut/vgeo_cut_feedback_layout.js";
  * @typedef {import("../../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} FrameGraph
  */
 
+/**
+ * What takes a slot of a frame's feedback ({@link GPUVirtualGeometryRuntime#slot_of}): a cut that writes its
+ * counters and its wants there, and reads its counters back when the reading lands.
+ *
+ * @typedef {Object} VGeoFeedbackConsumer
+ * @property {function(Uint32Array, number, boolean, GPUVirtualGeometryRuntime): void} read_feedback the reading,
+ *   where its slot's counters start in it, whether another consumer shared the slot, and the runtime
+ */
+
 /**
  * The most views one frame's feedback is laid out for. A view past it shares the last slot, which
  * merges its counters and its want slice with that view's and loses nothing else; the bound exists
@@ -37,7 +51,8 @@ const SLOT_CEILING = 64;
  *
  * **Every view that cuts takes a slot** (§2.4): its own counters, its own want slice and its own
  * stamp tag, so one view's list running out cannot silence another's, and a reading can say which
- * view needed more wavefronts. The view the frame is opened for is slot 0.
+ * view needed more wavefronts. The view the frame is opened for is slot 0. A slot's taker is any
+ * {@link VGeoFeedbackConsumer}, a view's cut or a cut that is not a view's.
  *
  * @author Alex Goldring
  * @copyright Company Named Limited (c) 2026
@@ -119,14 +134,14 @@ export class GPUVirtualGeometryRuntime {
     #cleared = false;
 
     /**
-     * This frame's slot for each view that has cut in it.
-     * @type {Map<VGeoViewCut, number>}
+     * This frame's slot for each consumer that has cut in it.
+     * @type {Map<VGeoFeedbackConsumer, number>}
      */
     #slot_of = new Map();
 
     /**
-     * This frame's views, by slot; a slot shared past the layout holds more than one.
-     * @type {VGeoViewCut[][]}
+     * This frame's consumers, by slot; a slot shared past the layout holds more than one.
+     * @type {VGeoFeedbackConsumer[][]}
      */
     #slots = [];
 
@@ -444,14 +459,14 @@ export class GPUVirtualGeometryRuntime {
     }
 
     /**
-     * This frame's slot for a view, taking the next one the first time the view cuts in the frame.
+     * This frame's slot for a consumer, taking the next one the first time it cuts in the frame.
      *
-     * A view past the slots the frame was laid out for shares the last one — never slot 0, which is
-     * the frame's own view's — and the next frame is laid out with room for it. A shared slot's
-     * counters are the sum of its views', so its reading lands on each of them but escalates none
-     * (see `VGeoFeedbackLoop`).
+     * A consumer past the slots the frame was laid out for shares the last one — never slot 0, which
+     * is the frame's own view's — and the next frame is laid out with room for it. A shared slot's
+     * counters are the sum of its consumers', so its reading lands on each of them, told it was
+     * shared (see `VGeoFeedbackLoop`).
      *
-     * @param {VGeoViewCut} view
+     * @param {VGeoFeedbackConsumer} view
      * @returns {number}
      */
     slot_of(view) {
@@ -492,10 +507,36 @@ export class GPUVirtualGeometryRuntime {
     }
 
     /**
-     * This frame's views, by slot — what a reading of this frame's feedback is about. A copy, since
-     * the reading lands frames later and the table is rebuilt every frame.
+     * Fill the fields of a cut's `VGEO_CUT_PARAMS_STRUCT` that are the frame's and its slot's rather
+     * than the cut's own: the arena's stride, where the frame's touch bits and the slot's counters and
+     * wants are, and the slot's stamp tag.
+     *
+     * @param {Object} params written in place
+     * @param {number} slot this frame's, from {@link slot_of}
+     * @returns {Object} params
+     */
+    fill_slot_params(params, slot) {
+        const layout = this.#layout;
+
+        assert.defined(layout, 'feedback_layout — begin_frame must have run');
+        assert.lessThan(slot, layout.slot_count, 'slot');
+
+        params.page_slot_words = this.#pool.page_slot_words;
+        params.touch_bits_base = layout.touch_bits_base;
+        params.stats_base = vgeo_feedback_slot_stats(slot);
+        params.want_count_offset = vgeo_feedback_slot_want_count(slot);
+        params.want_base = vgeo_feedback_slot_wants(layout, slot);
+        params.want_capacity = layout.slot_want_capacity;
+        params.frame_tag = this.frame_tag_of(slot);
+
+        return params;
+    }
+
+    /**
+     * This frame's consumers, by slot — what a reading of this frame's feedback is about. A copy,
+     * since the reading lands frames later and the table is rebuilt every frame.
      *
-     * @returns {VGeoViewCut[][]}
+     * @returns {VGeoFeedbackConsumer[][]}
      */
     frame_slots() {
         return this.#slots.map(views => views.slice());

package/src/shade/renderer/geometry/virtual/runtime/VGeoFeedbackLoop.d.ts

@@ -1,6 +1,6 @@
 /**
  * @typedef {import("../../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} FrameGraph
- * @typedef {import("./VGeoViewCut.js").VGeoViewCut} VGeoViewCut
+ * @typedef {import("./GPUVirtualGeometryRuntime.js").VGeoFeedbackConsumer} VGeoFeedbackConsumer
  * @typedef {import("./GPUVirtualGeometryRuntime.js").GPUVirtualGeometryRuntime} GPUVirtualGeometryRuntime
  * @typedef {import("./VGeoResidency.js").VGeoResidency} VGeoResidency
  * @typedef {import("./cut/vgeo_cut_feedback_layout.js").vgeo_cut_feedback_layout} vgeo_cut_feedback_layout
@@ -96,7 +96,7 @@ export class VGeoFeedbackLoop {
     #private;
 }
 export type FrameGraph = import("../../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph;
-export type VGeoViewCut = import("./VGeoViewCut.js").VGeoViewCut;
+export type VGeoFeedbackConsumer = import("./GPUVirtualGeometryRuntime.js").VGeoFeedbackConsumer;
 export type GPUVirtualGeometryRuntime = import("./GPUVirtualGeometryRuntime.js").GPUVirtualGeometryRuntime;
 export type VGeoResidency = import("./VGeoResidency.js").VGeoResidency;
 export type vgeo_cut_feedback_layout = typeof import("./cut/vgeo_cut_feedback_layout.js").vgeo_cut_feedback_layout;

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

@@ -1 +1 @@
-{"version":3,"file":"VGeoFeedbackLoop.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/runtime/VGeoFeedbackLoop.js"],"names":[],"mappings":"AAMA;;;;;;GAMG;AAEH;;;;;;;;;;;;;;;;GAgBG;AACH;IA4CI;;;;;;OAMG;IACH;QAL8C,OAAO,EAA1C,yBAAyB;QACF,SAAS,EAAhC,aAAa;QACI,aAAa,GAA9B,MAAM;OAUhB;IAED;;OAEG;IACH,4DAEC;IAED;;OAEG;IACH,yBAEC;IAED;;;;;;;OAOG;IACH,6BAEC;IAED;;OAEG;IACH,yBAEC;IAED;;OAEG;IACH,8BAEC;IAED;;OAEG;IACH,+BAEC;IAED;;;OAGG;IACH,iCAEC;IAED;;;;;OAKG;IACH,YAHW,UAAU,GACR,OAAO,CAwEnB;IA4CD;;;;OAIG;IACH,SAFa,IAAI,CAIhB;IAED;;;;;;;;;OASG;IACH,WAFa,IAAI,CAMhB;;CACJ;yBA3RY,OAAO,iEAAiE,EAAE,UAAU;0BACpF,OAAO,kBAAkB,EAAE,WAAW;wCACtC,OAAO,gCAAgC,EAAE,yBAAyB;4BAClE,OAAO,oBAAoB,EAAE,aAAa"}
+{"version":3,"file":"VGeoFeedbackLoop.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/runtime/VGeoFeedbackLoop.js"],"names":[],"mappings":"AAKA;;;;;;GAMG;AAEH;;;;;;;;;;;;;;;;GAgBG;AACH;IA4CI;;;;;;OAMG;IACH;QAL8C,OAAO,EAA1C,yBAAyB;QACF,SAAS,EAAhC,aAAa;QACI,aAAa,GAA9B,MAAM;OAUhB;IAED;;OAEG;IACH,4DAEC;IAED;;OAEG;IACH,yBAEC;IAED;;;;;;;OAOG;IACH,6BAEC;IAED;;OAEG;IACH,yBAEC;IAED;;OAEG;IACH,8BAEC;IAED;;OAEG;IACH,+BAEC;IAED;;;OAGG;IACH,iCAEC;IAED;;;;;OAKG;IACH,YAHW,UAAU,GACR,OAAO,CAwEnB;IAgCD;;;;OAIG;IACH,SAFa,IAAI,CAIhB;IAED;;;;;;;;;OASG;IACH,WAFa,IAAI,CAMhB;;CACJ;yBA/QY,OAAO,iEAAiE,EAAE,UAAU;mCACpF,OAAO,gCAAgC,EAAE,oBAAoB;wCAC7D,OAAO,gCAAgC,EAAE,yBAAyB;4BAClE,OAAO,oBAAoB,EAAE,aAAa"}

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

@@ -1,12 +1,11 @@
 import { assert } from "../../../../../core/assert.js";
 import { graph_read_buffer } from "../../../buffer/graph_read_buffer.js";
-import { VGEO_CUT_STAT } from "./layout/VGEO_CUT_STAT.js";
 import { VGEO_CUT_STAT_COUNT } from "./layout/VGEO_CUT_STAT_COUNT.js";
 import { vgeo_feedback_slot_stats } from "./cut/vgeo_cut_feedback_layout.js";
 
 /**
  * @typedef {import("../../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} FrameGraph
- * @typedef {import("./VGeoViewCut.js").VGeoViewCut} VGeoViewCut
+ * @typedef {import("./GPUVirtualGeometryRuntime.js").VGeoFeedbackConsumer} VGeoFeedbackConsumer
  * @typedef {import("./GPUVirtualGeometryRuntime.js").GPUVirtualGeometryRuntime} GPUVirtualGeometryRuntime
  * @typedef {import("./VGeoResidency.js").VGeoResidency} VGeoResidency
  * @typedef {import("./cut/vgeo_cut_feedback_layout.js").vgeo_cut_feedback_layout} vgeo_cut_feedback_layout
@@ -181,9 +180,9 @@ export class VGeoFeedbackLoop {
         const reading_frame = this.#runtime.pool.frame;
 
         /*
-         And which views it is about, by slot. The table is rebuilt every frame and the set of views
-         changes — a point light's faces are in the shadow budget one frame and out the next — so a
-         reading that asked for "the" table when it landed would hand one view's counters to another.
+         And which consumers it is about, by slot. The table is rebuilt every frame and the set of
+         views changes — a point light's faces are in the shadow budget one frame and out the next — so
+         a reading that asked for "the" table when it landed would hand one view's counters to another.
         */
         const slots = this.#runtime.frame_slots();
 
@@ -226,34 +225,22 @@ export class VGeoFeedbackLoop {
      * @param {Uint32Array} words
      * @param {ReturnType<vgeo_cut_feedback_layout>} layout the frame's own, not the current one
      * @param {number} reading_frame the frame this reading is about
-     * @param {VGeoViewCut[][]} slots the frame's views, by slot
+     * @param {VGeoFeedbackConsumer[][]} slots the frame's consumers, by slot
      */
     #apply(words, layout, reading_frame, slots) {
         for (let slot = 0; slot < slots.length; slot++) {
-            const base = vgeo_feedback_slot_stats(slot);
+            const consumers = slots[slot];
 
             /*
-             A slot two views shared — they were past the frame's layout — holds the sum of their
-             counters, so a remainder in it says one of them ran out and not which. Escalating both
-             would raise a bound that was never binding, for good; each has a slot of its own next
-             frame, and escalates from that.
+             The consumer owns what its counters mean; the loop's job here is the same as with a
+             want, which is to carry the reading to whoever it is about. A slot two consumers shared
+             — they were past the frame's layout — holds the sum of their counters, which each is
+             told.
             */
-            const remaining = slots[slot].length === 1 ? words[base + VGEO_CUT_STAT.QUEUE_REMAINING] : 0;
+            const shared = consumers.length > 1;
 
-            for (const view of slots[slot]) {
-                for (let i = 0; i < VGEO_CUT_STAT_COUNT; i++) {
-                    view.stats[i] = words[base + i];
-                }
-
-                /*
-                 One counter is not a statistic, it is an instruction. `QUEUE_REMAINING` is non-zero
-                 exactly when the descent ran out of wavefronts and abandoned subtrees it had not
-                 expanded — a hole in the picture rather than a coarser surface — and this is the only
-                 moment anything on the host learns it. The view owns what to do about it; the loop's
-                 job here is the same as with a want, which is to carry the reading to whoever it is
-                 about.
-                */
-                view.note_incomplete_descent(remaining, this.#runtime);
+            for (const consumer of consumers) {
+                consumer.read_feedback(words, vgeo_feedback_slot_stats(slot), shared, this.#runtime);
             }
         }
 

package/src/shade/renderer/geometry/virtual/runtime/VGeoViewCut.d.ts

@@ -173,23 +173,46 @@ export class VGeoViewCut {
      * @returns {boolean} whether the bound moved
      */
     note_incomplete_descent(remaining: number, runtime: GPUVirtualGeometryRuntime): boolean;
+    /**
+     * Take this view's slot of a reading: its counters, and what they say about its descent.
+     *
+     * One counter is not a statistic, it is an instruction. `QUEUE_REMAINING` is non-zero exactly
+     * when the descent ran out of wavefronts and abandoned subtrees it had not expanded — a hole in
+     * the picture rather than a coarser surface — and this is the only moment anything on the host
+     * learns it.
+     *
+     * A slot two views shared — they were past the frame's layout — holds the sum of their counters,
+     * so a remainder in it says one of them ran out and not which. Escalating both would raise a
+     * bound that was never binding, for good; each has a slot of its own next frame, and escalates
+     * from that.
+     *
+     * @param {Uint32Array} words the reading
+     * @param {number} base where this slot's counters start in it
+     * @param {boolean} shared whether another consumer shared the slot
+     * @param {GPUVirtualGeometryRuntime} runtime
+     */
+    read_feedback(words: Uint32Array, base: number, shared: boolean, runtime: GPUVirtualGeometryRuntime): void;
     /**
      * Publish the frame's shared settings and this view's own, as one uniform.
      *
      * 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.
+     * a second copy of `tau` is a second thing to forget to update. The slot's own fields are the
+     * runtime's to fill ({@link GPUVirtualGeometryRuntime#fill_slot_params}).
      *
      * @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
+     * @param {number} [options.tau] the threshold, for a cut whose records carry an error scale of their own rather
+     *   than a view's pixels; `runtime.tau × tau_scale` otherwise
      * @returns {void}
      */
-    write_params({ runtime, slot, coarsen }: {
+    write_params({ runtime, slot, coarsen, tau }: {
         runtime: GPUVirtualGeometryRuntime;
         slot: number;
         coarsen?: boolean;
+        tau?: number;
     }): void;
     destroy(): void;
     #private;

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

@@ -1 +1 @@
-{"version":3,"file":"VGeoViewCut.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/runtime/VGeoViewCut.js"],"names":[],"mappings":"AAsBA;;GAEG;AAEH;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH;IA6EI;;;;OAIG;IACH;QAH8B,MAAM;QACR,KAAK,GAAtB,MAAM;OAehB;IAhDD;;;;;;;OAOG;IACH,WAFU,MAAM,CAEF;IAed;;;;OAIG;IACH,OAFU,WAAW,CAEwB;IAsB7C;;;;OAIG;IACH,+BAEC;IAED;;OAEG;IACH,2BAEC;IAED;;OAEG;IACH,8BAEC;IAED;;;;OAIG;IACH,2BAEC;IAED;;OAEG;IACH,kCAEC;IAED;;;;;;;;;;;;;;;OAeG;IACH,kBAFa,IAAI,CAchB;IAED;;;;;;;;;;OAUG;IACH,mCAHW,MAAM,GACJ,IAAI,CAkBhB;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACH;QAL2B,KAAK,EAArB,MAAM;QACU,MAAM,EAAtB,MAAM;QACqB,iBAAiB,EAA5C,UAAU,MAAM,CAAC;QACf,IAAI,CAmBhB;IAED;;;;;;OAMG;IACH,0BAHW,yBAAyB,GACvB,MAAM,CAIlB;IAED;;;;OAIG;IACH,oCAEC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,mCAJW,MAAM,WACN,yBAAyB,GACvB,OAAO,CAgBnB;IAED;;;;;;;;;;;;OAYG;IACH;QAL8C,OAAO,EAA1C,yBAAyB;QACT,IAAI,EAApB,MAAM;QACY,OAAO,GAAzB,OAAO;QACL,IAAI,CAmChB;IAED,gBAIC;;CACJ;wCA5XY,OAAO,gCAAgC,EAAE,yBAAyB"}
+{"version":3,"file":"VGeoViewCut.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/runtime/VGeoViewCut.js"],"names":[],"mappings":"AAkBA;;GAEG;AAEH;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH;IAoFI;;;;OAIG;IACH;QAH8B,MAAM;QACR,KAAK,GAAtB,MAAM;OAehB;IAvDD;;;;;;;OAOG;IACH,WAFU,MAAM,CAEF;IAed;;;;OAIG;IACH,OAFU,WAAW,CAEwB;IA6B7C;;;;OAIG;IACH,+BAEC;IAED;;OAEG;IACH,2BAEC;IAED;;OAEG;IACH,8BAEC;IAED;;;;OAIG;IACH,2BAEC;IAED;;OAEG;IACH,kCAEC;IAED;;;;;;;;;;;;;;;OAeG;IACH,kBAFa,IAAI,CAchB;IAED;;;;;;;;;;OAUG;IACH,mCAHW,MAAM,GACJ,IAAI,CAkBhB;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACH;QAL2B,KAAK,EAArB,MAAM;QACU,MAAM,EAAtB,MAAM;QACqB,iBAAiB,EAA5C,UAAU,MAAM,CAAC;QACf,IAAI,CAmBhB;IAED;;;;;;OAMG;IACH,0BAHW,yBAAyB,GACvB,MAAM,CAIlB;IAED;;;;OAIG;IACH,oCAEC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,mCAJW,MAAM,WACN,yBAAyB,GACvB,OAAO,CAgBnB;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,qBALW,WAAW,QACX,MAAM,UACN,OAAO,WACP,yBAAyB,QAQnC;IAED;;;;;;;;;;;;;;;OAeG;IACH;QAP8C,OAAO,EAA1C,yBAAyB;QACT,IAAI,EAApB,MAAM;QACY,OAAO,GAAzB,OAAO;QACU,GAAG,GAApB,MAAM;QAEJ,IAAI,CAyBhB;IAED,gBAIC;;CACJ;wCAtZY,OAAO,gCAAgC,EAAE,yBAAyB"}

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

@@ -2,11 +2,7 @@ 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 } from "./layout/VGEO_CUT_STAT.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";
@@ -124,6 +120,13 @@ export class VGeoViewCut {
      */
     stats = new Uint32Array(VGEO_CUT_STAT_COUNT);
 
+    /**
+     * The params' fields as {@link write_params} last wrote them, kept so writing them allocates nothing.
+     *
+     * @type {Object}
+     */
+    #params_fields = {};
+
     /**
      * @param {Object} options
      * @param {GPUDevice} options.device
@@ -348,48 +351,67 @@ export class VGeoViewCut {
         return true;
     }
 
+    /**
+     * Take this view's slot of a reading: its counters, and what they say about its descent.
+     *
+     * One counter is not a statistic, it is an instruction. `QUEUE_REMAINING` is non-zero exactly
+     * when the descent ran out of wavefronts and abandoned subtrees it had not expanded — a hole in
+     * the picture rather than a coarser surface — and this is the only moment anything on the host
+     * learns it.
+     *
+     * A slot two views shared — they were past the frame's layout — holds the sum of their counters,
+     * so a remainder in it says one of them ran out and not which. Escalating both would raise a
+     * bound that was never binding, for good; each has a slot of its own next frame, and escalates
+     * from that.
+     *
+     * @param {Uint32Array} words the reading
+     * @param {number} base where this slot's counters start in it
+     * @param {boolean} shared whether another consumer shared the slot
+     * @param {GPUVirtualGeometryRuntime} runtime
+     */
+    read_feedback(words, base, shared, runtime) {
+        for (let i = 0; i < VGEO_CUT_STAT_COUNT; i++) {
+            this.stats[i] = words[base + i];
+        }
+
+        this.note_incomplete_descent(shared ? 0 : words[base + VGEO_CUT_STAT.QUEUE_REMAINING], runtime);
+    }
+
     /**
      * Publish the frame's shared settings and this view's own, as one uniform.
      *
      * 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.
+     * a second copy of `tau` is a second thing to forget to update. The slot's own fields are the
+     * runtime's to fill ({@link GPUVirtualGeometryRuntime#fill_slot_params}).
      *
      * @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
+     * @param {number} [options.tau] the threshold, for a cut whose records carry an error scale of their own rather
+     *   than a view's pixels; `runtime.tau × tau_scale` otherwise
      * @returns {void}
      */
-    write_params({ runtime, slot, coarsen = false }) {
+    write_params({ runtime, slot, coarsen = false, tau = undefined }) {
         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 * 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,
-            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.frame_tag_of(slot),
-            instance_capacity: runtime.instance_capacity,
-            meshlet_capacity: runtime.meshlet_capacity,
-            flags: (runtime.cull_enabled ? VGEO_CUT_FLAG_CULL : 0)
-                | (coarsen ? VGEO_CUT_FLAG_COARSEN : 0),
-        }, VGEO_CUT_PARAMS_STRUCT, this.#scratch, 0);
+        const params = runtime.fill_slot_params(this.#params_fields, slot);
+
+        params.tau = tau ?? runtime.tau * this.tau_scale;
+        params.projection_k = this.#projection_k;
+        params.distance_weight = this.#distance_weight;
+        params.queue_capacity = runtime.queue_capacity;
+        params.claim_word_count = runtime.claim_word_capacity;
+        params.descent_steps = runtime.descent_steps;
+        params.frontier_word_count = this.#frontier_word_count;
+        params.instance_capacity = runtime.instance_capacity;
+        params.meshlet_capacity = runtime.meshlet_capacity;
+        params.flags = (runtime.cull_enabled ? VGEO_CUT_FLAG_CULL : 0)
+            | (coarsen ? VGEO_CUT_FLAG_COARSEN : 0);
+
+        write_gpu_typed_buffer(params, VGEO_CUT_PARAMS_STRUCT, this.#scratch, 0);
 
         this.#device.queue.writeBuffer(
             this.#params, 0, this.#scratch, 0, VGEO_CUT_PARAMS_STRUCT.aligned_size

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

@@ -0,0 +1,14 @@
+/**
+ * What the cut's rule says about one cluster ({@link chunk_vgeo_cut_rule }'s `vg_cut_cluster`). A traversal acts on
+ * it: the camera's draws, wants and claims, a box cut takes the cluster's triangles.
+ */
+export type VGEO_CUT_VERDICT = number;
+export namespace VGEO_CUT_VERDICT {
+    let NONE: number;
+    let BELOW: number;
+    let TAKE: number;
+    let CLAMP: number;
+    let HELD: number;
+    let REFINE: number;
+}
+//# sourceMappingURL=VGEO_CUT_VERDICT.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"VGEO_CUT_VERDICT.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/runtime/cut/VGEO_CUT_VERDICT.js"],"names":[],"mappings":";;;;+BAMU,MAAM"}