@woosh/meep-engine 3.69.0 → 3.70.0

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

@@ -1,100 +1,151 @@
 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_geometry_read_triangle_vertices } from "../format/chunk_geometry_read_triangle_vertices.js";
+import { chunk_extract_byte } from "../../binary/chunk_extract_byte.js";
+import { chunk_first_bit_high } from "../../binary/chunk_first_bit_high.js";
+import {
+    chunk_geometry_read_triangle_positions
+} from "../format/chunk_geometry_read_triangle_positions.js";
 import {
     chunk_ray_triangle_compute_intersection_barycentric
 } from "./chunk_ray_triangle_compute_intersection_barycentric.js";
 import { RAY_HIT_INFO } from "./RAY_HIT_INFO.js";
 import { RAY_STRUCT } from "./RAY_STRUCT.js";
+import { BVH8_INODE_STRUCT } from "../../bvh/bvh8/webgpu/BVH8_INODE_STRUCT.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_ray_get_octant_inv4 } from "../../bvh/bvh8/webgpu/chunk_ray_get_octant_inv4.js";
 
+/**
+ * Nearest hit against one geometry's tree.
+ *
+ * Two-sided. `t` is -1 on a miss, and on a hit `triangle` is the
+ * `(meshlet << 8) | triangle` id and `barycentrics` the hit's coordinates on it. `geometry` and
+ * `instance` are left for the caller.
+ *
+ * A node's triangles are `base_index_triangle` plus an offset, and the sum is the id as it stands — so
+ * the tree must address triangles as {@link bvh8_build_for_meshlets} makes it.
+ *
+ * Children are visited in the order the ray's octant ranks their slots, nearer first, and the ray is
+ * shortened at every hit: a node tested after a hit is tested against the shorter ray. Groups already
+ * on the stack keep the hits they were given, so a node behind a later hit is still fetched once, and
+ * rejected there.
+ *
+ * `stack` is the caller's, used from `stack_top` up and handed back as it was found. A group of
+ * sibling nodes waits on it only while the walk is below one of its members, so the walk needs one
+ * entry per level of the tree.
+ *
+ * @see https://github.com/jan-van-bergen/GPU-Raytracer/blob/6559ae2241c8fdea0ddaec959fe1a47ec9b3ab0d/Src/CUDA/Raytracing/BVH8.h#L277
+ * @type {CodeChunk}
+ */
 export const chunk_ray_query_blas_nearest = CodeChunk.from(
     //language=WGSL
     `
 fn ray_query_blas_nearest(
     ray: ${RAY_STRUCT.wgsl_ref},
     geometry_index: u32,
-    stack:ptr<function, array< u32, ${BVH_TRAVERSAL_STACK_SIZE}> >,
-    stack_top: u32
+    stack: ptr<function, array<vec2u, ${BVH8_TRAVERSAL_STACK_SIZE}>>,
+    stack_top: u32,
 ) -> ${RAY_HIT_INFO.wgsl_ref} {
 
     let geometry = geometries[geometry_index];
-    
+
     let blas_address = blas_lookup[geometry_index];
-             
-    var pointer = stack_top + 1;
-        
-    let direction_rcp = 1.0 / ray.direction;
-        
+
     var best_hit: ${RAY_HIT_INFO.wgsl_ref};
     best_hit.t = -1.0;
-    
+
+    // shortened as hits are found
     var _ray = ray;
-    
-    var node_index = 0u;
-    
-    for(;pointer > stack_top && pointer <= ${BVH_TRAVERSAL_STACK_SIZE};){
-        
-        let node = blas_data[ blas_address + node_index ];
-            
-        if(!aabb3_intersects_ray( node.bounds, _ray.origin, direction_rcp, _ray.tmax)){
-            
-            pointer --;
-            node_index = stack[pointer];
-            
-            continue;
-        
+
+    var pointer = stack_top;
+
+    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){
-            // not a leaf node
-            
-            node_index = child_1;
-            
-            stack[ pointer ] = child_2;
-            
-            pointer ++;
-            
-        }else{
-            pointer --;
-            node_index = stack[pointer];
-            
-            let encoded_triangle_id = child_2;
-                        
-            let triangle = geometry_read_triangle_vertices(geometry, encoded_triangle_id);
-            
-            let a = triangle.a.position;
-            let b = triangle.b.position;
-            let c = triangle.c.position;
-            
-            var triangle_hit:vec3<f32>;
-            
-            if(!ray_triangle_compute_intersection_barycentric(&triangle_hit, _ray, a, b, c)){
-                // miss
-                continue;
+
+        // 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_INODE_STRUCT.wgsl_ref} = blas_data[blas_address + 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) | extract_byte(node.data[0].w, 3u);
+
+        let triangle_base = node.data[1].y;
+
+        // one bit per triangle whose slot the ray reaches
+        var triangle_hits = hitmask & 0x00ffffffu;
+
+        while (triangle_hits != 0u) {
+            let triangle_offset = first_bit_high(triangle_hits);
+
+            triangle_hits &= ~(1u << triangle_offset);
+
+            let encoded_triangle_id = triangle_base + triangle_offset;
+
+            var v0: vec3f;
+            var v1: vec3f;
+            var v2: vec3f;
+
+            geometry_read_triangle_positions(&v0, &v1, &v2, geometry, encoded_triangle_id);
+
+            var triangle_hit: vec3<f32>;
+
+            if (ray_triangle_compute_intersection_barycentric(&triangle_hit, _ray, v0, v1, v2)) {
+                _ray.tmax = triangle_hit.z;
+
+                best_hit.t = triangle_hit.z;
+                best_hit.barycentrics = triangle_hit.xy;
+                best_hit.triangle = encoded_triangle_id;
             }
-                        
-            _ray.tmax = triangle_hit.z;
-            
-            best_hit.t = triangle_hit.z;
-            best_hit.barycentrics = triangle_hit.xy;
-            best_hit.triangle = encoded_triangle_id;
+        }
+
+        if ((current_group.y & 0xff000000u) == 0u) {
+            if (pointer == stack_top) {
+                break;
+            }
+
+            pointer--;
+            current_group = stack[pointer];
         }
     }
-    
-    return best_hit;
 
+    return best_hit;
 }
-  `, [
+    `, [
+        BVH8_INODE_STRUCT.declaration_chunk,
         RAY_STRUCT.declaration_chunk,
         RAY_HIT_INFO.declaration_chunk,
-        BVH_NULL_NODE_DEFINITION,
-        chunk_aabb3_intersects_ray,
+        chunk_extract_byte,
+        chunk_first_bit_high,
+        chunk_ray_get_octant_inv4,
+        chunk_bvh8_node_intersect,
+        chunk_bvh8_ray_direction_rcp,
         chunk_ray_triangle_compute_intersection_barycentric,
-        chunk_geometry_read_triangle_vertices,
+        chunk_geometry_read_triangle_positions,
     ]
-);
+);

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

@@ -1,5 +1,17 @@
 /**
- * NOTE: occlusion query is single-sided, back sides of triangles are ignored
+ * Whether anything of one geometry lies along a ray, through its tree.
+ *
+ * Single-sided: back sides of triangles are ignored.
+ *
+ * A node's triangles are `base_index_triangle` plus an offset, and the sum is handed to
+ * `geometry_read_triangle_positions` as it stands — so the tree must address triangles as
+ * `(meshlet << 8) | triangle`, which is what {@link bvh8_build_for_meshlets} produces.
+ *
+ * `stack` is the caller's, used from `stack_top` up and handed back as it was found. A group of
+ * sibling nodes waits on it only while the walk is below one of its members, so the walk needs one
+ * entry per level of the tree.
+ *
+ * @see https://github.com/jan-van-bergen/GPU-Raytracer/blob/6559ae2241c8fdea0ddaec959fe1a47ec9b3ab0d/Src/CUDA/Raytracing/BVH8.h#L277
  * @type {CodeChunk}
  */
 export const chunk_ray_query_blas_occluded: CodeChunk;

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

@@ -1 +1 @@
-{"version":3,"file":"chunk_ray_query_blas_occluded.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/geometry/ray/chunk_ray_query_blas_occluded.js"],"names":[],"mappings":"AAQA;;;GAGG;AACH,4CAFU,SAAS,CAuEjB;0BAjFwB,gCAAgC"}
+{"version":3,"file":"chunk_ray_query_blas_occluded.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/geometry/ray/chunk_ray_query_blas_occluded.js"],"names":[],"mappings":"AAiBA;;;;;;;;;;;;;;;GAeG;AACH,4CAFU,SAAS,CA0GjB;0BAzIwB,gCAAgC"}

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

@@ -1,82 +1,138 @@
 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_geometry_read_triangle_positions } from "../format/chunk_geometry_read_triangle_positions.js";
-import { chunk_ray_triangle_intersection_barycentric } from "./chunk_ray_triangle_intersection_barycentric.js";
+import { chunk_extract_byte } from "../../binary/chunk_extract_byte.js";
+import { chunk_first_bit_high } from "../../binary/chunk_first_bit_high.js";
+import {
+    chunk_geometry_read_triangle_positions
+} from "../format/chunk_geometry_read_triangle_positions.js";
+import { chunk_ray_intersects_sphere } from "./chunk_ray_intersects_sphere.js";
+import {
+    chunk_ray_triangle_intersection_barycentric
+} from "./chunk_ray_triangle_intersection_barycentric.js";
 import { RAY_STRUCT } from "./RAY_STRUCT.js";
+import { BVH8_INODE_STRUCT } from "../../bvh/bvh8/webgpu/BVH8_INODE_STRUCT.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_ray_get_octant_inv4 } from "../../bvh/bvh8/webgpu/chunk_ray_get_octant_inv4.js";
 
 /**
- * NOTE: occlusion query is single-sided, back sides of triangles are ignored
+ * Whether anything of one geometry lies along a ray, through its tree.
+ *
+ * Single-sided: back sides of triangles are ignored.
+ *
+ * A node's triangles are `base_index_triangle` plus an offset, and the sum is handed to
+ * `geometry_read_triangle_positions` as it stands — so the tree must address triangles as
+ * `(meshlet << 8) | triangle`, which is what {@link bvh8_build_for_meshlets} produces.
+ *
+ * `stack` is the caller's, used from `stack_top` up and handed back as it was found. A group of
+ * sibling nodes waits on it only while the walk is below one of its members, so the walk needs one
+ * entry per level of the tree.
+ *
+ * @see https://github.com/jan-van-bergen/GPU-Raytracer/blob/6559ae2241c8fdea0ddaec959fe1a47ec9b3ab0d/Src/CUDA/Raytracing/BVH8.h#L277
  * @type {CodeChunk}
  */
 export const chunk_ray_query_blas_occluded = CodeChunk.from(
     //language=WGSL
     `
 fn ray_query_blas_occluded(
-    ray: ${RAY_STRUCT.wgsl_ref}, 
-    geometry_index: u32, 
-    stack: ptr<function, array<u32,${BVH_TRAVERSAL_STACK_SIZE}>>, 
-    stack_top: u32
+    ray: ${RAY_STRUCT.wgsl_ref},
+    geometry_index: u32,
+    stack: ptr<function, array<vec2u, ${BVH8_TRAVERSAL_STACK_SIZE}>>,
+    stack_top: u32,
 ) -> bool {
-        
-    let blas_address = blas_lookup[geometry_index];
+
     let geometry = geometries[geometry_index];
-             
-    var pointer = stack_top + 1;
-       
-    var node_index = 0u;
-    
-    for(;pointer > stack_top && pointer <= ${BVH_TRAVERSAL_STACK_SIZE};){
-    
-        let node = blas_data[ blas_address + node_index ];
-        
-        if(!aabb3_intersects_ray( node.bounds, ray.origin, 1.0 / ray.direction, ray.tmax)){
-            
-            pointer --;
-            node_index = stack[pointer];
-            
-            continue;
-        
+
+    let bounding_sphere = geometry.bounding_sphere;
+
+    if (!ray_intersects_sphere(ray, bounding_sphere.xyz, bounding_sphere.w)) {
+        // typically this lets us get misses much quicker
+        return false;
+    }
+
+    let blas_address = blas_lookup[geometry_index];
+
+    var pointer = stack_top;
+
+    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){
-            // not a leaf node
-            
-            node_index = child_1;
-            
-            stack[ pointer ] = child_2;
-            
-            pointer ++;
-            
-        }else{
-            
-            pointer --;
-            node_index = stack[pointer];
-             
-            var v0:vec3f;                                   
-            var v1:vec3f;                                   
-            var v2:vec3f;
-                                               
-            geometry_read_triangle_positions(&v0, &v1, &v2, geometry, child_2);
-                        
-            if( ray_triangle_intersection_barycentric(ray, v0, v1, v2) ){
-                // got a hit
+
+        // 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_INODE_STRUCT.wgsl_ref} = blas_data[blas_address + 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) | extract_byte(node.data[0].w, 3u);
+
+        let triangle_base = node.data[1].y;
+
+        // one bit per triangle whose slot the ray reaches
+        var triangle_hits = hitmask & 0x00ffffffu;
+
+        while (triangle_hits != 0u) {
+            let triangle_offset = first_bit_high(triangle_hits);
+
+            triangle_hits &= ~(1u << triangle_offset);
+
+            var v0: vec3f;
+            var v1: vec3f;
+            var v2: vec3f;
+
+            geometry_read_triangle_positions(&v0, &v1, &v2, geometry, triangle_base + triangle_offset);
+
+            if (ray_triangle_intersection_barycentric(ray, v0, v1, v2)) {
                 return true;
             }
         }
+
+        if ((current_group.y & 0xff000000u) == 0u) {
+            if (pointer == stack_top) {
+                break;
+            }
+
+            pointer--;
+            current_group = stack[pointer];
+        }
     }
-    
+
     return false;
-}`,
-    [
-        BVH_NULL_NODE_DEFINITION,
+}
+    `, [
+        BVH8_INODE_STRUCT.declaration_chunk,
         RAY_STRUCT.declaration_chunk,
-        chunk_aabb3_intersects_ray,
-        chunk_geometry_read_triangle_positions,
+        chunk_extract_byte,
+        chunk_first_bit_high,
+        chunk_ray_get_octant_inv4,
+        chunk_bvh8_node_intersect,
+        chunk_bvh8_ray_direction_rcp,
         chunk_ray_triangle_intersection_barycentric,
+        chunk_ray_intersects_sphere,
+        chunk_geometry_read_triangle_positions,
     ]
-);
+);

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

@@ -1,3 +1,24 @@
+/**
+ * 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;
 import { CodeChunk } from "../../../compiler/CodeChunk.js";
 //# sourceMappingURL=chunk_ray_query_nearest.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"chunk_ray_query_nearest.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/geometry/ray/chunk_ray_query_nearest.js"],"names":[],"mappings":"AAYA,gDAqGE;0BAhHwB,gCAAgC"}
+{"version":3,"file":"chunk_ray_query_nearest.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/geometry/ray/chunk_ray_query_nearest.js"],"names":[],"mappings":"AAcA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,sCAFU,SAAS,CAuHjB;0BAvJwB,gCAAgC"}