@woosh/meep-engine 3.69.0 → 3.70.0

package/src/shade/renderer/global_illumination/probe_clipmap/brick/mesh/MESH_BRICK.d.ts

@@ -4,15 +4,14 @@
  */
 export const MESH_BRICK_BATCH: number;
 /**
- * Nodes a walk keeps on a level of its frontier; the rest are handed on to the next round. Eight
- * nodes a lane a level at most.
+ * Nodes a walk keeps on a level of its frontier; the rest are handed on to the next round. A node
+ * gives a level eight at most.
  *
- * Measured on Zorah's TLAS (12,608 leaves, 27 levels deep), the widest level of a cell's walk is
- * 758 nodes at cascade 2 and 2,410 at cascade 5; at this frontier and tasks of
- * {@link MESH_BRICK_BATCH} nodes every walk ends in its third round. The frontier is 4 KiB of the
- * walk's 5.1 KiB of workgroup memory, and the iGPU's walk is bound by how many workgroups that memory
- * lets in: against 1,024 nodes, which ended every walk in its second round, the walks of a full
- * rebuild of Zorah's windows went from 71.1 to 43.0 ms there, and stayed even on the 4090.
+ * An integrated GPU's walk is bound by how many workgroups its memory lets in, and the frontier's two
+ * lists are the larger part of that memory. Measured on Zorah's TLAS (12,597 leaves) over the frames
+ * in which the windows fill: at 512 nodes every walk ends in its second
+ * round and the walks take 842 ms there in all; at 256, in its third, 448; at 128, in its fourth,
+ * 474.
  * @type {number}
  */
 export const MESH_BRICK_FRONTIER: number;
@@ -33,8 +32,8 @@ export const MESH_BRICK_RECORD_WORDS: number;
 export const MESH_BRICK_ROUNDS: number;
 /**
  * Rounds a walk of a TLAS over at most 2^20 leaves can need. A task starts from at most
- * {@link MESH_BRICK_BATCH} nodes and hands on only past {@link MESH_BRICK_FRONTIER}, eight times as
- * many, so a chain of k rounds needs a level 64·8^(k-1) nodes wide; 2^20 leaves allow k = 6.
+ * {@link MESH_BRICK_BATCH} nodes and hands on only past {@link MESH_BRICK_FRONTIER}, four times as
+ * many, so a chain of k rounds needs a level 64·4^(k-1) nodes wide; 2^20 leaves allow k = 8.
  * @type {number}
  */
 export const MESH_BRICK_ROUND_LIMIT: number;

