@woosh/meep-engine 3.68.0 → 3.70.0

package/src/shade/renderer/shader/chunk/sdf/chunk_point_query_blas_nearest.d.ts

@@ -1,3 +1,25 @@
+/**
+ * Nearest point of one geometry's surface to a point, through its tree: `primitive` is the
+ * `(meshlet << 8) | triangle` id of the nearest triangle within `max_distance`, or all ones when there
+ * is none.
+ *
+ * A node is visited once for its own triangles: those of the slots whose boxes are nearer than the best
+ * found, one after another, and each time one of them is nearer still the rest are held to it. Its
+ * child nodes are then taken nearest box first, and what is left of them waits on the stack as one
+ * entry:
+ *
+ * - one other child worth a visit waits as itself, and is visited whatever has been found by then;
+ * - several wait as their node; on the way back the node is read again and the nearest of those that
+ *   still beats the best is taken.
+ *
+ * So the stack is as deep as the tree and no deeper, whatever the fan-out.
+ *
+ * `stack` is the caller's, used from `stack_top` up and handed back as it was found below that. The
+ * walk reads and writes the first word of an entry and nothing else of it: which of a waiting node's
+ * slots are still to visit stays with the walk, a byte a level ({@link chunk_bvh8_waiting_slots}).
+ *
+ * @type {CodeChunk}
+ */
 export const chunk_point_query_blas_nearest: CodeChunk;
 import { CodeChunk } from "../../compiler/CodeChunk.js";
 //# sourceMappingURL=chunk_point_query_blas_nearest.d.ts.map

package/src/shade/renderer/shader/chunk/sdf/chunk_point_query_blas_nearest.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_point_query_blas_nearest.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/sdf/chunk_point_query_blas_nearest.js"],"names":[],"mappings":"AAgBA,uDAsHE;0BArIwB,6BAA6B"}
+{"version":3,"file":"chunk_point_query_blas_nearest.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/sdf/chunk_point_query_blas_nearest.js"],"names":[],"mappings":"AAmBA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,6CAFU,SAAS,CA8IjB;0BAjLwB,6BAA6B"}

package/src/shade/renderer/shader/chunk/sdf/chunk_point_query_blas_nearest.js

@@ -1,135 +1,182 @@
+import { assert } from "../../../../../core/assert.js";
 import { UINT32_MAX } from "../../../../../core/binary/UINT32_MAX.js";
+import { GEOMETRY_METADATA_STRUCT } from "../../../geometry/GEOMETRY_METADATA_STRUCT.js";
+import { MESHLET_METADATA_STRUCT } from "../../../geometry/meshlet/encoding/MESHLET_METADATA_STRUCT.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_unsigned_distance_sqr_to_point
-} from "../geometry/aabb3/chunk_aabb3_unsigned_distance_sqr_to_point.js";
-import { chunk_geometry_read_triangle_vertices } from "../geometry/format/chunk_geometry_read_triangle_vertices.js";
+import { chunk_read_meshlet_resolved_index } from "../geometry/meshlet/chunk_read_meshlet_resolved_index.js";
+import { chunk_read_meshlet_vertex_position } from "../geometry/meshlet/chunk_read_meshlet_vertex_position.js";
 import { chunk_compute_triangle_face_normal } from "../geometry/normal/chunk_compute_triangle_face_normal.js";
-import { chunk_f32_array_as_vec3 } from "../geometry/vec3/chunk_f32_array_as_vec3.js";
 import {
     chunk_triangle_closest_point_to_point_barycentric
 } from "./chunk_triangle_closest_point_to_point_barycentric.js";
 import { SURFACE_POINT_3D } from "./SURFACE_POINT_3D.js";
+import { BVH8_INODE_STRUCT } from "../bvh/bvh8/webgpu/BVH8_INODE_STRUCT.js";
+import { BVH8_BLAS_MAX_DEPTH, BVH8_TRAVERSAL_STACK_SIZE } from "../bvh/bvh8/webgpu/BVH8_MAX_DEPTH.js";
+import { chunk_bvh8_node_slot_distances } from "../bvh/bvh8/webgpu/chunk_bvh8_node_slot_distances.js";
+import { BVH8_WAITING_SLOTS_CAPACITY, chunk_bvh8_waiting_slots } from "../bvh/bvh8/webgpu/chunk_bvh8_waiting_slots.js";
 
