@woosh/meep-engine 3.68.0 → 3.70.0

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

@@ -1,13 +1,13 @@
-import { chunk_scene_database_access } from "../../../scene/chunk_scene_database_access.js";
 import { chunk_mesh_sdf_raymarch } from "../../../geometry/sdf/chunk_mesh_sdf_raymarch.js";
 import { chunk_mesh_sdf_header } from "../../../geometry/sdf/chunk_mesh_sdf_sample.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_distance_to_ray } from "../geometry/aabb3/chunk_aabb3_distance_to_ray.js";
-import { chunk_aabb3_unsigned_distance_to_point } from "../geometry/aabb3/chunk_aabb3_unsigned_distance_to_point.js";
-import { chunk_array_to_aabb3 } from "../geometry/aabb3/chunk_array_to_aabb3.js";
+import { chunk_first_bit_high } from "../binary/chunk_first_bit_high.js";
+import { BVH8_TLAS_MAX_DEPTH } 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 "../geometry/mat4/chunk_mat4_inverse.js";
 import { chunk_ray_transform_m4 } from "../geometry/ray/chunk_ray_transform_m4.js";
 import { RAY_STRUCT } from "../geometry/ray/RAY_STRUCT.js";
@@ -20,8 +20,11 @@ import { F32_MAX_DEFINITION } from "../math/F32_MAX_DEFINITION.js";
  * 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}
  */
@@ -33,87 +36,110 @@ struct SceneSDFHit {
     mesh: u32,
 }
 