package/src/shade/renderer/global_illumination/probe_clipmap/brick/mesh/MESH_BRICK.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MESH_BRICK.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/brick/mesh/MESH_BRICK.js"],"names":[],"mappings":"AAkBA;;;GAGG;AACH,+BAFU,MAAM,CAE0C;AAE1D;;;;;;;;;;;GAWG;AACH,kCAFU,MAAM,CAEuB;AAEvC;;;GAGG;AACH,6CAFU,MAAM,CAEgC;AAEhD;;;GAGG;AACH,sCAFU,MAAM,CAEyE;AAEzF;;;GAGG;AACH,gCAFU,MAAM,CAEmB;AAEnC;;;;;GAKG;AACH,qCAFU,MAAM,CAEiI;AASjJ;;;;;GAKG;AACH,2CAFU,MAAM,CAEuD;AAEvE;;;GAGG;AACH,2CAFU,MAAM,CAE6D;AAE7E;;;GAGG;AACH,sCAFU,MAAM,CAEyB;AAEzC;;;;;GAKG;AACH,yCAFU,MAAM,CAE4B;AAO5C;;;GAGG;AACH,2CAFU,MAAM,CAE8B;AAE9C;;;GAGG;AACH,mDAFU,MAAM,CAEsC;AAEtD;;;GAGG;AACH,yCAFU,MAAM,CAE4B;AAE5C;;;GAGG;AACH,iDAFU,MAAM,CAEoC;AAEpD;;;GAGG;AACH,gDAFU,MAAM,CAEmC;AAEnD;;;GAGG;AACH,gDAFU,MAAM,CAEmC;AAEnD;;;GAGG;AACH,iDAFU,MAAM,CAEoC;AAEpD;;;GAGG;AACH,gDAFU,MAAM,CAEmC;AAEnD;;;GAGG;AACH,8CAFU,MAAM,CAEiC;AAEjD;;;GAGG;AACH,iDAFU,MAAM,CAEoC;AAEpD;;;GAGG;AACH,yCAFU,MAAM,CAE6B;AAE7C;;;GAGG;AACH,yCAFU,MAAM,CAEqD;AAErE;;;;GAIG;AACH,uCAFU,MAAM,CAEuD;AAEvE;;;GAGG;AACH,8CAFU,MAAM,CAE4D;AAE5E;;;GAGG;AACH,8CAFU,MAAM,CAEmE;AAEnF;;;GAGG;AACH,0CAFU,MAAM,CAE+D;AAE/E;;;GAGG;AACH,gDAFU,MAAM,CAEiE;AAEjF;;;GAGG;AACH,uCAFU,MAAM,CAE8D"}
+{"version":3,"file":"MESH_BRICK.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/brick/mesh/MESH_BRICK.js"],"names":[],"mappings":"AAkBA;;;GAGG;AACH,+BAFU,MAAM,CAE0C;AAE1D;;;;;;;;;;GAUG;AACH,kCAFU,MAAM,CAEuB;AAEvC;;;GAGG;AACH,6CAFU,MAAM,CAEgC;AAEhD;;;GAGG;AACH,sCAFU,MAAM,CAEyE;AAEzF;;;GAGG;AACH,gCAFU,MAAM,CAEmB;AAEnC;;;;;GAKG;AACH,qCAFU,MAAM,CAEiI;AASjJ;;;;;GAKG;AACH,2CAFU,MAAM,CAEuD;AAEvE;;;GAGG;AACH,2CAFU,MAAM,CAE6D;AAE7E;;;GAGG;AACH,sCAFU,MAAM,CAEyB;AAEzC;;;;;GAKG;AACH,yCAFU,MAAM,CAE4B;AAO5C;;;GAGG;AACH,2CAFU,MAAM,CAE8B;AAE9C;;;GAGG;AACH,mDAFU,MAAM,CAEsC;AAEtD;;;GAGG;AACH,yCAFU,MAAM,CAE4B;AAE5C;;;GAGG;AACH,iDAFU,MAAM,CAEoC;AAEpD;;;GAGG;AACH,gDAFU,MAAM,CAEmC;AAEnD;;;GAGG;AACH,gDAFU,MAAM,CAEmC;AAEnD;;;GAGG;AACH,iDAFU,MAAM,CAEoC;AAEpD;;;GAGG;AACH,gDAFU,MAAM,CAEmC;AAEnD;;;GAGG;AACH,8CAFU,MAAM,CAEiC;AAEjD;;;GAGG;AACH,iDAFU,MAAM,CAEoC;AAEpD;;;GAGG;AACH,yCAFU,MAAM,CAE6B;AAE7C;;;GAGG;AACH,yCAFU,MAAM,CAEqD;AAErE;;;;GAIG;AACH,uCAFU,MAAM,CAEuD;AAEvE;;;GAGG;AACH,8CAFU,MAAM,CAE4D;AAE5E;;;GAGG;AACH,8CAFU,MAAM,CAEmE;AAEnF;;;GAGG;AACH,0CAFU,MAAM,CAE+D;AAE/E;;;GAGG;AACH,gDAFU,MAAM,CAEiE;AAEjF;;;GAGG;AACH,uCAFU,MAAM,CAE8D"}

package/src/shade/renderer/global_illumination/probe_clipmap/brick/mesh/MESH_BRICK.js

@@ -23,18 +23,17 @@ import { BRICK_CELL_WORKGROUP_SIZE } from "../BRICK_CLIPMAP.js";
 export const MESH_BRICK_BATCH = BRICK_CELL_WORKGROUP_SIZE;
 
 /**
- * Nodes a walk keeps on a level of its frontier; the rest are handed on to the next round. Eight
- * nodes a lane a level at most.
+ * Nodes a walk keeps on a level of its frontier; the rest are handed on to the next round. A node
+ * gives a level eight at most.
  *
- * Measured on Zorah's TLAS (12,608 leaves, 27 levels deep), the widest level of a cell's walk is
- * 758 nodes at cascade 2 and 2,410 at cascade 5; at this frontier and tasks of
- * {@link MESH_BRICK_BATCH} nodes every walk ends in its third round. The frontier is 4 KiB of the
- * walk's 5.1 KiB of workgroup memory, and the iGPU's walk is bound by how many workgroups that memory
- * lets in: against 1,024 nodes, which ended every walk in its second round, the walks of a full
- * rebuild of Zorah's windows went from 71.1 to 43.0 ms there, and stayed even on the 4090.
+ * An integrated GPU's walk is bound by how many workgroups its memory lets in, and the frontier's two
+ * lists are the larger part of that memory. Measured on Zorah's TLAS (12,597 leaves) over the frames
+ * in which the windows fill: at 512 nodes every walk ends in its second
+ * round and the walks take 842 ms there in all; at 256, in its third, 448; at 128, in its fourth,
+ * 474.
  * @type {number}
  */