+assert.lessThanOrEqual(BVH8_BLAS_MAX_DEPTH, BVH8_WAITING_SLOTS_CAPACITY, 'a BLAS may be deeper than the walk can keep slots for');
 
+/**
+ * Nearest point of one geometry's surface to a point, through its tree: `primitive` is the
+ * `(meshlet << 8) | triangle` id of the nearest triangle within `max_distance`, or all ones when there
+ * is none.
+ *
+ * A node is visited once for its own triangles: those of the slots whose boxes are nearer than the best
+ * found, one after another, and each time one of them is nearer still the rest are held to it. Its
+ * child nodes are then taken nearest box first, and what is left of them waits on the stack as one
+ * entry:
+ *
+ * - one other child worth a visit waits as itself, and is visited whatever has been found by then;
+ * - several wait as their node; on the way back the node is read again and the nearest of those that
+ *   still beats the best is taken.
+ *
+ * So the stack is as deep as the tree and no deeper, whatever the fan-out.
+ *
+ * `stack` is the caller's, used from `stack_top` up and handed back as it was found below that. The
+ * walk reads and writes the first word of an entry and nothing else of it: which of a waiting node's
+ * slots are still to visit stays with the walk, a byte a level ({@link chunk_bvh8_waiting_slots}).
+ *
+ * @type {CodeChunk}
+ */
 export const chunk_point_query_blas_nearest = CodeChunk.from(
     //language=WGSL
     `
-fn point_query_blas_nearest (
-    position:vec3<f32>,
+fn point_query_blas_nearest(
+    position: vec3<f32>,
     max_distance: f32,
-    geometry_index:u32,
-    stack:ptr<function, array<u32,${BVH_TRAVERSAL_STACK_SIZE}> >, 
-    stack_top:u32
-) -> ${SURFACE_POINT_3D.wgsl_ref}{
-  
+    geometry_index: u32,
+    stack: ptr<function, array<vec2u, ${BVH8_TRAVERSAL_STACK_SIZE}>>,
+    stack_top: u32,
+) -> ${SURFACE_POINT_3D.wgsl_ref} {
+
     let geometry = geometries[geometry_index];
-    
+
     let blas_address = blas_lookup[geometry_index];
-             
-    var pointer = stack_top + 1;
-    
-    var node_index = 0u;
-    
+
     var nearest_distance_sqr = max_distance * max_distance;
-    
+
     var out: ${SURFACE_POINT_3D.wgsl_ref};
-    out.primitive = ${UINT32_MAX}; // used to indicate a miss on output
-    
-    for(;pointer > stack_top && pointer < ${BVH_TRAVERSAL_STACK_SIZE};){
-    
-        let node = blas_data[ blas_address + node_index ];
-        
-        let child_1 = node.child_1;
-        let child_2 = node.child_2;
-        
-        if(child_1 != BVH_NULL_NODE){
-            // not a leaf node
-            let child_1_bounds = blas_data[ blas_address + child_1 ].bounds;
-            let distance_sqr_to_child1 = aabb3_unsigned_distance_sqr_to_point(child_1_bounds, position);
-       
-            let child_2_bounds = blas_data[ blas_address + child_2 ].bounds;
-            let distance_sqr_to_child2 = aabb3_unsigned_distance_sqr_to_point(child_2_bounds, position);
-       
-            // sort children
-            var sorted_children = vec2(child_1, child_2);
-            var sorted_distances =  vec2(distance_sqr_to_child1, distance_sqr_to_child2);
-            
-            if (distance_sqr_to_child2 < distance_sqr_to_child1) {
-                
-                sorted_children = sorted_children.yx;
-                sorted_distances = sorted_distances.yx;
+    out.primitive = ${UINT32_MAX}u; // a miss, until something is found
 
+    // the walk's own part of the stack
+    let stack_end = min(stack_top + ${BVH8_WAITING_SLOTS_CAPACITY}u, ${BVH8_TRAVERSAL_STACK_SIZE}u);
+
+    var pointer = stack_top;
+
+    // the slots still to visit of each node waiting on the stack; none for a child waiting as itself
+    var waiting = vec4<u32>(0u);
+
+    // the node being looked at, and which of its child slots are still to visit
+    var node_index = blas_address;
+    var pending = 0u;
+    var arriving = true;
+
+    loop {
+        let node: ${BVH8_INODE_STRUCT.wgsl_ref} = blas_data[node_index];
+        let distances = bvh8_node_slot_distances_sqr(node, position);
+
+        let imask = node.data[0].w >> 24u;
+
+        if (arriving) {
+            // this node's own triangles first: what they find prunes its children
+            let runs = bvh8_node_slot_runs(node);
+
+            var run = bvh8_slot_runs_within(runs, distances, nearest_distance_sqr);
+
+            if (run != 0u) {
+                // a node's triangles are one run of one meshlet
+                let triangle_base = node.data[1].y;
+
+                let meshlet_header = meshlet_metadata[geometry.meshlets_address + (triangle_base >> 8u)];
+
+                while (run != 0u) {
+                    let encoded_triangle_id = triangle_base + countTrailingZeros(run);
+
+                    run &= run - 1u;
+
+                    let corner = (encoded_triangle_id & 0xffu) * 3u;
+
+                    let a = read_meshlet_vertex_position(meshlet_header, read_meshlet_resolved_index(meshlet_header, corner));
+                    let b = read_meshlet_vertex_position(meshlet_header, read_meshlet_resolved_index(meshlet_header, corner + 1u));
+                    let c = read_meshlet_vertex_position(meshlet_header, read_meshlet_resolved_index(meshlet_header, corner + 2u));
+
+                    let barycentric = triangle_closest_point_to_point_barycentric(position, a, b, c);
+
+                    let contact = a * barycentric.x + b * barycentric.y + c * (1.0 - barycentric.x - barycentric.y);
+
+                    let offset = position - contact;
+                    let distance_sqr = dot(offset, offset);
+
+                    if (distance_sqr < nearest_distance_sqr) {
+                        nearest_distance_sqr = distance_sqr;
+
+                        out.position = contact;
+                        out.normal = compute_triangle_face_normal(a, b, c);
+                        out.primitive = encoded_triangle_id;
+
+                        // slots no nearer than this are done with
+                        run &= bvh8_slot_runs_within(runs, distances, nearest_distance_sqr);
+                    }
+                }
             }
-            
-            if(sorted_distances.y < nearest_distance_sqr){
-                // both children are within range
-                
-                node_index = sorted_children.x;
-                
-                stack[ pointer ] = sorted_children.y;
-                
-                pointer ++;
-                
-            }else if(sorted_distances.x < nearest_distance_sqr){
-                
-                node_index = sorted_children.x;
-                
-            }else{
-            
-                pointer --;
-                node_index = stack[pointer];
-                
-            }
-            
-        }else{
-            
-            pointer --;
-            node_index = stack[pointer];
-            
-            let triangle_index = child_2;
-            let triangle = geometry_read_triangle_vertices(geometry, child_2);
-            
-            let a = triangle.a.position;
-            let b = triangle.b.position;
-            let c = triangle.c.position;
-                            
-            let barycentric2 = triangle_closest_point_to_point_barycentric(position, a, b, c);
-            
-            let u = barycentric2.x;
-            let v = barycentric2.y;
-            let w = 1 - u - v;
-            
-            let contact = a*u + b*v + c*w;
-            
-            let distance_to_triangle = distance(position, contact);
-            let distance_to_triangle_sqr = distance_to_triangle * distance_to_triangle;
-            
-            if (distance_to_triangle_sqr >= nearest_distance_sqr) {
-                continue;
+
+            pending = imask;
+        }
+
+        // the children still to visit that are worth one
+        let worthwhile = bvh8_slots_within(distances, nearest_distance_sqr) & pending;
+
+        if (worthwhile != 0u) {
+            let nearest_slot = bvh8_nearest_slot_among(distances, worthwhile);
+
+            // the node's children sit in one block, in slot order
+            let child_block = blas_address + node.data[1].x;
+
+            let later = worthwhile & ~(1u << nearest_slot);
+
+            if (later != 0u && pointer < stack_end) {
+                let lone = (later & (later - 1u)) == 0u;
+
+                stack[pointer].x = select(node_index, child_block + countOneBits(imask & (later - 1u)), lone);
+
+                pointer++;
+
+                waiting = bvh8_waiting_slots_push(waiting, select(later, 0u, lone));
             }
-            
-            nearest_distance_sqr = distance_to_triangle_sqr;
-            
-            out.position = contact;
-            out.normal = compute_triangle_face_normal(a,b,c);
-            out.primitive = triangle_index;
-            
+
+            node_index = child_block + countOneBits(imask & ((1u << nearest_slot) - 1u));
+            arriving = true;
+
+            continue;
+        }
+
+        // nothing more under this node: back to whatever waits
+        if (pointer == stack_top) {
+            break;
         }
-        
+
+        pointer--;
+
+        node_index = stack[pointer].x;
+        pending = bvh8_waiting_slots_latest(waiting);
+        arriving = pending == 0u;
+
+        waiting = bvh8_waiting_slots_pop(waiting);
     }
-    
+
     return out;
 }
     `, [
-        BVH_NULL_NODE_DEFINITION,
+        BVH8_INODE_STRUCT.declaration_chunk,
+        GEOMETRY_METADATA_STRUCT.declaration_chunk,
+        MESHLET_METADATA_STRUCT.declaration_chunk,
         SURFACE_POINT_3D.declaration_chunk,
-        chunk_f32_array_as_vec3,
-        chunk_geometry_read_triangle_vertices,
-        chunk_aabb3_unsigned_distance_sqr_to_point,
+        chunk_bvh8_node_slot_distances,
+        chunk_bvh8_waiting_slots,
+        chunk_read_meshlet_resolved_index,
+        chunk_read_meshlet_vertex_position,
         chunk_triangle_closest_point_to_point_barycentric,
         chunk_compute_triangle_face_normal,
     ]
-);
+);