-fn scene_sdf_raymarch_hit(ray:${RAY_STRUCT.wgsl_ref}) -> SceneSDFHit{
-    var node_index = tlas.root;
+fn scene_sdf_raymarch_hit(ray: ${RAY_STRUCT.wgsl_ref}) -> SceneSDFHit {
+    // the walk has the stack to itself: a field is marched, not walked
+    var stack: array<vec2u, ${BVH8_TLAS_MAX_DEPTH}>;
+    var pointer = 0u;
 
-    var stack:array<u32, ${BVH_TRAVERSAL_STACK_SIZE}>;
-    var pointer  = 1u;
-        
     var best: SceneSDFHit;
 
     best.t = F32_MAX;
-        
-    for(;pointer > 0 && pointer <= ${BVH_TRAVERSAL_STACK_SIZE};){
-            
-        let node = tlas.nodes[node_index];
-        
-        let distance_to_node = aabb_distance_to_ray(node.bounds, ray);
-        
-        if(distance_to_node > best.t){
-            
-            pointer --;
-            node_index = stack[pointer];
-            
-            continue;
+
+    // shortened as hits are found
+    var reach_ray = ray;
+
+    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_TLAS_MAX_DEPTH}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(reach_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);
 
             /*
              The ray enters the instance with its direction made unit there, so a hit's parameter
              there is in the instance's units: a stretch of the world's, the length of the world
              direction under the inverse. Over the stretch it is a world distance again.
             */
-            let to_local = mat4_inverse(node.global);
-            let geometry_ray = ray_transform_m4(ray, to_local);
+            let to_local = mat4_inverse(placement.global);
+            let geometry_ray = ray_transform_m4(reach_ray, to_local);
             let stretch = length((to_local * vec4<f32>(ray.direction, 0.0)).xyz);
 
             let local_t = mesh_sdf_raymarch(mesh_sdf_header(mesh.geometry), 0u, geometry_ray);
             let distance = select(local_t / stretch, -1.0, local_t < 0.0);
 
-            if(distance < 0.0 || distance >= best.t){
+            if (distance < 0.0 || distance >= best.t) {
                 continue;
             }
-            
-            // found a good hit
+
             best.t = distance;
             best.mesh = mesh_id;
-            
-            
+
+            reach_ray.tmax = distance;
+        }
+
+        if ((current_group.y & 0xff000000u) == 0u) {
+            if (pointer == 0u) {
+                break;
+            }
+
+            pointer--;
+            current_group = stack[pointer];
         }
-        
     }
-        
-       
+
     return best;
 }
     `, [
-        BVH_NULL_NODE_DEFINITION,
+        RAY_STRUCT.declaration_chunk,
+        chunk_first_bit_high,
+        chunk_ray_get_octant_inv4,
+        chunk_bvh8_node_intersect,
+        chunk_bvh8_ray_direction_rcp,
+        chunk_bvh8_tree_read,
         chunk_mat4_inverse,
-        chunk_aabb3_distance_to_ray,
-        chunk_aabb3_unsigned_distance_to_point,
-        chunk_array_to_aabb3,
         chunk_ray_transform_m4,
         F32_MAX_DEFINITION,
         chunk_mesh_sdf_header,
@@ -141,4 +167,4 @@ fn scene_sdf_raymarch(ray:${RAY_STRUCT.wgsl_ref}) -> f32{
         RAY_STRUCT.declaration_chunk,
         chunk_scene_sdf_raymarch_hit,
     ]
-);
+);

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

@@ -1,3 +1,18 @@
+/**
+ * The least signed distance from a point to any instance's field:
+ *
+ * ```wgsl
+ * fn sdf_query_distance(position: vec3<f32>) -> f32 // F32_MAX in a scene of no instances
+ * ```
+ *
+ * The TLAS is walked nearest box first by the signed distance to a slot's box, which nothing under
+ * the slot is nearer than: 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.
+ *
+ * The enclosing shader binds `tlas` and what `mesh_sdf_query_distance` reads.
+ *
+ * @type {CodeChunk}
+ */
 export const chunk_sdf_query_distance: CodeChunk;
 import { CodeChunk } from "../../compiler/CodeChunk.js";
 //# sourceMappingURL=chunk_sdf_query_distance.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"chunk_sdf_query_distance.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/sdf/chunk_sdf_query_distance.js"],"names":[],"mappings":"AASA,iDAuEE;0BA/EwB,6BAA6B"}
+{"version":3,"file":"chunk_sdf_query_distance.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/sdf/chunk_sdf_query_distance.js"],"names":[],"mappings":"AAWA;;;;;;;;;;;;;;GAcG;AACH,uCAFU,SAAS,CAqGjB;0BA5HwB,6BAA6B"}

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

@@ -1,81 +1,126 @@
 import { chunk_mesh_sdf_query_distance } from "../../../shadow/sdf/chunk_mesh_sdf_query_distance.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_signed_distance_to_point } from "../geometry/aabb3/chunk_aabb3_signed_distance_to_point.js";
-
-import { chunk_aabb3_unsigned_distance_to_point } from "../geometry/aabb3/chunk_aabb3_unsigned_distance_to_point.js";
+import { BVH8_TLAS_MAX_DEPTH } 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 { assert } from "../../../../../core/assert.js";
 import { F32_MAX_DEFINITION } from "../math/F32_MAX_DEFINITION.js";
 
+assert.lessThanOrEqual(BVH8_TLAS_MAX_DEPTH, BVH8_WAITING_SLOTS_CAPACITY, 'the TLAS may be deeper than the walk can keep slots for');
+
+/**
+ * The least signed distance from a point to any instance's field:
+ *
+ * ```wgsl
+ * fn sdf_query_distance(position: vec3<f32>) -> f32 // F32_MAX in a scene of no instances
+ * ```
+ *
+ * The TLAS is walked nearest box first by the signed distance to a slot's box, which nothing under
+ * the slot is nearer than: 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.
+ *
+ * The enclosing shader binds `tlas` and what `mesh_sdf_query_distance` reads.
+ *
+ * @type {CodeChunk}
+ */
 export const chunk_sdf_query_distance = CodeChunk.from(
     //language=WGSL
     `
-fn sdf_query_distance (position: vec3<f32>) -> f32{
-    
-    var node_index = tlas.root;
-
-    
-    var stack:array<u32, ${BVH_TRAVERSAL_STACK_SIZE}>;
-    var pointer  = 1u;
-        
+fn sdf_query_distance(position: vec3<f32>) -> f32 {
+    // a node an entry, and nothing under the tree to share the stack with
+    var stack: array<u32, ${BVH8_TLAS_MAX_DEPTH}>;
+    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 best_distance = F32_MAX;
-        
-    for(;pointer > 0 && pointer <= ${BVH_TRAVERSAL_STACK_SIZE};){
-            
-        let node = tlas.nodes[node_index];
-        
-        let distance_to_node = aabb3_signed_distance_to_point(node.bounds, position);
-        
-        if(distance_to_node > best_distance){
-            
-            pointer --;
-            node_index = stack[pointer];
-            
-            continue;
+
+    // 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;
+
+    loop {
+        let node = bvh8_tree_read_node(&tlas, node_index);
+        let distances = bvh8_node_slot_signed_distances(node, position);
+
+        let imask = node.data[0].w >> 24u;
+
+        if (arriving) {
+            // this node's own instances first: what they find prunes its children
+            let runs = bvh8_node_slot_runs(node);
+
+            var run = bvh8_slot_runs_within(runs, distances, best_distance);
+
+            while (run != 0u) {
+                let offset = countTrailingZeros(run);
+
+                run &= run - 1u;
+
+                // a leaf's payload is the instance's meshes row
+                let signed_distance = mesh_sdf_query_distance(bvh8_tree_read_payload(&tlas, node, offset), position);
+
+                if (signed_distance < best_distance) {
+                    best_distance = signed_distance;
+
+                    // slots no nearer than this are done with
+                    run &= bvh8_slot_runs_within(runs, distances, best_distance);
+                }
+            }
+
+            pending = imask;
         }
-        
-        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;
-            
-            let signed_distance = mesh_sdf_query_distance(mesh_id, position);
-
-            if(signed_distance >= best_distance){
-                continue;
+
+        // the children still to visit that are worth one
+        let worthwhile = bvh8_slots_within(distances, best_distance) & 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 = node.data[1].x;
+
+            let later = worthwhile & ~(1u << nearest_slot);
+
+            if (later != 0u && pointer < ${BVH8_TLAS_MAX_DEPTH}u) {
+                let lone = (later & (later - 1u)) == 0u;
+
+                stack[pointer] = select(node_index, child_block + countOneBits(imask & (later - 1u)), lone);
+
+                pointer++;
+
+                waiting = bvh8_waiting_slots_push(waiting, select(later, 0u, lone));
             }
-            
-            // found a good hit
-            best_distance = signed_distance;
-            
-            
+
+            node_index = child_block + countOneBits(imask & ((1u << nearest_slot) - 1u));
+            arriving = true;
+
+            continue;
+        }
+
+        // nothing more under this node: back to whatever waits
+        if (pointer == 0u) {
+            break;
         }
-        
+
+        pointer--;
+
+        node_index = stack[pointer];
+        pending = bvh8_waiting_slots_latest(waiting);
+        arriving = pending == 0u;
+
+        waiting = bvh8_waiting_slots_pop(waiting);
     }
-        
-       
+
     return best_distance;
 }
     `, [
-        BVH_NULL_NODE_DEFINITION,
-        chunk_aabb3_unsigned_distance_to_point,
-        chunk_aabb3_signed_distance_to_point,
         F32_MAX_DEFINITION,
+        chunk_bvh8_tree_read,
+        chunk_bvh8_node_slot_distances,
+        chunk_bvh8_waiting_slots,
         chunk_mesh_sdf_query_distance,
     ]
-);
+);

package/src/shade/renderer/shadow/sdf/chunk_ray_query_sdf_raycast.d.ts

@@ -1,3 +1,17 @@
+/**
+ * The distance along a ray to the nearest instance's field, by `sdf_mesh_raymarch`:
+ *
+ * ```wgsl
+ * fn ray_query_sdf_raycast(ray: Ray) -> f32 // -1 for no hit within the ray's reach
+ * ```
+ *
+ * The TLAS is walked with the ray, nearer slots first by the ray's octant, and the ray is shortened
+ * at every hit.
+ *
+ * The enclosing shader binds `tlas` and what `sdf_mesh_raymarch` reads.
+ *
+ * @type {CodeChunk}
+ */
 export const chunk_ray_query_sdf_raycast: CodeChunk;
 import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
 //# sourceMappingURL=chunk_ray_query_sdf_raycast.d.ts.map

package/src/shade/renderer/shadow/sdf/chunk_ray_query_sdf_raycast.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_ray_query_sdf_raycast.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shadow/sdf/chunk_ray_query_sdf_raycast.js"],"names":[],"mappings":"AAQA,oDAuEE;0BA1EwB,oCAAoC"}
+{"version":3,"file":"chunk_ray_query_sdf_raycast.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shadow/sdf/chunk_ray_query_sdf_raycast.js"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;GAaG;AACH,0CAFU,SAAS,CA2FjB;0BA1GwB,oCAAoC"}

package/src/shade/renderer/shadow/sdf/chunk_ray_query_sdf_raycast.js

@@ -1,80 +1,114 @@
-import { BVH_NULL_NODE_DEFINITION } from "../../shader/chunk/bvh/BVH_NULL_NODE_DEFINITION.js";
-import { BVH_TRAVERSAL_STACK_SIZE } from "../../shader/chunk/bvh/BVH_TRAVERSAL_STACK_SIZE.js";
-import { chunk_aabb3_intersects_ray } from "../../shader/chunk/geometry/aabb3/chunk_aabb3_intersects_ray.js";
-import { chunk_ray_transform_m4 } from "../../shader/chunk/geometry/ray/chunk_ray_transform_m4.js";
+import { chunk_first_bit_high } from "../../shader/chunk/binary/chunk_first_bit_high.js";
+import { BVH8_TLAS_MAX_DEPTH } from "../../shader/chunk/bvh/bvh8/webgpu/BVH8_MAX_DEPTH.js";
+import { chunk_bvh8_node_intersect } from "../../shader/chunk/bvh/bvh8/webgpu/chunk_bvh8_node_intersect.js";
+import { chunk_bvh8_ray_direction_rcp } from "../../shader/chunk/bvh/bvh8/webgpu/chunk_bvh8_ray_direction_rcp.js";
+import { chunk_bvh8_tree_read } from "../../shader/chunk/bvh/bvh8/webgpu/chunk_bvh8_tree_read.js";
+import { chunk_ray_get_octant_inv4 } from "../../shader/chunk/bvh/bvh8/webgpu/chunk_ray_get_octant_inv4.js";
 import { RAY_STRUCT } from "../../shader/chunk/geometry/ray/RAY_STRUCT.js";
 import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
 import { chunk_sdf_mesh_raymarch } from "./chunk_sdf_mesh_raymarch.js";
 
+/**
+ * The distance along a ray to the nearest instance's field, by `sdf_mesh_raymarch`:
+ *
+ * ```wgsl
+ * fn ray_query_sdf_raycast(ray: Ray) -> f32 // -1 for no hit within the ray's reach
+ * ```
+ *
+ * The TLAS is walked with the ray, nearer slots first by the ray's octant, and the ray is shortened
+ * at every hit.
+ *
+ * The enclosing shader binds `tlas` and what `sdf_mesh_raymarch` reads.
+ *
+ * @type {CodeChunk}
+ */
 export const chunk_ray_query_sdf_raycast = CodeChunk.from(
     //language=WGSL
     `
-fn ray_query_sdf_raycast( in_ray: ${RAY_STRUCT.wgsl_ref} ) -> f32 {
-    var stack = array<u32, ${BVH_TRAVERSAL_STACK_SIZE}>();
-    
-    let direction_rcp = 1.0 / in_ray.direction;
-    
-    var node_index = tlas.root;
-    var pointer = 1u;
-    
+fn ray_query_sdf_raycast(in_ray: ${RAY_STRUCT.wgsl_ref}) -> f32 {
+    // the walk has the stack to itself: a field is marched, not walked
+    var stack: array<vec2u, ${BVH8_TLAS_MAX_DEPTH}>;
+    var pointer = 0u;
+
+    // shortened as hits are found
     var _ray = in_ray;
-    
-    for(;pointer > 0 && pointer <= ${BVH_TRAVERSAL_STACK_SIZE};){
-                    
-        let node = tlas.nodes[node_index];
-        
-        if(!aabb3_intersects_ray(node.bounds, _ray.origin, direction_rcp, _ray.tmax)){
-        
-            pointer --;
-            node_index = stack[pointer];
-            
-            continue;
+
+    let oct_inv4 = ray_get_octant_inv4(in_ray.direction);
+    let direction_rcp = bvh8_ray_direction_rcp(in_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_TLAS_MAX_DEPTH}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 distance = sdf_mesh_raymarch(_ray, child_2);
-                     
-            if(distance >= _ray.tmin && distance < _ray.tmax){
+
+        // 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 distance = sdf_mesh_raymarch(_ray, bvh8_tree_read_payload(&tlas, node, offset));
+
+            if (distance >= 0.0 && distance < _ray.tmax) {
                 _ray.tmax = distance;
             }
-                        
         }
-        
+
+        if ((current_group.y & 0xff000000u) == 0u) {
+            if (pointer == 0u) {
+                break;
+            }
+
+            pointer--;
+            current_group = stack[pointer];
+        }
     }
-    
-    if(_ray.tmax < in_ray.tmax){
+
+    if (_ray.tmax < in_ray.tmax) {
         // got a hit
         return _ray.tmax;
     }
-    
-    return -1;
+
+    return -1.0;
 }
     `, [
-
         RAY_STRUCT.declaration_chunk,
-        BVH_NULL_NODE_DEFINITION,
-        chunk_ray_transform_m4,
-        chunk_aabb3_intersects_ray,
-        chunk_sdf_mesh_raymarch
+        chunk_first_bit_high,
+        chunk_ray_get_octant_inv4,
+        chunk_bvh8_node_intersect,
+        chunk_bvh8_ray_direction_rcp,
+        chunk_bvh8_tree_read,
+        chunk_sdf_mesh_raymarch,
     ]
-);
+);

package/src/shade/renderer/shadow/sdf/graph_draw_sdf_shadows.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_draw_sdf_shadows.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shadow/sdf/graph_draw_sdf_shadows.js"],"names":[],"mappings":"AA8HA;;;;;;;;;;GAUG;AACH;IAR+B,KAAK;IACD,IAAI;IACZ,WAAW,EAA3B,MAAM;IACU,SAAS,EAAzB,MAAM;IACU,gBAAgB,EAAhC,MAAM;IACU,sBAAsB,EAAtC,MAAM;IACJ,MAAM,CAgGlB;AApHD,kDASG;4BAjGyB,6BAA6B"}
+{"version":3,"file":"graph_draw_sdf_shadows.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shadow/sdf/graph_draw_sdf_shadows.js"],"names":[],"mappings":"AA8HA;;;;;;;;;;GAUG;AACH;IAR+B,KAAK;IACD,IAAI;IACZ,WAAW,EAA3B,MAAM;IACU,SAAS,EAAzB,MAAM;IACU,gBAAgB,EAAhC,MAAM;IACU,sBAAsB,EAAtC,MAAM;IACJ,MAAM,CAgGlB;AApHD,kDASG;4BAlGyB,6BAA6B"}