-export const MESH_BRICK_FRONTIER = 512;
+export const MESH_BRICK_FRONTIER = 256;
 
 /**
  * Words of a record's header: its build slot, then how many entries it holds.
@@ -56,8 +55,8 @@ export const MESH_BRICK_ROUNDS = 2;
 
 /**
  * Rounds a walk of a TLAS over at most 2^20 leaves can need. A task starts from at most
- * {@link MESH_BRICK_BATCH} nodes and hands on only past {@link MESH_BRICK_FRONTIER}, eight times as
- * many, so a chain of k rounds needs a level 64·8^(k-1) nodes wide; 2^20 leaves allow k = 6.
+ * {@link MESH_BRICK_BATCH} nodes and hands on only past {@link MESH_BRICK_FRONTIER}, four times as
+ * many, so a chain of k rounds needs a level 64·4^(k-1) nodes wide; 2^20 leaves allow k = 8.
  * @type {number}
  */
 export const MESH_BRICK_ROUND_LIMIT = 1 + Math.ceil(Math.log2((1 << 20) / MESH_BRICK_BATCH) / Math.log2(MESH_BRICK_FRONTIER / MESH_BRICK_BATCH));

package/src/shade/renderer/global_illumination/probe_clipmap/brick/mesh/chunk_mesh_brick_walk.d.ts

@@ -13,8 +13,8 @@
  * An iteration of a level appends the children it finds to the next level's list at places `start`
  * to `end`, as their reservations came; the frontier keeps the places below
  * {@link MESH_BRICK_FRONTIER}, and every child at or past it is handed on, at its place counted from
- * whichever is later of `start` and the frontier. An iteration appends two children a lane at most,
- * so it hands on at most twice {@link MESH_BRICK_BATCH}.
+ * whichever is later of `start` and the frontier. An iteration appends eight children a lane at most,
+ * so it hands on at most eight times {@link MESH_BRICK_BATCH}.
  *
  * @type {CodeChunk}
  */

package/src/shade/renderer/global_illumination/probe_clipmap/brick/mesh/chunk_mesh_brick_walk.js

@@ -26,8 +26,8 @@ import {
  * An iteration of a level appends the children it finds to the next level's list at places `start`
  * to `end`, as their reservations came; the frontier keeps the places below
  * {@link MESH_BRICK_FRONTIER}, and every child at or past it is handed on, at its place counted from
- * whichever is later of `start` and the frontier. An iteration appends two children a lane at most,
- * so it hands on at most twice {@link MESH_BRICK_BATCH}.
+ * whichever is later of `start` and the frontier. An iteration appends eight children a lane at most,
+ * so it hands on at most eight times {@link MESH_BRICK_BATCH}.
  *
  * @type {CodeChunk}
  */

package/src/shade/renderer/global_illumination/probe_clipmap/brick/mesh/shader_mesh_brick_gather.d.ts

@@ -7,9 +7,10 @@ export const MESH_BRICK_GATHER_SETTINGS: WebGPUStruct;
  * whose box comes within the band of a taken cell, gathered whole, a workgroup a walk.
  *
  * A walk expands the TLAS a level at a time, as the cooperative query does (`chunk_bvh_query_aabb_cooperative`):
- * each node of the level is tested by a lane against the cell grown by the cascade's band, the children
- * of an overlapping internal node go on the next level, and an overlapping leaf is a row when
- * `mesh_brick_accept` takes it. Nothing is dropped:
+ * each node of the level is read by a lane, and its eight slots tested against the cell grown by the
+ * cascade's band. The child nodes of the slots the box meets go on the next level. An instance in a
+ * slot the box meets is a row when its own box meets it too — a slot's is the instance's rounded outward
+ * to the node's grid — and `mesh_brick_accept` takes it. Nothing is dropped:
  * - a level keeps {@link MESH_BRICK_FRONTIER} nodes, and the children that fall past them are handed on in
  *   task records of up to {@link MESH_BRICK_BATCH} nodes, each a walk of the next round, which this same
  *   kernel runs from them;
@@ -26,12 +27,15 @@ export const MESH_BRICK_GATHER_SETTINGS: WebGPUStruct;
  * a command dispatches was written this frame.
  *
  * An iteration of a level costs the workgroup a barrier and a `workgroupUniformLoad`, and a barrier
- * more after one whose hand-off copied records out: lane 0 hands every lane where the next iteration's
- * children start and, on the level's last, how many nodes the next level holds.
+ * more after one whose hand-off copied rows out: lane 0 hands every lane where the next iteration's
+ * children start and, on the level's last, how many nodes the next level holds. A lane writes its own
+ * children past the frontier straight into the task records the hand-off kept for them.
  *
- * Per lane and level, at most {@link MESH_BRICK_FRONTIER} / {@link MESH_BRICK_BATCH} node reads, accepts
- * and appends, over at most {@link BVH_QUERY_AABB_LEVEL_BUDGET} levels; per iteration, two task entries
- * and two batch entries copied at most.
+ * Per lane and level, at most {@link MESH_BRICK_FRONTIER} / {@link MESH_BRICK_BATCH} node reads, each
+ * with at most eight accepts and eight appends of either kind, over at most
+ * {@link BVH_QUERY_AABB_LEVEL_BUDGET} levels — a budget for a binary tree, a third of which a tree of
+ * three binary levels a node needs; per iteration, eight task entries written and nine batch entries
+ * copied at most.
  *
  * @type {ComputeShader}
  */

package/src/shade/renderer/global_illumination/probe_clipmap/brick/mesh/shader_mesh_brick_gather.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_mesh_brick_gather.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/brick/mesh/shader_mesh_brick_gather.js"],"names":[],"mappings":"AAyCA;;GAEG;AACH,yCAFU,YAAY,CAeQ;AA0V9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,uCAFU,aAAa,CAMpB;6BApa0B,yCAAyC;8BAJxC,qCAAqC"}
+{"version":3,"file":"shader_mesh_brick_gather.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/brick/mesh/shader_mesh_brick_gather.js"],"names":[],"mappings":"AA4CA;;GAEG;AACH,yCAFU,YAAY,CAeQ;AAoY9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,uCAFU,aAAa,CAMpB;6BAld0B,yCAAyC;8BAJxC,qCAAqC"}

