@woosh/meep-engine 3.68.0 → 3.70.0

package/src/shade/renderer/shader/chunk/geometry/ray/chunk_ray_query_nearest.js

@@ -1,114 +1,153 @@
 import { chunk_scene_database_access } from "../../../../scene/chunk_scene_database_access.js";
 import { CodeChunk } from "../../../compiler/CodeChunk.js";
-import { BVH_NULL_NODE_DEFINITION } from "../../bvh/BVH_NULL_NODE_DEFINITION.js";
-import { BVH_TRAVERSAL_STACK_SIZE } from "../../bvh/BVH_TRAVERSAL_STACK_SIZE.js";
-import { chunk_aabb3_intersects_ray } from "../aabb3/chunk_aabb3_intersects_ray.js";
+import { chunk_first_bit_high } from "../../binary/chunk_first_bit_high.js";
+import { BVH8_TRAVERSAL_STACK_SIZE } from "../../bvh/bvh8/webgpu/BVH8_MAX_DEPTH.js";
+import { chunk_bvh8_node_intersect } from "../../bvh/bvh8/webgpu/chunk_bvh8_node_intersect.js";
+import { chunk_bvh8_ray_direction_rcp } from "../../bvh/bvh8/webgpu/chunk_bvh8_ray_direction_rcp.js";
+import { chunk_bvh8_tree_read } from "../../bvh/bvh8/webgpu/chunk_bvh8_tree_read.js";
+import { chunk_ray_get_octant_inv4 } from "../../bvh/bvh8/webgpu/chunk_ray_get_octant_inv4.js";
 import { chunk_mat4_inverse } from "../mat4/chunk_mat4_inverse.js";
-
 import { chunk_ray_query_blas_nearest } from "./chunk_ray_query_blas_nearest.js";
 import { chunk_ray_transform_m4 } from "./chunk_ray_transform_m4.js";
 import { RAY_HIT_INFO } from "./RAY_HIT_INFO.js";
 import { RAY_STRUCT } from "./RAY_STRUCT.js";
 