package/src/shade/renderer/shader/chunk/sdf/chunk_scene_point_query_nearest.d.ts

@@ -1,3 +1,24 @@
+/**
+ * The nearest point of any instance's surface to a point in the world, within `max_distance`:
+ *
+ * ```wgsl
+ * fn scene_point_query_nearest(position: vec3<f32>, max_distance: f32) -> SurfacePoint3D
+ * ```
+ *
+ * `primitive` is the `meshes` row of the instance the point lies on, or all ones when there is none;
+ * `position` and `normal` are in the world.
+ *
+ * The TLAS is walked nearest box first: an instance, or a child node, is passed by once the best
+ * found is nearer than its box. A node's instances are asked before its children, each in its own
+ * space ({@link chunk_point_query_blas_nearest}).
+ *
+ * One stack serves both levels, a node in the first word of an entry: the BLAS under an instance
+ * takes the entries above the TLAS walk's own.
+ *
+ * The enclosing shader binds `tlas`, `scene_database` and the BLAS buffers.
+ *
+ * @type {CodeChunk}
+ */
 export const chunk_scene_point_query_nearest: CodeChunk;
 import { CodeChunk } from "../../compiler/CodeChunk.js";
 //# sourceMappingURL=chunk_scene_point_query_nearest.d.ts.map