package/src/shade/renderer/global_illumination/probe_clipmap/brick/mesh/shader_mesh_brick_gather.js

@@ -1,13 +1,16 @@
 import { assert } from "../../../../../../core/assert.js";
 import { WebGPUExtensionType } from "../../../../../descriptor/WebGPUExtensionType.js";
 import { MESH_SDF_HEADERS_RESOURCE } from "../../../../geometry/sdf/MESH_SDF_RESOURCES.js";
-import { BVH2_NODE_STRUCT } from "../../../../shader/chunk/bvh/BVH2_NODE_STRUCT.js";
-import { BVH_NULL_NODE_DEFINITION } from "../../../../shader/chunk/bvh/BVH_NULL_NODE_DEFINITION.js";
-import { BVH_STRUCT } from "../../../../shader/chunk/bvh/BVH_STRUCT.js";
+import { chunk_scene_database_access } from "../../../../scene/chunk_scene_database_access.js";
+import { BVH8_INODE_STRUCT } from "../../../../shader/chunk/bvh/bvh8/webgpu/BVH8_INODE_STRUCT.js";
 import {
-    BVH_QUERY_AABB_LEVEL_BUDGET,
-    chunk_bvh_query_aabb_frontier
-} from "../../../../shader/chunk/bvh/chunk_bvh_query_aabb_frontier.js";
+    chunk_bvh8_node_slot_distances
+} from "../../../../shader/chunk/bvh/bvh8/webgpu/chunk_bvh8_node_slot_distances.js";
+import { BVH8_TREE_TYPE, chunk_bvh8_tree_read } from "../../../../shader/chunk/bvh/bvh8/webgpu/chunk_bvh8_tree_read.js";
+import { BVH_QUERY_AABB_LEVEL_BUDGET } from "../../../../shader/chunk/bvh/chunk_bvh_query_aabb_frontier.js";
+import {
+    chunk_aabb3_intersects_aabb3
+} from "../../../../shader/chunk/geometry/aabb3/chunk_aabb3_intersects_aabb3.js";
 import { CLIPMAP_LEVEL_ARRAY } from "../../../../shader/chunk/clipmap/CLIPMAP_LEVEL_STRUCT.js";
 import { chunk_folded_workgroup_index } from "../../../../shader/chunk/grid/chunk_folded_workgroup_index.js";
 import {
@@ -76,17 +79,15 @@ resources.createGroup()
     .addStorageBuffer("mesh_brick_resolves", WebGPUArray.u32, true);
 
 resources.createGroup()
-    .addStorageBuffer("tlas", BVH_STRUCT)
+    .addStorageBuffer("tlas", BVH8_TREE_TYPE)
     .addStorageBuffer("scene_database", WebGPUArray.from(u32))
     .add(MESH_SDF_HEADERS_RESOURCE);
 
 const body = CodeChunk.from(
     //language=WGSL
     `
-/** children an iteration finds at most: two a lane */
-const MESH_BRICK_WALK_SPILL = ${2 * MESH_BRICK_BATCH}u;
-/** rows waiting for their batch: fewer than a batch, and an iteration's at most */
-const MESH_BRICK_WALK_ROWS = ${2 * MESH_BRICK_BATCH}u;
+/** rows waiting for their batch: fewer than a batch, and an iteration's at most, eight a lane */
+const MESH_BRICK_WALK_ROWS = ${9 * MESH_BRICK_BATCH}u;
 
 /** what lane 0 hands the workgroup after an iteration */
 struct MeshBrickWalkHandoff {
@@ -107,8 +108,6 @@ struct MeshBrickWalkHandoff {
 var<workgroup> walk_frontier: array<array<u32, MESH_BRICK_FRONTIER>, 2>;
 // appends asked of each list; past the frontier they were handed on
 var<workgroup> walk_reserved: array<atomic<u32>, 2>;
-// the iteration's children past the frontier, on their way to task records
-var<workgroup> walk_spill: array<u32, MESH_BRICK_WALK_SPILL>;
 // accepted rows, a ring from the first not yet in a batch
 var<workgroup> walk_rows: array<u32, MESH_BRICK_WALK_ROWS>;
 var<workgroup> walk_rows_reserved: atomic<u32>;
@@ -117,10 +116,6 @@ var<workgroup> walk_rows_reserved: atomic<u32>;
 var<workgroup> walk_task: vec3<u32>;
 var<workgroup> walk_handoff: MeshBrickWalkHandoff;
 
-fn bvh_node(index: u32) -> ${BVH2_NODE_STRUCT.wgsl_ref} {
-    return tlas.nodes[index];
-}
-
 /** lane 0: a flag of the cell's for the frame; the first lists the cell for the resolve */
 fn mesh_brick_walk_flag(build: u32, flag: u32) {
     let flags = atomicOr(&mesh_brick_accumulators[mesh_brick_accumulator(build) + MESH_BRICK_ACCUMULATOR_FLAGS], flag);
@@ -202,14 +197,6 @@ fn mesh_brick_walk_tasks(build: u32, spilled: u32) -> vec2<u32> {
     return tasks;
 }
 
-fn mesh_brick_walk_place(next: u32, slot: u32, start: u32, child: u32) {
-    if (slot < MESH_BRICK_FRONTIER) {
-        walk_frontier[next][slot] = child;
-    } else {
-        walk_spill[mesh_brick_walk_spill_index(slot, start)] = child;
-    }
-}
-
 @compute @workgroup_size(${BRICK_CELL_WORKGROUP_SIZE})
 fn main(
     @builtin(workgroup_id) workgroup_id: vec3<u32>,
@@ -221,7 +208,8 @@ fn main(
     if (lane == 0u) {
         var walks: u32;
         var build = index;
-        var roots = select(1u, 0u, tlas.root == BVH_NULL_NODE);
+        // a scene of no instances has nothing to walk
+        var roots = select(1u, 0u, bvh8_tree_leaf_count(&tlas) == 0u);
 
         if (settings.round == 0u) {
             walks = brick_take[BRICK_TAKE_COUNT];
@@ -257,12 +245,15 @@ fn main(
     let at = brick_provider_cell(brick_provider_key(build, settings.ring_capacity), settings.resolution);
 
     // every instance whose box comes within the band of the cell
-    let query = array<f32, 6>(at.corner.x - at.band, at.corner.y - at.band, at.corner.z - at.band, at.far.x + at.band, at.far.y + at.band, at.far.z + at.band);
+    let query_low = at.corner - vec3<f32>(at.band);
+    let query_high = at.far + vec3<f32>(at.band);
+    let query = array<f32, 6>(query_low.x, query_low.y, query_low.z, query_high.x, query_high.y, query_high.z);
 
     // the first level's nodes, each read back by the lane that wrote it
     if (settings.round == 0u) {
         if (lane == 0u) {
-            walk_frontier[0][0] = tlas.root;
+            // the root
+            walk_frontier[0][0] = 0u;
         }
     } else if (lane < task.z) {
         walk_frontier[0][lane] = mesh_brick_tasks[mesh_brick_task_in(index) + MESH_BRICK_RECORD_HEADER_WORDS + lane];
@@ -271,7 +262,7 @@ fn main(
     var expand_count = task.z;
     // lane 0's: the rows handed to batches so far
     var rows_taken = 0u;
-    // the last hand-off copied out of the spill and the ring, which the next iteration fills again
+    // the last hand-off copied rows out of the ring, which the next iteration fills again
     var copied = false;
 
     for (var level = 0u; level < ${BVH_QUERY_AABB_LEVEL_BUDGET}u && expand_count != 0u; level++) {
@@ -285,15 +276,33 @@ fn main(
         for (var iteration = 0u; iteration < iterations; iteration++) {
             let slot = iteration * MESH_BRICK_BATCH + lane;
 
-            var node: ${BVH2_NODE_STRUCT.wgsl_ref};
-            var kind = BVH_QUERY_AABB_SKIP;
+            var node: ${BVH8_INODE_STRUCT.wgsl_ref};
+            // of the node's slots: the child nodes the cell's box meets, a bit a slot
+            var children = 0u;
+            // and the instances taken, a bit each of the node's run
+            var taken = 0u;
 
             if (slot < expand_count) {
-                node = bvh_node(walk_frontier[list][slot]);
-                kind = bvh_query_aabb_classify(node.bounds, node.child_1, query);
+                node = bvh8_tree_read_node(&tlas, walk_frontier[list][slot]);
+
+                let meeting = bvh8_node_slots_meeting(node, query_low, query_high);
+
+                children = meeting & (node.data[0].w >> 24u);
 
-                if (kind == BVH_QUERY_AABB_LEAF && !mesh_brick_accept(node.child_2, node.bounds, at.voxel)) {
-                    kind = BVH_QUERY_AABB_SKIP;
+                var run = bvh8_slot_runs_of(bvh8_node_slot_runs(node), meeting);
+
+                while (run != 0u) {
+                    let offset = countTrailingZeros(run);
+
+                    run &= run - 1u;
+
+                    // a slot's box is its instance's rounded outward to the node's grid: the row's own box decides
+                    let row = bvh8_tree_read_payload(&tlas, node, offset);
+                    let box = scene_read_mesh(&scene_database, row).bounding_box;
+
+                    if (aabb3_intersects_aabb3(box, query) && mesh_brick_accept(row, box, at.voxel)) {
+                        taken |= 1u << offset;
+                    }
                 }
             }
 
@@ -302,16 +311,38 @@ fn main(
             }
 
             // every lane reserves, asking or not, so the subgroup operations stay uniform
-            let child = subgroup_reserve_workgroup(&walk_reserved[next], select(0u, 2u, kind == BVH_QUERY_AABB_DESCEND));
-            let row = subgroup_reserve_workgroup(&walk_rows_reserved, select(0u, 1u, kind == BVH_QUERY_AABB_LEAF));
+            let child = subgroup_reserve_workgroup(&walk_reserved[next], countOneBits(children));
+            let row = subgroup_reserve_workgroup(&walk_rows_reserved, countOneBits(taken));
+
+            let imask = node.data[0].w >> 24u;
+
+            // The children that fit the frontier go on it now. Those past it wait for the task records
+            // lane 0 is about to ask for: 'beyond' and 'place' are theirs.
+            var beyond = children;
+            var place = child;
 
-            if (kind == BVH_QUERY_AABB_DESCEND) {
-                mesh_brick_walk_place(next, child, start, node.child_1);
-                mesh_brick_walk_place(next, child + 1u, start, node.child_2);
+            while (beyond != 0u && place < MESH_BRICK_FRONTIER) {
+                let child_slot = countTrailingZeros(beyond);
+
+                beyond &= beyond - 1u;
+
+                // the node's children sit in one block, in slot order
+                walk_frontier[next][place] = node.data[1].x + countOneBits(imask & ((1u << child_slot) - 1u));
+
+                place++;
             }
 
-            if (kind == BVH_QUERY_AABB_LEAF) {
-                walk_rows[row % MESH_BRICK_WALK_ROWS] = node.child_2;
+            var rows_left = taken;
+            var row_place = row;
+
+            while (rows_left != 0u) {
+                let offset = countTrailingZeros(rows_left);
+
+                rows_left &= rows_left - 1u;
+
+                walk_rows[row_place % MESH_BRICK_WALK_ROWS] = bvh8_tree_read_payload(&tlas, node, offset);
+
+                row_place++;
             }
 
             // every append of the iteration has landed
@@ -350,15 +381,27 @@ fn main(
 
             let handoff = workgroupUniformLoad(&walk_handoff);
 
-            for (var k = 0u; k < handoff.tasks_kept; k++) {
-                let i = k * MESH_BRICK_BATCH + lane;
-                let record = mesh_brick_task_out(handoff.tasks + k);
+            // this lane's children past the frontier, each to its place in the task records kept
+            while (beyond != 0u) {
+                let child_slot = countTrailingZeros(beyond);
 
-                if (i < handoff.spilled) {
-                    mesh_brick_tasks[record + MESH_BRICK_RECORD_HEADER_WORDS + lane] = walk_spill[i];
+                beyond &= beyond - 1u;
+
+                let i = mesh_brick_walk_spill_index(place, start);
+                let k = i / MESH_BRICK_BATCH;
+
+                if (k < handoff.tasks_kept) {
+                    mesh_brick_tasks[mesh_brick_task_out(handoff.tasks + k) + MESH_BRICK_RECORD_HEADER_WORDS + i % MESH_BRICK_BATCH]
+                        = node.data[1].x + countOneBits(imask & ((1u << child_slot) - 1u));
                 }
 
-                if (lane == 0u) {
+                place++;
+            }
+
+            if (lane == 0u) {
+                for (var k = 0u; k < handoff.tasks_kept; k++) {
+                    let record = mesh_brick_task_out(handoff.tasks + k);
+
                     mesh_brick_tasks[record] = build;
                     mesh_brick_tasks[record + 1u] = min(MESH_BRICK_BATCH, handoff.spilled - k * MESH_BRICK_BATCH);
                 }
@@ -379,7 +422,7 @@ fn main(
             }
 
             start = handoff.end;
-            copied = handoff.tasks_kept + handoff.batches_kept != 0u;
+            copied = handoff.batches_kept != 0u;
 
             if (settles) {
                 expand_count = min(handoff.end, MESH_BRICK_FRONTIER);
@@ -391,9 +434,11 @@ fn main(
     chunk_brick_clipmap,
     chunk_brick_provider,
     chunk_folded_workgroup_index,
-    chunk_bvh_query_aabb_frontier,
-    BVH_NULL_NODE_DEFINITION,
-    BVH2_NODE_STRUCT.declaration_chunk,
+    BVH8_INODE_STRUCT.declaration_chunk,
+    chunk_bvh8_tree_read,
+    chunk_bvh8_node_slot_distances,
+    chunk_aabb3_intersects_aabb3,
+    chunk_scene_database_access,
     chunk_subgroup_reserve_workgroup,
     chunk_mesh_brick_instance,
     chunk_mesh_brick_walk,
@@ -406,9 +451,10 @@ body.addExtension(WebGPUExtensionType.Subgroups);
  * whose box comes within the band of a taken cell, gathered whole, a workgroup a walk.
  *
  * A walk expands the TLAS a level at a time, as the cooperative query does (`chunk_bvh_query_aabb_cooperative`):
- * each node of the level is tested by a lane against the cell grown by the cascade's band, the children
- * of an overlapping internal node go on the next level, and an overlapping leaf is a row when
- * `mesh_brick_accept` takes it. Nothing is dropped:
+ * each node of the level is read by a lane, and its eight slots tested against the cell grown by the
+ * cascade's band. The child nodes of the slots the box meets go on the next level. An instance in a
+ * slot the box meets is a row when its own box meets it too — a slot's is the instance's rounded outward
+ * to the node's grid — and `mesh_brick_accept` takes it. Nothing is dropped:
  * - a level keeps {@link MESH_BRICK_FRONTIER} nodes, and the children that fall past them are handed on in
  *   task records of up to {@link MESH_BRICK_BATCH} nodes, each a walk of the next round, which this same
  *   kernel runs from them;
@@ -425,12 +471,15 @@ body.addExtension(WebGPUExtensionType.Subgroups);
  * a command dispatches was written this frame.
  *
  * An iteration of a level costs the workgroup a barrier and a `workgroupUniformLoad`, and a barrier
- * more after one whose hand-off copied records out: lane 0 hands every lane where the next iteration's
- * children start and, on the level's last, how many nodes the next level holds.
+ * more after one whose hand-off copied rows out: lane 0 hands every lane where the next iteration's
+ * children start and, on the level's last, how many nodes the next level holds. A lane writes its own
+ * children past the frontier straight into the task records the hand-off kept for them.
  *
- * Per lane and level, at most {@link MESH_BRICK_FRONTIER} / {@link MESH_BRICK_BATCH} node reads, accepts
- * and appends, over at most {@link BVH_QUERY_AABB_LEVEL_BUDGET} levels; per iteration, two task entries
- * and two batch entries copied at most.
+ * Per lane and level, at most {@link MESH_BRICK_FRONTIER} / {@link MESH_BRICK_BATCH} node reads, each
+ * with at most eight accepts and eight appends of either kind, over at most
+ * {@link BVH_QUERY_AABB_LEVEL_BUDGET} levels — a budget for a binary tree, a third of which a tree of
+ * three binary levels a node needs; per iteration, eight task entries written and nine batch entries
+ * copied at most.
  *
  * @type {ComputeShader}
  */

package/src/shade/renderer/global_illumination/probe_clipmap/debug/graph_probe_clipmap_debug_mesh_sdf.js

@@ -7,7 +7,7 @@ import {
     MESH_SDF_INDIRECTION_RESOURCE,
     MESH_SDF_SAMPLER_RESOURCE
 } from "../../../geometry/sdf/MESH_SDF_RESOURCES.js";
-import { BVH_STRUCT } from "../../../shader/chunk/bvh/BVH_STRUCT.js";
+import { BVH8_TREE_TYPE } from "../../../shader/chunk/bvh/bvh8/webgpu/chunk_bvh8_tree_read.js";
 import { chunk_camera_ray_from_uv } from "../../../shader/chunk/geometry/ray/chunk_camera_ray_from_uv.js";
 import { F32_MAX_DEFINITION } from "../../../shader/chunk/math/F32_MAX_DEFINITION.js";
 import { chunk_scene_sdf_raymarch } from "../../../shader/chunk/sdf/chunk_scene_sdf_raymarch.js";
@@ -37,7 +37,7 @@ resources.createGroup()
     .add(MESH_SDF_ATLAS_RESOURCE)
     .add(MESH_SDF_SAMPLER_RESOURCE)
     .addStorageBuffer("scene_database", WebGPUArray.from(u32))
-    .addStorageBuffer("tlas", BVH_STRUCT);
+    .addStorageBuffer("tlas", BVH8_TREE_TYPE);
 
 resources.createGroup()
     .addUniform("camera", CAMERA_UNIFORM_STRUCT);

package/src/shade/renderer/global_illumination/probe_clipmap/debug/graph_probe_clipmap_debug_mesh_surfaces.js

@@ -16,7 +16,7 @@ import {
     MESH_SURFACE_ROWS_RESOURCE
 } from "../../../geometry/sdf/surface/MESH_SURFACE_RESOURCES.js";
 import { chunk_scene_database_access } from "../../../scene/chunk_scene_database_access.js";
-import { BVH_STRUCT } from "../../../shader/chunk/bvh/BVH_STRUCT.js";
+import { BVH8_TREE_TYPE } from "../../../shader/chunk/bvh/bvh8/webgpu/chunk_bvh8_tree_read.js";
 import { chunk_mat4_inverse } from "../../../shader/chunk/geometry/mat4/chunk_mat4_inverse.js";
 import { chunk_camera_ray_from_uv } from "../../../shader/chunk/geometry/ray/chunk_camera_ray_from_uv.js";
 import { F32_MAX_DEFINITION } from "../../../shader/chunk/math/F32_MAX_DEFINITION.js";
@@ -43,7 +43,7 @@ resources.createGroup()
     .add(MESH_SDF_ATLAS_RESOURCE)
     .add(MESH_SDF_SAMPLER_RESOURCE)
     .addStorageBuffer("scene_database", WebGPUArray.from(u32))
-    .addStorageBuffer("tlas", BVH_STRUCT);
+    .addStorageBuffer("tlas", BVH8_TREE_TYPE);
 
 resources.createGroup()
     .add(MESH_SURFACE_RECORDS_RESOURCE)

package/src/shade/renderer/gpu_primitive/bvh/BVH_BUFFER_LAYOUT.d.ts

@@ -13,13 +13,13 @@ export function bvh_buffer_size(leaf_count: number): number;
  * restated as literals — `.pack()` and WGSL layout rules decide these offsets, and a builder that
  * hard-codes them is one struct edit away from writing trees nothing can traverse.
  *
- * The layout every RT consumer depends on:
+ * The layout every reader of a binary tree depends on:
  *
  *   [u32 root][node 0][node 1] ... where a node is
  *   [min.x, min.y, min.z, max.x, max.y, max.z : f32][child_1 : u32][child_2 : u32]
  *
  * A node is a leaf exactly when `child_1 == BVH_NULL_NODE`, and then `child_2` carries the payload
- * (for the TLAS, a row in the scene database's `meshes` table). An internal node always has two
+ * (for the tree over a scene's instances, a row in the scene database's `meshes` table). An internal node always has two
  * real children with meaningful bounds — the distance-ordered point queries dereference both before
  * descending, so a placeholder child is not an option.
  *