@woosh/meep-engine 3.26.0 → 3.28.0

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

@@ -5,12 +5,13 @@ import { COLLECTION_U32_STRUCT_READ } from "../../../../gpu_primitive/COLLECTION
 import { COLLECTION_U32_STRUCT_WRITE } from "../../../../gpu_primitive/COLLECTION_U32_STRUCT_WRITE.js";
 import { ComputeShader } from "../../../../shader/ComputeShader.js";
 import { ShaderResourceSetDescriptor } from "../../../../shader/resource/ShaderResourceSetDescriptor.js";
+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";
-import { VGEO_PAGE_ROW_OFFSET } from "../layout/VGEO_PAGE_ROW_OFFSET.js";
 import { VGEO_CUT_PARAMS_STRUCT } from "./VGEO_CUT_PARAMS_STRUCT.js";
 import { VGEO_CUT_WORKGROUP_SIZE } from "./VGEO_CUT_WORKGROUP_SIZE.js";
 
@@ -53,7 +54,25 @@ const body = CodeChunk.from(
 fn main(@builtin(global_invocation_id) global_id: vec3<u32>) {
     let instance_slot = global_id.x;
 
-    if (instance_slot >= prefix_sums.count) {
+    /*
+     The same clamp the collect pass puts on its own input, one pass further along, because the
+     count that arrives here is produced the same way: \`shader_vgeo_cut_collect\` reserves a claim
+     width with an unconditional \`atomicAdd\` and bounds-checks only the element write, and the
+     prefix scan rewrites the elements and leaves the count untouched. So a frame that offered more
+     virtual instances than the collection holds hands this pass a count past the end of it, and —
+     as everywhere in the cut — the indirect dispatch is built from that count, so the overshoot
+     arrives as lanes.
+
+     One clamp covers both of this pass's reads: the scanned elements and the instance records are
+     sized from the same \`instance_capacity\`, so a slot past the end of one is past the end of the
+     other. A lane that ran anyway would take its root page row from whatever the bound range gives
+     it back rather than from an instance, and put *that* into the queue — a wavefront descending a
+     page on behalf of an instance the collect pass never wrote, claiming and touching it. The LRU
+     would then hold pages up for geometry nobody is looking at.
+     */
+    let instance_count = min(prefix_sums.count, arrayLength(&prefix_sums.elements));
+
+    if (instance_slot >= instance_count) {
         return;
     }
 
@@ -100,42 +119,18 @@ fn main(@builtin(global_invocation_id) global_id: vec3<u32>) {
      because it is also what stamps the root page as touched, and a root that never reports a touch
      is a root that ages out of the touch-LRU while it is on screen.
      */
-    let ordinal = vg_arena[
-        page_row * params.page_slot_words + ${VGEO_PAGE_ROW_OFFSET.ORDINAL}u
-    ];
-
-    let bit = claim_base + ordinal;
-
-    atomicOr(&claim[bit >> 5u], 1u << (bit & 31u));
-
-    atomicAdd(&feedback[${VGEO_FEEDBACK_OFFSET.STATS}u + ${VGEO_CUT_STAT.PAGES}u], 1u);
-
-    if (atomicExchange(&feedback[params.touch_stamp_base + page_row], 1u) == 0u) {
-        let touch_slot = atomicAdd(&feedback[${VGEO_FEEDBACK_OFFSET.TOUCH_COUNT}u], 1u);
-
-        if (touch_slot < params.touch_capacity) {
-            atomicStore(&feedback[params.touch_base + touch_slot], page_row);
-        }
-    }
-
-    let slot = atomicAdd(&queue_out.count, 1u);
-
-    if (slot >= params.queue_capacity) {
-        atomicAdd(
-            &feedback[${VGEO_FEEDBACK_OFFSET.STATS}u + ${VGEO_CUT_STAT.QUEUE_DROPPED}u], 1u
-        );
-
-        return;
-    }
-
-    let base = slot * 4u;
-
-    queue_out.elements[base] = instance_slot;
-    queue_out.elements[base + 1u] = page_row;
-    queue_out.elements[base + 2u] = 0u;
-    queue_out.elements[base + 3u] = 0u;
+    /*
+     Through the shared claim, and by slice rather than by instance record: the claim base was
+     written to the instance record two lines above and is still in a register here, so the
+     _at form spares the read back. The claim cannot fail — the root is pinned and the capacity
+     bound was taken above — but it is the same code the descent and the reseed run, which is
+     the point of taking it rather than open-coding the three atomics.
+    */
+    vg_claim_page_at(claim_base, capacity, page_row);
+
+    vg_queue_push_root(instance_slot, page_row);
 }
-`, []);
+`, [chunk_vgeo_cut_claim, chunk_vgeo_cut_queue]);
 
 export const shader_vgeo_cut_seed = ComputeShader.from({
     label: "VGeo cut seed",

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":"AA6gBA,qDAIG;8BA9gB2B,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":"AAu2BA,qDAIG;8BAx2B2B,qCAAqC"}