package/src/shade/renderer/shader/chunk/sdf/chunk_scene_point_query_nearest.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_scene_point_query_nearest.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/sdf/chunk_scene_point_query_nearest.js"],"names":[],"mappings":"AAeA,wDAqHE;0BAlIwB,6BAA6B"}
+{"version":3,"file":"chunk_scene_point_query_nearest.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/sdf/chunk_scene_point_query_nearest.js"],"names":[],"mappings":"AAiBA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,8CAFU,SAAS,CAyIjB;0BA1KwB,6BAA6B"}

package/src/shade/renderer/shader/chunk/sdf/chunk_scene_point_query_nearest.js

@@ -1,11 +1,11 @@
+import { assert } from "../../../../../core/assert.js";
 import { UINT32_MAX } from "../../../../../core/binary/UINT32_MAX.js";
 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_unsigned_distance_sqr_to_point
-} from "../geometry/aabb3/chunk_aabb3_unsigned_distance_sqr_to_point.js";
+import { BVH8_TLAS_MAX_DEPTH, BVH8_TRAVERSAL_STACK_SIZE } from "../bvh/bvh8/webgpu/BVH8_MAX_DEPTH.js";
+import { chunk_bvh8_node_slot_distances } from "../bvh/bvh8/webgpu/chunk_bvh8_node_slot_distances.js";
+import { chunk_bvh8_tree_read } from "../bvh/bvh8/webgpu/chunk_bvh8_tree_read.js";
+import { BVH8_WAITING_SLOTS_CAPACITY, chunk_bvh8_waiting_slots } from "../bvh/bvh8/webgpu/chunk_bvh8_waiting_slots.js";
 import { chunk_mat4_inverse } from "../geometry/mat4/chunk_mat4_inverse.js";
 import { chunk_v3_matrix4_project } from "../geometry/vec3/chunk_v3_matrix4_project.js";
 import { chunk_v3_matrix4_rotate } from "../geometry/vec3/chunk_v3_matrix4_rotate.js";
