@woosh/meep-engine 3.58.0 → 3.60.0

package/src/shade/renderer/geometry/sdf/cards/shader_mesh_cards_raster_args.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Threads a workgroup of {@link shader_mesh_cards_raster_args}.
+ * @type {number}
+ */
+export const MESH_CARDS_RASTER_ARGS_WORKGROUP_SIZE: number;
+/**
+ * @type {WebGPUStruct}
+ */
+export const MESH_CARDS_RASTER_ARGS_SETTINGS: WebGPUStruct;
+/**
+ * Card capture by raster, step 1: a thread a run, writing its draw. The draw is every card of the
+ * layout times every meshlet of the geometry, as instances, at a meshlet's worth of vertices: the
+ * card count is the device's, so the draw follows it rather than {@link MESH_CARD_MAX}.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_mesh_cards_raster_args: ComputeShader;
+import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
+import { ComputeShader } from "../../../shader/ComputeShader.js";
+//# sourceMappingURL=shader_mesh_cards_raster_args.d.ts.map

package/src/shade/renderer/geometry/sdf/cards/shader_mesh_cards_raster_args.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shader_mesh_cards_raster_args.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/sdf/cards/shader_mesh_cards_raster_args.js"],"names":[],"mappings":"AAcA;;;GAGG;AACH,oDAFU,MAAM,CAEwC;AAExD;;GAEG;AACH,8CAFU,YAAY,CAKY;AAclC;;;;;;GAMG;AACH,4CAFU,aAAa,CAkCpB;6BAzE0B,sCAAsC;8BAJrC,kCAAkC"}

package/src/shade/renderer/geometry/sdf/cards/shader_mesh_cards_raster_args.js

@@ -0,0 +1,80 @@
+import { STRUCT_UNINDEXED_DRAW_COMMAND } from "../../../gpu_primitive/indirect/STRUCT_UNINDEXED_DRAW_COMMAND.js";
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../../../shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../../../shader/resource/ShaderResourceSetDescriptor.js";
+import { u32, vec4u } from "../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../../../shader/type/WebGPUArray.js";
+import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
+import { GEOMETRY_METADATA_STRUCT } from "../../GEOMETRY_METADATA_STRUCT.js";
+import { GEOMETRY_MESHLET_TRIANGLE_LIMIT } from "../../meshlet/GEOMETRY_MESHLET_TRIANGLE_LIMIT.js";
+import { MESH_SDF_HEADERS_RESOURCE, MESH_SDF_INDIRECTION_RESOURCE } from "../MESH_SDF_RESOURCES.js";
+import { chunk_mesh_cards } from "./chunk_mesh_cards.js";
+import { MESH_CARD_SETS_RESOURCE } from "./MESH_CARD_RESOURCES.js";
+import { MESH_CARD_SET_STRUCT } from "./MESH_CARD_SET_STRUCT.js";
+
+/**
+ * Threads a workgroup of {@link shader_mesh_cards_raster_args}.
+ * @type {number}
+ */
+export const MESH_CARDS_RASTER_ARGS_WORKGROUP_SIZE = 64;
+
+/**
+ * @type {WebGPUStruct}
+ */
+export const MESH_CARDS_RASTER_ARGS_SETTINGS = WebGPUStruct.from({
+    /** raster runs this frame */
+    run_count: u32,
+}, "MeshCardsRasterArgsSettings");
+
+const resources = new ShaderResourceSetDescriptor();
+
+resources.setImmediate("settings", MESH_CARDS_RASTER_ARGS_SETTINGS);
+
+resources.createGroup()
+    .add(MESH_SDF_HEADERS_RESOURCE)
+    .add(MESH_SDF_INDIRECTION_RESOURCE)
+    .add(MESH_CARD_SETS_RESOURCE)
+    .addStorageBuffer("mesh_card_raster_runs", WebGPUArray.from(vec4u))
+    .addStorageBuffer("geometries", WebGPUArray.from(GEOMETRY_METADATA_STRUCT))
+    .addStorageBuffer("mesh_card_raster_draws", WebGPUArray.from(STRUCT_UNINDEXED_DRAW_COMMAND), true);
+
+/**
+ * Card capture by raster, step 1: a thread a run, writing its draw. The draw is every card of the
+ * layout times every meshlet of the geometry, as instances, at a meshlet's worth of vertices: the
+ * card count is the device's, so the draw follows it rather than {@link MESH_CARD_MAX}.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_mesh_cards_raster_args = ComputeShader.from({
+    label: "Mesh Cards Raster Args",
+    resources,
+    body: CodeChunk.from(
+        //language=WGSL
+        `
+@compute @workgroup_size(${MESH_CARDS_RASTER_ARGS_WORKGROUP_SIZE})
+fn main(@builtin(global_invocation_id) id: vec3<u32>) {
+    let run = id.x;
+
+    if (run >= settings.run_count) {
+        return;
+    }
+
+    let card_set = mesh_card_sets[mesh_card_raster_runs[run].y];
+    let cards = mesh_sdf_indirection[mesh_sdf_headers[card_set.geometry].cards + MESH_CARD_LAYOUT_CARD_COUNT];
+
+    var draw: ${STRUCT_UNINDEXED_DRAW_COMMAND.wgsl_ref};
+
+    draw.vertexCount = ${GEOMETRY_MESHLET_TRIANGLE_LIMIT * 3}u;
+    draw.instanceCount = min(cards, MESH_CARD_MAX) * geometries[card_set.geometry].meshlets_count;
+    draw.firstVertex = 0u;
+    draw.firstInstance = 0u;
+
+    mesh_card_raster_draws[run] = draw;
+}
+`, [
+            STRUCT_UNINDEXED_DRAW_COMMAND.declaration_chunk,
+            GEOMETRY_METADATA_STRUCT.declaration_chunk,
+            MESH_CARD_SET_STRUCT.declaration_chunk,
+            chunk_mesh_cards,
+        ]),
+});

package/src/shade/renderer/geometry/sdf/cards/shader_mesh_cards_raster_scatter.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @type {WebGPUStruct}
+ */
+export const MESH_CARDS_RASTER_SCATTER_SETTINGS: WebGPUStruct;
+/**
+ * Card capture by raster, step 3: a thread a texel of each page of the frame's raster runs, a whole
+ * card set each, moving the texel from its card's cell of the scratch into the page's atlas tile.
+ * The thread → (run, page, texel) mapping is the trace's: the runs' first threads are ascending.
+ *
+ * Page texel (x, y) of column (u, v) is lattice point (7u + x, 7v + y) of the card, texel
+ * (7u + x, 7v + y) of its cell: a page's last texel and the next column's first are one texel.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_mesh_cards_raster_scatter: ComputeShader;
+import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
+import { ComputeShader } from "../../../shader/ComputeShader.js";
+//# sourceMappingURL=shader_mesh_cards_raster_scatter.d.ts.map

package/src/shade/renderer/geometry/sdf/cards/shader_mesh_cards_raster_scatter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shader_mesh_cards_raster_scatter.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/sdf/cards/shader_mesh_cards_raster_scatter.js"],"names":[],"mappings":"AAcA;;GAEG;AACH,iDAFU,YAAY,CASe;AAgBrC;;;;;;;;;GASG;AACH,+CAFU,aAAa,CAgEpB;6BA1G0B,sCAAsC;8BAJrC,kCAAkC"}

package/src/shade/renderer/geometry/sdf/cards/shader_mesh_cards_raster_scatter.js

@@ -0,0 +1,113 @@
+import { chunk_index_to_grid2d } from "../../../shader/chunk/grid/chunk_index_to_grid2d.js";
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../../../shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../../../shader/resource/ShaderResourceSetDescriptor.js";
+import { u32, vec4u } from "../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../../../shader/type/WebGPUArray.js";
+import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
+import { MESH_SDF_BAKE_WORKGROUP_SIZE } from "../bake/MESH_SDF_BAKE.js";
+import { MESH_SDF_HEADERS_RESOURCE, MESH_SDF_INDIRECTION_RESOURCE } from "../MESH_SDF_RESOURCES.js";
+import { chunk_mesh_cards } from "./chunk_mesh_cards.js";
+import { MESH_CARD_SETS_RESOURCE } from "./MESH_CARD_RESOURCES.js";
+import { MESH_CARD_SET_STRUCT } from "./MESH_CARD_SET_STRUCT.js";
+import { MESH_CARD_RASTER_CELLS_X } from "./mesh_cards_raster_pass_descriptor.js";
+
+/**
+ * @type {WebGPUStruct}
+ */
+export const MESH_CARDS_RASTER_SCATTER_SETTINGS = WebGPUStruct.from({
+    /** raster runs this frame */
+    run_count: u32,
+    /** texels over every run's pages: the threads that do work */
+    thread_count: u32,
+    /** workgroups along x, the rest folded into y */
+    groups_x: u32,
+}, "MeshCardsRasterScatterSettings");
+
+const resources = new ShaderResourceSetDescriptor();
+
+resources.setImmediate("settings", MESH_CARDS_RASTER_SCATTER_SETTINGS);
+
+resources.createGroup()
+    .add(MESH_SDF_HEADERS_RESOURCE)
+    .add(MESH_SDF_INDIRECTION_RESOURCE)
+    .add(MESH_CARD_SETS_RESOURCE)
+    .addStorageBuffer("mesh_card_raster_runs", WebGPUArray.from(vec4u))
+    .addTexture("mesh_card_raster_albedo", "float", "2d")
+    .addTexture("mesh_card_raster_emissive", "float", "2d")
+    .addStorageTexture("mesh_card_albedo", "rgba8unorm", "2d", "write-only")
+    .addStorageTexture("mesh_card_emissive", "rgba8unorm", "2d", "write-only");
+
+/**
+ * Card capture by raster, step 3: a thread a texel of each page of the frame's raster runs, a whole
+ * card set each, moving the texel from its card's cell of the scratch into the page's atlas tile.
+ * The thread → (run, page, texel) mapping is the trace's: the runs' first threads are ascending.
+ *
+ * Page texel (x, y) of column (u, v) is lattice point (7u + x, 7v + y) of the card, texel
+ * (7u + x, 7v + y) of its cell: a page's last texel and the next column's first are one texel.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_mesh_cards_raster_scatter = ComputeShader.from({
+    label: "Mesh Cards Raster Scatter",
+    resources,
+    body: CodeChunk.from(
+        //language=WGSL
+        `
+@compute @workgroup_size(${MESH_SDF_BAKE_WORKGROUP_SIZE})
+fn main(
+    @builtin(workgroup_id) workgroup_id: vec3<u32>,
+    @builtin(local_invocation_index) lane: u32,
+) {
+    let thread = (workgroup_id.y * settings.groups_x + workgroup_id.x) * ${MESH_SDF_BAKE_WORKGROUP_SIZE}u + lane;
+
+    if (thread >= settings.thread_count) {
+        return;
+    }
+
+    // the run the thread falls in: the last whose first thread is at or below it
+    var low = 0u;
+    var high = settings.run_count;
+
+    while (high - low > 1u) {
+        let middle = (low + high) / 2u;
+
+        if (mesh_card_raster_runs[middle].x <= thread) {
+            low = middle;
+        } else {
+            high = middle;
+        }
+    }
+
+    let run = mesh_card_raster_runs[low];
+    let card_set = mesh_card_sets[run.y];
+
+    let page_texels = MESH_CARD_PAGE_TEXELS * MESH_CARD_PAGE_TEXELS;
+    let within = thread - run.x;
+    let page = within / page_texels;
+    let texel = vec2<u32>(within % MESH_CARD_PAGE_TEXELS, (within / MESH_CARD_PAGE_TEXELS) % MESH_CARD_PAGE_TEXELS);
+
+    let header = mesh_sdf_headers[card_set.geometry];
+    let columns = mesh_sdf_indirection[header.cards + MESH_CARD_LAYOUT_COLUMN_COUNT];
+
+    // the page list follows the tables
+    let listed = mesh_sdf_indirection[header.cards + MESH_CARD_LAYOUT_TABLES + columns + page];
+    let card = listed >> 16u;
+    let column = vec2<u32>(listed & 0xffu, (listed >> 8u) & 0xffu);
+
+    let corner = vec2<u32>(run.z & 0xffffu, run.z >> 16u)
+        + vec2<u32>(card % ${MESH_CARD_RASTER_CELLS_X}u, card / ${MESH_CARD_RASTER_CELLS_X}u) * run.w;
+    let drawn = corner + column * MESH_SDF_BRICK_VOXELS + texel;
+
+    let tiles_per_row = textureDimensions(mesh_card_albedo).x / MESH_CARD_PAGE_TEXELS;
+    let stored = index_to_grid2d(card_set.page_base + page, tiles_per_row) * MESH_CARD_PAGE_TEXELS + texel;
+
+    textureStore(mesh_card_albedo, stored, textureLoad(mesh_card_raster_albedo, drawn, 0));
+    textureStore(mesh_card_emissive, stored, textureLoad(mesh_card_raster_emissive, drawn, 0));
+}
+`, [
+            MESH_CARD_SET_STRUCT.declaration_chunk,
+            chunk_mesh_cards,
+            chunk_index_to_grid2d,
+        ]),
+});

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"}