+/**
+ * The nearest hit of a ray in the scene:
+ *
+ * ```wgsl
+ * fn ray_query_nearest(ray: Ray) -> RayHitInfo
+ * ```
+ *
+ * A hit holds the world distance in `t` (negative for a miss), the instance's `meshes` row in
+ * `instance`, its geometry in `geometry`, and `triangle` and `barycentrics` in that geometry.
+ *
+ * The scene's TLAS is walked with the ray, nearer slots first by the ray's octant, and the ray is
+ * shortened at every hit: a node tested after a hit is tested against the shorter ray. The geometry
+ * of an instance is entered in its own space ({@link chunk_ray_query_blas_nearest}, two-sided).
+ *
+ * One stack serves both levels: the BLAS under an instance takes the entries above the TLAS walk's
+ * own. A scene of no instances is a tree of one empty node, and is missed.
+ *
+ * The enclosing shader binds `tlas`, `scene_database` and the BLAS buffers.
+ *
+ * @type {CodeChunk}
+ */
 export const chunk_ray_query_nearest = CodeChunk.from(
     //language=WGSL
     `
-fn ray_query_nearest(
-    ray: ${RAY_STRUCT.wgsl_ref},
-) -> ${RAY_HIT_INFO.wgsl_ref}{
-    var stack = array<u32, ${BVH_TRAVERSAL_STACK_SIZE}>();
-    
-    var node_index = tlas.root;
-    var pointer = 1u;
-    
-    let direction_rcp = 1.0 / ray.direction;
-    
+fn ray_query_nearest(ray: ${RAY_STRUCT.wgsl_ref}) -> ${RAY_HIT_INFO.wgsl_ref} {
+    var stack: array<vec2u, ${BVH8_TRAVERSAL_STACK_SIZE}>;
+    var pointer = 0u;
+
     var best_hit: ${RAY_HIT_INFO.wgsl_ref};
     best_hit.t = -1.0;
-    
+
+    // shortened as hits are found
     var global_ray = ray;
-    
-    for(;pointer > 0 && pointer <= ${BVH_TRAVERSAL_STACK_SIZE};){
-            
-        let node = tlas.nodes[node_index];
-        
-        if(!aabb3_intersects_ray(node.bounds, global_ray.origin, direction_rcp, global_ray.tmax)){
-            
-            pointer --;
-            node_index = stack[pointer];
-            
-            continue;
+
+    let oct_inv4 = ray_get_octant_inv4(ray.direction);
+    let direction_rcp = bvh8_ray_direction_rcp(ray.direction);
+
+    // The group being walked: the nodes of one parent that the ray reaches and that are still to visit
+    //   x: index of the parent's first child node
+    //   y: | hits, by traversal priority | pad     | imask  |
+    //      | 8 bits                      | 16 bits | 8 bits |
+    // The root is a group of one, already hit.
+    var current_group = vec2(0u, 0x80000000u);
+
+    loop {
+        let hits_imask = current_group.y;
+
+        // nearest of the group's remaining nodes
+        let child_index_offset = first_bit_high(hits_imask);
+        let child_index_base = current_group.x;
+
+        current_group.y &= ~(1u << child_index_offset);
+
+        if ((current_group.y & 0xff000000u) != 0u && pointer < ${BVH8_TRAVERSAL_STACK_SIZE}u) {
+            // the rest of the group waits
+            stack[pointer] = current_group;
+            pointer++;
         }
-        
-        let child_1 = node.child_1;
-        let child_2 = node.child_2;
-        
-        if(child_1 != BVH_NULL_NODE){
-            // Intermediate node
-            
-            node_index = child_1;
-            
-            stack[ pointer ] = child_2;
-            
-            pointer ++;
-                       
-        }else{
-        
-           
-            pointer --;
-            node_index = stack[pointer];
-            
-            // leaf, traverse BLAS
-            // child_2 stores the user_data (mesh_id)
-            let mesh_id = child_2;
+
+        // undo the octant ranking to get the node's slot, then count the nodes in the slots below it
+        let slot_index = (child_index_offset - 24u) ^ (oct_inv4 & 0xffu);
+        let relative_index = countOneBits(hits_imask & ~(0xffffffffu << slot_index));
+
+        let node = bvh8_tree_read_node(&tlas, child_index_base + relative_index);
+
+        let hitmask = bvh8_node_intersect(global_ray, direction_rcp, oct_inv4, node);
+
+        current_group.x = node.data[1].x;
+        current_group.y = (hitmask & 0xff000000u) | (node.data[0].w >> 24u);
+
+        // one bit per instance whose box the ray reaches
+        var instance_hits = hitmask & 0x00ffffffu;
+
+        while (instance_hits != 0u) {
+            let offset = countTrailingZeros(instance_hits);
+
+            instance_hits &= instance_hits - 1u;
+
+            // a leaf's payload is the instance's meshes row
+            let mesh_id = bvh8_tree_read_payload(&tlas, node, offset);
 
             let mesh = scene_read_mesh(&scene_database, mesh_id);
-            let node = scene_read_node(&scene_database, mesh.node);
+            let placement = scene_read_node(&scene_database, mesh.node);
 
             let geometry_id = mesh.geometry;
 
-            let local_ray = ray_transform_m4(global_ray, mat4_inverse(node.global));
+            let local_ray = ray_transform_m4(global_ray, mat4_inverse(placement.global));
 
             let hit = ray_query_blas_nearest(local_ray, geometry_id, &stack, pointer);
 
-            if(hit.t < 0.0){
-                // miss
+            if (hit.t < 0.0) {
                 continue;
             }
 
             let local_hit_position = local_ray.origin + local_ray.direction * hit.t;
 
-            let global_hit_position = node.global * vec4(local_hit_position, 1.0);
-            
-            let distance = distance( global_ray.origin, global_hit_position.xyz / global_hit_position.w );
-            
-            if(distance >= global_ray.tmax){
+            let global_hit_position = placement.global * vec4(local_hit_position, 1.0);
+
+            let reach = distance(global_ray.origin, global_hit_position.xyz / global_hit_position.w);
+
+            if (reach >= global_ray.tmax) {
                 continue;
             }
-            
-            // found a good hit
-            
-            global_ray.tmax = distance;
-            
+
+            global_ray.tmax = reach;
+
             best_hit = hit;
-            
-            best_hit.t = distance;
+
+            best_hit.t = reach;
             best_hit.instance = mesh_id;
             best_hit.geometry = geometry_id;
         }
-        
+
+        if ((current_group.y & 0xff000000u) == 0u) {
+            if (pointer == 0u) {
+                break;
+            }
+
+            pointer--;
+            current_group = stack[pointer];
+        }
     }
-    
+
     return best_hit;
 }
-  `,
-    [
+    `, [
+        RAY_STRUCT.declaration_chunk,
         RAY_HIT_INFO.declaration_chunk,
-        BVH_NULL_NODE_DEFINITION,
-        chunk_ray_transform_m4,
-        chunk_aabb3_intersects_ray,
+        chunk_first_bit_high,
+        chunk_ray_get_octant_inv4,
+        chunk_bvh8_node_intersect,
+        chunk_bvh8_ray_direction_rcp,
+        chunk_bvh8_tree_read,
         chunk_ray_query_blas_nearest,
+        chunk_ray_transform_m4,
         chunk_mat4_inverse,
         chunk_scene_database_access,
     ]
-);
+);

package/src/shade/renderer/shader/chunk/geometry/ray/chunk_ray_query_nearest_among.d.ts

@@ -27,8 +27,7 @@ export const RAY_QUERY_AMONG_PASS: number;
  *   traced as a geometry other than its own (a stand-in) is traced under the instance's own transform.
  *
  * The enclosing shader binds what `ray_query_nearest` reads: `tlas`, `scene_database` and the BLAS
- * buffers. The ray's direction is unit length. The TLAS must hold a tree: an empty one
- * (`tlas.root == BVH_NULL_NODE`) is the caller's to turn away.
+ * buffers. The ray's direction is unit length. A scene of no instances is missed.
  *
  * @type {CodeChunk}
  */

package/src/shade/renderer/shader/chunk/geometry/ray/chunk_ray_query_nearest_among.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_ray_query_nearest_among.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/geometry/ray/chunk_ray_query_nearest_among.js"],"names":[],"mappings":"AAYA;;;;;GAKG;AACH,mCAFU,MAAM,CAE+B;AAE/C;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,4CAFU,SAAS,CAsGjB;0BAjJwB,gCAAgC"}
+{"version":3,"file":"chunk_ray_query_nearest_among.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/geometry/ray/chunk_ray_query_nearest_among.js"],"names":[],"mappings":"AAeA;;;;;GAKG;AACH,mCAFU,MAAM,CAE+B;AAE/C;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,4CAFU,SAAS,CAiIjB;0BA9KwB,gCAAgC"}

package/src/shade/renderer/shader/chunk/geometry/ray/chunk_ray_query_nearest_among.js

@@ -1,9 +1,12 @@
 import { UINT32_MAX } from "../../../../../../core/binary/UINT32_MAX.js";
 import { TRANSFORMS_TABLE } from "../../../../scene/chunk_scene_database_access.js";
 import { CodeChunk } from "../../../compiler/CodeChunk.js";
-import { BVH_NULL_NODE_DEFINITION } from "../../bvh/BVH_NULL_NODE_DEFINITION.js";
-import { BVH_TRAVERSAL_STACK_SIZE } from "../../bvh/BVH_TRAVERSAL_STACK_SIZE.js";
-import { chunk_aabb3_intersects_ray } from "../aabb3/chunk_aabb3_intersects_ray.js";
+import { chunk_first_bit_high } from "../../binary/chunk_first_bit_high.js";
+import { BVH8_TRAVERSAL_STACK_SIZE } from "../../bvh/bvh8/webgpu/BVH8_MAX_DEPTH.js";
+import { chunk_bvh8_node_intersect } from "../../bvh/bvh8/webgpu/chunk_bvh8_node_intersect.js";
+import { chunk_bvh8_ray_direction_rcp } from "../../bvh/bvh8/webgpu/chunk_bvh8_ray_direction_rcp.js";
+import { chunk_bvh8_tree_read } from "../../bvh/bvh8/webgpu/chunk_bvh8_tree_read.js";
+import { chunk_ray_get_octant_inv4 } from "../../bvh/bvh8/webgpu/chunk_ray_get_octant_inv4.js";
 import { chunk_mat4_inverse } from "../mat4/chunk_mat4_inverse.js";
 import { chunk_ray_query_blas_nearest } from "./chunk_ray_query_blas_nearest.js";
 import { chunk_ray_transform_m4 } from "./chunk_ray_transform_m4.js";
@@ -40,8 +43,7 @@ export const RAY_QUERY_AMONG_PASS = UINT32_MAX;
  *   traced as a geometry other than its own (a stand-in) is traced under the instance's own transform.
  *
  * The enclosing shader binds what `ray_query_nearest` reads: `tlas`, `scene_database` and the BLAS
- * buffers. The ray's direction is unit length. The TLAS must hold a tree: an empty one
- * (`tlas.root == BVH_NULL_NODE`) is the caller's to turn away.
+ * buffers. The ray's direction is unit length. A scene of no instances is missed.
  *
  * @type {CodeChunk}
  */
@@ -53,83 +55,107 @@ const RAY_QUERY_AMONG_PASS: u32 = ${RAY_QUERY_AMONG_PASS}u;
 fn ray_query_nearest_among(
     ray: ${RAY_STRUCT.wgsl_ref},
 ) -> ${RAY_HIT_INFO.wgsl_ref} {
-    var stack = array<u32, ${BVH_TRAVERSAL_STACK_SIZE}>();
-
-    var node_index = tlas.root;
-    var pointer = 1u;
-
-    let direction_rcp = 1.0 / ray.direction;
+    // one stack for both levels: the BLAS under an instance takes the entries above this walk's own
+    var stack: array<vec2u, ${BVH8_TRAVERSAL_STACK_SIZE}>;
+    var pointer = 0u;
 
     var best_hit: ${RAY_HIT_INFO.wgsl_ref};
     best_hit.t = -1.0;
 
+    // shortened as hits are found
     var global_ray = ray;
 
-    for (; pointer > 0u && pointer <= ${BVH_TRAVERSAL_STACK_SIZE}u;) {
+    let oct_inv4 = ray_get_octant_inv4(ray.direction);
+    let direction_rcp = bvh8_ray_direction_rcp(ray.direction);
 
-        let node = tlas.nodes[node_index];
+    // The group being walked: the nodes of one parent that the ray reaches and that are still to visit
+    //   x: index of the parent's first child node
+    //   y: | hits, by traversal priority | pad     | imask  |
+    //      | 8 bits                      | 16 bits | 8 bits |
+    // The root is a group of one, already hit.
+    var current_group = vec2(0u, 0x80000000u);
 
-        if (!aabb3_intersects_ray(node.bounds, global_ray.origin, direction_rcp, global_ray.tmax)) {
-            pointer--;
-            node_index = stack[pointer];
+    loop {
+        let hits_imask = current_group.y;
+
+        // nearest of the group's remaining nodes
+        let child_index_offset = first_bit_high(hits_imask);
+        let child_index_base = current_group.x;
+
+        current_group.y &= ~(1u << child_index_offset);
 
-            continue;
+        if ((current_group.y & 0xff000000u) != 0u && pointer < ${BVH8_TRAVERSAL_STACK_SIZE}u) {
+            // the rest of the group waits
+            stack[pointer] = current_group;
+            pointer++;
         }
 
-        let child_1 = node.child_1;
-        let child_2 = node.child_2;
+        // undo the octant ranking to get the node's slot, then count the nodes in the slots below it
+        let slot_index = (child_index_offset - 24u) ^ (oct_inv4 & 0xffu);
+        let relative_index = countOneBits(hits_imask & ~(0xffffffffu << slot_index));
 
-        if (child_1 != BVH_NULL_NODE) {
-            // an inner node
-            node_index = child_1;
+        let node = bvh8_tree_read_node(&tlas, child_index_base + relative_index);
 
-            stack[pointer] = child_2;
+        let hitmask = bvh8_node_intersect(global_ray, direction_rcp, oct_inv4, node);
 
-            pointer++;
+        current_group.x = node.data[1].x;
+        current_group.y = (hitmask & 0xff000000u) | (node.data[0].w >> 24u);
 
-            continue;
-        }
+        // one bit per instance whose box the ray reaches
+        var instance_hits = hitmask & 0x00ffffffu;
 
-        pointer--;
-        node_index = stack[pointer];
+        while (instance_hits != 0u) {
+            let offset = countTrailingZeros(instance_hits);
 
-        // a leaf: child_2 is the instance's meshes row
-        let mesh_id = child_2;
+            instance_hits &= instance_hits - 1u;
 
-        let geometry_id = ray_query_among_geometry(mesh_id);
+            // a leaf's payload is the instance's meshes row
+            let mesh_id = bvh8_tree_read_payload(&tlas, node, offset);
 
-        if (geometry_id == RAY_QUERY_AMONG_PASS) {
-            continue;
-        }
+            let geometry_id = ray_query_among_geometry(mesh_id);
 
-        // a mesh row and its transforms row are the same row
-        let global = ${TRANSFORMS_TABLE.marshalling_method_read_field('global')}(&scene_database, mesh_id);
+            if (geometry_id == RAY_QUERY_AMONG_PASS) {
+                continue;
+            }
 
-        let local_ray = ray_transform_m4(global_ray, mat4_inverse(global));
+            // a mesh row and its transforms row are the same row
+            let global = ${TRANSFORMS_TABLE.marshalling_method_read_field('global')}(&scene_database, mesh_id);
 
-        let hit = ray_query_blas_nearest(local_ray, geometry_id, &stack, pointer);
+            let local_ray = ray_transform_m4(global_ray, mat4_inverse(global));
 
-        if (hit.t < 0.0) {
-            continue;
-        }
+            let hit = ray_query_blas_nearest(local_ray, geometry_id, &stack, pointer);
 
-        let local_hit_position = local_ray.origin + local_ray.direction * hit.t;
+            if (hit.t < 0.0) {
+                continue;
+            }
 
-        let global_hit_position = global * vec4(local_hit_position, 1.0);
+            let local_hit_position = local_ray.origin + local_ray.direction * hit.t;
 
-        let reach = distance(global_ray.origin, global_hit_position.xyz / global_hit_position.w);
+            let global_hit_position = global * vec4(local_hit_position, 1.0);
 
-        if (reach >= global_ray.tmax) {
-            continue;
-        }
+            let reach = distance(global_ray.origin, global_hit_position.xyz / global_hit_position.w);
+
+            if (reach >= global_ray.tmax) {
+                continue;
+            }
+
+            global_ray.tmax = reach;
 
-        global_ray.tmax = reach;
+            best_hit = hit;
 
-        best_hit = hit;
+            best_hit.t = reach;
+            best_hit.instance = mesh_id;
+            best_hit.geometry = geometry_id;
+        }
+
+        if ((current_group.y & 0xff000000u) == 0u) {
+            if (pointer == 0u) {
+                break;
+            }
 
-        best_hit.t = reach;
-        best_hit.instance = mesh_id;
-        best_hit.geometry = geometry_id;
+            pointer--;
+            current_group = stack[pointer];
+        }
     }
 
     return best_hit;
@@ -138,9 +164,12 @@ fn ray_query_nearest_among(
     [
         RAY_STRUCT.declaration_chunk,
         RAY_HIT_INFO.declaration_chunk,
-        BVH_NULL_NODE_DEFINITION,
+        chunk_first_bit_high,
+        chunk_ray_get_octant_inv4,
+        chunk_bvh8_node_intersect,
+        chunk_bvh8_ray_direction_rcp,
+        chunk_bvh8_tree_read,
         chunk_ray_transform_m4,
-        chunk_aabb3_intersects_ray,
         chunk_ray_query_blas_nearest,
         chunk_mat4_inverse,
         TRANSFORMS_TABLE.chunk_read_field('global'),

package/src/shade/renderer/shader/chunk/geometry/ray/chunk_ray_query_occluded.d.ts

@@ -1,4 +1,18 @@
 /**
+ * Whether anything in the scene lies along a ray:
+ *
+ * ```wgsl
+ * fn ray_query_occluded(ray: Ray) -> bool
+ * ```
+ *
+ * The scene's TLAS is walked with the ray, and the geometry of every instance whose box it reaches
+ * is asked ({@link chunk_ray_query_blas_occluded}, single-sided) until one answers yes.
+ *
+ * One stack serves both levels: the BLAS under an instance takes the entries above the TLAS walk's
+ * own. A scene of no instances is a tree of one empty node, and occludes nothing.
+ *
+ * The enclosing shader binds `tlas`, `scene_database` and the BLAS buffers.
+ *
  * @type {CodeChunk}
  */
 export const chunk_ray_query_occluded: CodeChunk;

package/src/shade/renderer/shader/chunk/geometry/ray/chunk_ray_query_occluded.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_ray_query_occluded.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/geometry/ray/chunk_ray_query_occluded.js"],"names":[],"mappings":"AAWA;;GAEG;AACH,uCAFU,SAAS,CAwElB;0BAnFyB,gCAAgC"}
+{"version":3,"file":"chunk_ray_query_occluded.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/geometry/ray/chunk_ray_query_occluded.js"],"names":[],"mappings":"AAaA;;;;;;;;;;;;;;;;GAgBG;AACH,uCAFU,SAAS,CAwFjB;0BAnHwB,gCAAgC"}

package/src/shade/renderer/shader/chunk/geometry/ray/chunk_ray_query_occluded.js

@@ -1,85 +1,117 @@
 import { chunk_scene_database_access } from "../../../../scene/chunk_scene_database_access.js";
 import { CodeChunk } from "../../../compiler/CodeChunk.js";
-import { BVH_NULL_NODE_DEFINITION } from "../../bvh/BVH_NULL_NODE_DEFINITION.js";
-import { BVH_TRAVERSAL_STACK_SIZE } from "../../bvh/BVH_TRAVERSAL_STACK_SIZE.js";
-import { chunk_aabb3_intersects_ray } from "../aabb3/chunk_aabb3_intersects_ray.js";
+import { chunk_first_bit_high } from "../../binary/chunk_first_bit_high.js";
+import { BVH8_TRAVERSAL_STACK_SIZE } from "../../bvh/bvh8/webgpu/BVH8_MAX_DEPTH.js";
+import { chunk_bvh8_node_intersect } from "../../bvh/bvh8/webgpu/chunk_bvh8_node_intersect.js";
+import { chunk_bvh8_ray_direction_rcp } from "../../bvh/bvh8/webgpu/chunk_bvh8_ray_direction_rcp.js";
+import { chunk_bvh8_tree_read } from "../../bvh/bvh8/webgpu/chunk_bvh8_tree_read.js";
+import { chunk_ray_get_octant_inv4 } from "../../bvh/bvh8/webgpu/chunk_ray_get_octant_inv4.js";
 import { chunk_mat4_inverse } from "../mat4/chunk_mat4_inverse.js";
 import { chunk_ray_query_blas_occluded } from "./chunk_ray_query_blas_occluded.js";
 import { chunk_ray_transform_m4 } from "./chunk_ray_transform_m4.js";
 import { RAY_STRUCT } from "./RAY_STRUCT.js";
 
-
 /**
+ * Whether anything in the scene lies along a ray:
+ *
+ * ```wgsl
+ * fn ray_query_occluded(ray: Ray) -> bool
+ * ```
+ *
+ * The scene's TLAS is walked with the ray, and the geometry of every instance whose box it reaches
+ * is asked ({@link chunk_ray_query_blas_occluded}, single-sided) until one answers yes.
+ *
+ * One stack serves both levels: the BLAS under an instance takes the entries above the TLAS walk's
+ * own. A scene of no instances is a tree of one empty node, and occludes nothing.
+ *
+ * The enclosing shader binds `tlas`, `scene_database` and the BLAS buffers.
+ *
  * @type {CodeChunk}
  */
 export const chunk_ray_query_occluded = CodeChunk.from(
     //language=WGSL
     `
-fn ray_query_occluded( ray: ${RAY_STRUCT.wgsl_ref}) -> bool {
-    var stack = array<u32, ${BVH_TRAVERSAL_STACK_SIZE}>();
-        
-    var node_index = tlas.root;
-    var pointer = 1u;
-    
-    // this is a faster version of 'pointer > 0 && pointer <= BVH_TRAVERSAL_STACK_SIZE', saving an extra compare op
-    for(;(pointer & ${BVH_TRAVERSAL_STACK_SIZE - 1}) != 0;){
-                    
-        let node = tlas.nodes[node_index];
-        
-        if(!aabb3_intersects_ray(node.bounds, ray.origin, 1.0 / ray.direction, ray.tmax)){
-        
-            pointer --;
-            node_index = stack[pointer];
-            
-            continue;
+fn ray_query_occluded(ray: ${RAY_STRUCT.wgsl_ref}) -> bool {
+    var stack: array<vec2u, ${BVH8_TRAVERSAL_STACK_SIZE}>;
+    var pointer = 0u;
+
+    let oct_inv4 = ray_get_octant_inv4(ray.direction);
+    let direction_rcp = bvh8_ray_direction_rcp(ray.direction);
+
+    // The group being walked: the nodes of one parent that the ray reaches and that are still to visit
+    //   x: index of the parent's first child node
+    //   y: | hits, by traversal priority | pad     | imask  |
+    //      | 8 bits                      | 16 bits | 8 bits |
+    // The root is a group of one, already hit.
+    var current_group = vec2(0u, 0x80000000u);
+
+    loop {
+        let hits_imask = current_group.y;
+
+        // nearest of the group's remaining nodes
+        let child_index_offset = first_bit_high(hits_imask);
+        let child_index_base = current_group.x;
+
+        current_group.y &= ~(1u << child_index_offset);
+
+        if ((current_group.y & 0xff000000u) != 0u && pointer < ${BVH8_TRAVERSAL_STACK_SIZE}u) {
+            // the rest of the group waits
+            stack[pointer] = current_group;
+            pointer++;
         }
-        
-        let child_1 = node.child_1;
-        let child_2 = node.child_2;
-        
-        if(child_1 != BVH_NULL_NODE){
-            // Intermediate node
-            
-            node_index = child_1;
-            
-            stack[ pointer ] = child_2;
-            
-            pointer ++;
-            
-                       
-        }else{
-        
-            pointer --;
-            node_index = stack[pointer];
-                        
-            // leaf, traverse BLAS
-            // child_2 stores the user_data (mesh_id)
-
-            let mesh = scene_read_mesh(&scene_database, child_2);
-            let node = scene_read_node(&scene_database, mesh.node);
-
-            let geometry_id = mesh.geometry;
-
-            let local_ray = ray_transform_m4(ray, mat4_inverse(node.global));
-            
-            if(ray_query_blas_occluded(local_ray, geometry_id, &stack, pointer)){
+
+        // undo the octant ranking to get the node's slot, then count the nodes in the slots below it
+        let slot_index = (child_index_offset - 24u) ^ (oct_inv4 & 0xffu);
+        let relative_index = countOneBits(hits_imask & ~(0xffffffffu << slot_index));
+
+        let node = bvh8_tree_read_node(&tlas, child_index_base + relative_index);
+
+        let hitmask = bvh8_node_intersect(ray, direction_rcp, oct_inv4, node);
+
+        current_group.x = node.data[1].x;
+        current_group.y = (hitmask & 0xff000000u) | (node.data[0].w >> 24u);
+
+        // one bit per instance whose box the ray reaches
+        var instance_hits = hitmask & 0x00ffffffu;
+
+        while (instance_hits != 0u) {
+            let offset = countTrailingZeros(instance_hits);
+
+            instance_hits &= instance_hits - 1u;
+
+            // a leaf's payload is the instance's meshes row
+            let mesh = scene_read_mesh(&scene_database, bvh8_tree_read_payload(&tlas, node, offset));
+            let placement = scene_read_node(&scene_database, mesh.node);
+
+            let local_ray = ray_transform_m4(ray, mat4_inverse(placement.global));
+
+            if (ray_query_blas_occluded(local_ray, mesh.geometry, &stack, pointer)) {
                 return true;
             }
-            
         }
-        
+
+        if ((current_group.y & 0xff000000u) == 0u) {
+            if (pointer == 0u) {
+                break;
+            }
+
+            pointer--;
+            current_group = stack[pointer];
+        }
     }
-    
-    // no hit
+
     return false;
-}`,
-    [
+}
+    `, [
         RAY_STRUCT.declaration_chunk,
-        BVH_NULL_NODE_DEFINITION,
+        chunk_first_bit_high,
+        chunk_ray_get_octant_inv4,
+        chunk_bvh8_node_intersect,
+        chunk_bvh8_ray_direction_rcp,
+        chunk_bvh8_tree_read,
         chunk_ray_query_blas_occluded,
         chunk_ray_transform_m4,
-        chunk_aabb3_intersects_ray,
         chunk_mat4_inverse,
         chunk_scene_database_access,
     ]
-)
+);