@@ -13,121 +13,162 @@ import { F32_MAX_DEFINITION } from "../math/F32_MAX_DEFINITION.js";
 import { chunk_point_query_blas_nearest } from "./chunk_point_query_blas_nearest.js";
 import { SURFACE_POINT_3D } from "./SURFACE_POINT_3D.js";
 
+assert.lessThanOrEqual(BVH8_TLAS_MAX_DEPTH, BVH8_WAITING_SLOTS_CAPACITY, 'the TLAS may be deeper than the walk can keep slots for');
+
+/**
+ * The nearest point of any instance's surface to a point in the world, within `max_distance`:
+ *
+ * ```wgsl
+ * fn scene_point_query_nearest(position: vec3<f32>, max_distance: f32) -> SurfacePoint3D
+ * ```
+ *
+ * `primitive` is the `meshes` row of the instance the point lies on, or all ones when there is none;
+ * `position` and `normal` are in the world.
+ *
+ * The TLAS is walked nearest box first: an instance, or a child node, is passed by once the best
+ * found is nearer than its box. A node's instances are asked before its children, each in its own
+ * space ({@link chunk_point_query_blas_nearest}).
+ *
+ * One stack serves both levels, a node in the first word of an entry: the BLAS under an instance
+ * takes the entries above the TLAS walk's own.
+ *
+ * The enclosing shader binds `tlas`, `scene_database` and the BLAS buffers.
+ *
+ * @type {CodeChunk}
+ */
 export const chunk_scene_point_query_nearest = CodeChunk.from(
     //language=WGSL
     `
-fn scene_point_query_nearest(position: vec3<f32>, max_distance: f32) -> ${SURFACE_POINT_3D.wgsl_ref}{
+fn scene_point_query_nearest(position: vec3<f32>, max_distance: f32) -> ${SURFACE_POINT_3D.wgsl_ref} {
+    var stack: array<vec2u, ${BVH8_TRAVERSAL_STACK_SIZE}>;
+    var pointer = 0u;
+
+    // the slots still to visit of each node waiting on the stack; none for a child waiting as itself
+    var waiting = vec4<u32>(0u);
 
-    var stack = array<u32, ${BVH_TRAVERSAL_STACK_SIZE}>();
-    var node_index = tlas.root;
-    var pointer = 1u;
-    
     var nearest_distance_sqr = max_distance * max_distance;
-    
+
     var out: ${SURFACE_POINT_3D.wgsl_ref};
-    out.primitive = ${UINT32_MAX}; // used to indicate a miss on output
-    
+    out.primitive = ${UINT32_MAX}u; // a miss, until something is found
 
-    for(;pointer > 0u && pointer <= ${BVH_TRAVERSAL_STACK_SIZE};){
+    // the node being looked at, and which of its child slots are still to visit
+    var node_index = 0u;
+    var pending = 0u;
+    var arriving = true;
 
-        let node = tlas.nodes[node_index];
-        let child_1 = node.child_1;
-        let child_2 = node.child_2;
+    loop {
+        let node = bvh8_tree_read_node(&tlas, node_index);
+        let distances = bvh8_node_slot_distances_sqr(node, position);
 
-        if(child_1 != BVH_NULL_NODE){
-            // not a leaf node
-            let child_1_bounds = tlas.nodes[ child_1 ].bounds;
-            let distance_sqr_to_child1 = aabb3_unsigned_distance_sqr_to_point(child_1_bounds, position);
+        let imask = node.data[0].w >> 24u;
 
-            let child_2_bounds = tlas.nodes[ child_2 ].bounds;
-            let distance_sqr_to_child2 = aabb3_unsigned_distance_sqr_to_point(child_2_bounds, position);
+        if (arriving) {
+            // this node's own instances first: what they find prunes its children
+            let runs = bvh8_node_slot_runs(node);
 
-            // sort children
-            var sorted_children = vec2(child_1, child_2);
-            var sorted_distances =  vec2(distance_sqr_to_child1, distance_sqr_to_child2);
+            var run = bvh8_slot_runs_within(runs, distances, nearest_distance_sqr);
 
-            if (distance_sqr_to_child2 < distance_sqr_to_child1) {
+            while (run != 0u) {
+                let offset = countTrailingZeros(run);
 
-                sorted_children = sorted_children.yx;
-                sorted_distances = sorted_distances.yx;
+                run &= run - 1u;
 
-            }
+                // a leaf's payload is the instance's meshes row
+                let mesh_id = bvh8_tree_read_payload(&tlas, node, offset);
 
-            if(sorted_distances.y < nearest_distance_sqr){
-                // both children are within range
+                let mesh = scene_read_mesh(&scene_database, mesh_id);
+                let placement = scene_read_node(&scene_database, mesh.node);
 
-                node_index = sorted_children.x;
+                let geometry_position = v3_matrix4_project(position, mat4_inverse(placement.global));
 
-                stack[ pointer ] = sorted_children.y;
+                let geometry_hit = point_query_blas_nearest(
+                    geometry_position,
+                    F32_MAX, // TODO consider passing a sensible max-distance
+                    mesh.geometry,
+                    &stack,
+                    pointer
+                );
 
-                pointer ++;
+                if (geometry_hit.primitive == ${UINT32_MAX}u) {
+                    // a geometry with no triangles
+                    continue;
+                }
 
-            }else if(sorted_distances.x < nearest_distance_sqr){
+                let mesh_hit_point = v3_matrix4_project(geometry_hit.position, placement.global);
 
-                node_index = sorted_children.x;
+                let offset_to_mesh = mesh_hit_point - position;
+                let distance_to_mesh_sqr = dot(offset_to_mesh, offset_to_mesh);
 
-            }else{
+                if (distance_to_mesh_sqr >= nearest_distance_sqr) {
+                    continue;
+                }
 
-                pointer --;
-                node_index = stack[pointer];
+                nearest_distance_sqr = distance_to_mesh_sqr;
 
-            }
+                out.primitive = mesh_id;
+                out.normal = v3_matrix4_rotate(geometry_hit.normal, placement.global);
+                out.position = mesh_hit_point;
 
-        }else{
+                // slots no nearer than this are done with
+                run &= bvh8_slot_runs_within(runs, distances, nearest_distance_sqr);
+            }
 
-            pointer --;
-            node_index = stack[pointer];
+            pending = imask;
+        }
 
-            let mesh_id = child_2;
-            let mesh = scene_read_mesh(&scene_database, mesh_id);
-            let node = scene_read_node(&scene_database, mesh.node);
+        // the children still to visit that are worth one
+        let worthwhile = bvh8_slots_within(distances, nearest_distance_sqr) & pending;
 
-            let geometry_id = mesh.geometry;
+        if (worthwhile != 0u) {
+            let nearest_slot = bvh8_nearest_slot_among(distances, worthwhile);
 
-            let geometry_position = v3_matrix4_project(position, mat4_inverse(node.global));
+            // the node's children sit in one block, in slot order
+            let child_block = node.data[1].x;
 
-            let geometry_hit = point_query_blas_nearest(
-                geometry_position,
-                F32_MAX, // TODO consider passing a sensible max-distance
-                geometry_id,
-                &stack,
-                pointer
-            );
+            let later = worthwhile & ~(1u << nearest_slot);
 
-            if(geometry_hit.primitive == ${UINT32_MAX}){
-                // got nothing, this should not happen though
-                continue;
-            }
+            if (later != 0u && pointer < ${BVH8_TLAS_MAX_DEPTH}u) {
+                let lone = (later & (later - 1u)) == 0u;
 
-            let mesh_hit_point = v3_matrix4_project(geometry_hit.position, node.global);
+                stack[pointer].x = select(node_index, child_block + countOneBits(imask & (later - 1u)), lone);
 
-            let distance_to_mesh = distance(mesh_hit_point, position);
-            let distance_to_mesh2 = distance_to_mesh*distance_to_mesh;
+                pointer++;
 
-            if (distance_to_mesh2 >= nearest_distance_sqr) {
-                continue;
+                waiting = bvh8_waiting_slots_push(waiting, select(later, 0u, lone));
             }
 
-            nearest_distance_sqr = distance_to_mesh2;
+            node_index = child_block + countOneBits(imask & ((1u << nearest_slot) - 1u));
+            arriving = true;
 
-            out.primitive = mesh_id;
-            out.normal = v3_matrix4_rotate(geometry_hit.normal, node.global);
-            out.position = mesh_hit_point;
+            continue;
+        }
 
+        // nothing more under this node: back to whatever waits
+        if (pointer == 0u) {
+            break;
         }
+
+        pointer--;
+
+        node_index = stack[pointer].x;
+        pending = bvh8_waiting_slots_latest(waiting);
+        arriving = pending == 0u;
+
+        waiting = bvh8_waiting_slots_pop(waiting);
     }
-    
+
     return out;
 }
-`, [
+    `, [
         SURFACE_POINT_3D.declaration_chunk,
-        BVH_NULL_NODE_DEFINITION,
         F32_MAX_DEFINITION,
+        chunk_bvh8_tree_read,
+        chunk_bvh8_node_slot_distances,
+        chunk_bvh8_waiting_slots,
         chunk_point_query_blas_nearest,
-        chunk_aabb3_unsigned_distance_sqr_to_point,
         chunk_v3_matrix4_project,
         chunk_v3_matrix4_rotate,
         chunk_mat4_inverse,
         chunk_scene_database_access,
     ]
-);
+);

package/src/shade/renderer/shader/chunk/sdf/chunk_scene_sdf_raymarch.d.ts

@@ -5,8 +5,11 @@
  * fn scene_sdf_raymarch_hit(ray: Ray) -> SceneSDFHit // t = F32_MAX for none
  * ```
  *
- * The TLAS is walked nearest box first; in every instance it meets, the ray marches that geometry's
- * sparse field at level 0 in its local space, whose t is the world one.
+ * The TLAS is walked with the ray, nearer slots first by the ray's octant, and the ray is shortened
+ * at every hit; in every instance whose box it still reaches, the ray marches that geometry's sparse
+ * field at level 0 in its local space, whose t is the world one.
+ *
+ * The enclosing shader binds `tlas`, `scene_database` and the mesh SDF buffers.
  *
  * @type {CodeChunk}
  */

package/src/shade/renderer/shader/chunk/sdf/chunk_scene_sdf_raymarch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_scene_sdf_raymarch.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/sdf/chunk_scene_sdf_raymarch.js"],"names":[],"mappings":"AAeA;;;;;;;;;;;GAWG;AACH,2CAFU,SAAS,CAiGjB;AAEF;;;;;;;;GAQG;AACH,uCAFU,SAAS,CAYjB;0BA5IwB,6BAA6B"}
+{"version":3,"file":"chunk_scene_sdf_raymarch.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/sdf/chunk_scene_sdf_raymarch.js"],"names":[],"mappings":"AAeA;;;;;;;;;;;;;;GAcG;AACH,2CAFU,SAAS,CAwHjB;AAEF;;;;;;;;GAQG;AACH,uCAFU,SAAS,CAYjB;0BAtKwB,6BAA6B"}