@woosh/meep-engine 3.68.0 → 3.70.0

package/src/shade/renderer/scene/verify_gpu_tlas_build.js

@@ -3,12 +3,10 @@ import { BufferResourceDescriptor } from "../../device/graph/BufferResourceDescr
 import { ShadeGPUCommandContext } from "../../device/ShadeGPUCommandContext.js";
 import { GPUDatabase } from "../buffer/table/GPUDatabase.js";
 import { graph_inspect_gpu_buffer } from "../buffer/graph_inspect_gpu_buffer.js";
-import { bvh_buffer_size } from "../gpu_primitive/bvh/BVH_BUFFER_LAYOUT.js";
-import {
-    check_bvh_structure,
-    format_depth_histogram,
-    TRAVERSAL_STACK_SIZE
-} from "../gpu_primitive/bvh/check_bvh_structure.js";
+import { format_depth_histogram } from "../gpu_primitive/bvh/check_bvh_structure.js";
+import { bvh8_tree_buffer_size } from "../gpu_primitive/bvh8/BVH8_TREE_BUFFER_LAYOUT.js";
+import { check_bvh8_tree } from "../gpu_primitive/bvh8/check_bvh8_tree.js";
+import { BVH8_TLAS_MAX_DEPTH } from "../shader/chunk/bvh/bvh8/webgpu/BVH8_MAX_DEPTH.js";
 import { u32 } from "../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
 import { WebGPUArray } from "../shader/type/WebGPUArray.js";
 import { GPUInstancesAccelerationStructure } from "./GPUInstancesAccelerationStructure.js";
@@ -17,9 +15,9 @@ import { SCENE_DATABASE_SPEC } from "./SCENE_DATABASE_SPEC.js";
 /**
  * The whole TLAS path, on a device, against a real scene database.
  *
- * `verify_gpu_bvh_build` hands the primitive builder leaf boxes and a scene-bounds cell it computed
- * on the host, which is the right way to test the builder in isolation — and leaves exactly two
- * things with no on-device coverage anywhere: `shader_bvh_extract_instance_leaves`, which is where
+ * `verify_gpu_bvh_build` and `verify_gpu_bvh8_encode` hand the binary builder leaf boxes and a
+ * scene-bounds cell computed on the host, which is the right way to test the builder and the encode
+ * in isolation — and leaves exactly two things with no on-device coverage anywhere: `shader_bvh_extract_instance_leaves`, which is where
  * world AABBs are actually read from the `meshes` table and where the scene bounds are reduced,
  * and the +/-inf seeding of that cell, which a pool-cleared (zeroed) buffer would silently break by
  * anchoring every Morton code to the origin. This covers both, by driving
@@ -101,50 +99,22 @@ function make_boxes(count, seed, spread) {
  * @param {GPUInstancesAccelerationStructure} tlas
  * @param {string} label
  * @param {number[]} expected_rows the `meshes` rows that should be the tree's leaves
- * @param {number[][]} boxes_by_row world AABB per row, for the containment check on the root
+ * @param {number[][]} boxes_by_row world AABB per row, as it was written to the table
  * @returns {Promise<boolean>} whether the tree checked out
  */
 function inspect_tree(graphics, tlas, label, expected_rows, boxes_by_row) {
     const leaf_count = expected_rows.length;
 
-    if (leaf_count === 0) {
-        // nothing to traverse: the format's empty tree is the root word alone
-        return read_words(graphics, tlas.buffer, 1).then(words => {
-            const empty = words[0] === 0xffffffff;
-
-            report(label, empty ? [] : [`empty TLAS root word is ${words[0]}, expected BVH_NULL_NODE`], [], '', 0);
-
-            return empty;
-        });
-    }
-
-    const word_count = bvh_buffer_size(leaf_count) / Uint32Array.BYTES_PER_ELEMENT;
+    const word_count = bvh8_tree_buffer_size(leaf_count) / Uint32Array.BYTES_PER_ELEMENT;
 
     return read_words(graphics, tlas.buffer, word_count).then(tree => {
-        const result = check_bvh_structure(tree, leaf_count, expected_rows);
-
-        // The root has to hold every instance's world box — which is the end-to-end statement that
-        // the extraction pass read the right rows out of the `meshes` table.
-        if (result.problems.length === 0) {
-            const root_bounds = result.floats.subarray(1, 7);
-
-            for (const row of expected_rows) {
-                const box = boxes_by_row[row];
-
-                for (let axis = 0; axis < 3; axis++) {
-                    if (box[axis] < root_bounds[axis] - 1e-3 || box[3 + axis] > root_bounds[3 + axis] + 1e-3) {
-                        result.problems.push(
-                            `root does not contain row ${row} on axis ${axis}: `
-                            + `[${root_bounds[axis]}, ${root_bounds[3 + axis]}] vs [${box[axis]}, ${box[3 + axis]}]`
-                        );
-                        break;
-                    }
-                }
-
-                if (result.problems.length > 0) {
-                    break;
-                }
-            }
+        // Every slot has to hold the world boxes of the rows under it, and the header the box of them
+        // all — which is the end-to-end statement that the extraction pass read the right rows out of
+        // the `meshes` table. The table holds single-precision boxes.
+        const result = check_bvh8_tree(tree, leaf_count, expected_rows, row => boxes_by_row[row].map(Math.fround));
+
+        if (result.max_depth > BVH8_TLAS_MAX_DEPTH) {
+            result.warnings.push(`the tree is ${result.max_depth} levels deep, more than a walk's stack holds`);
         }
 
         report(
@@ -167,7 +137,7 @@ function inspect_tree(graphics, tlas, label, expected_rows, boxes_by_row) {
  * @param {number} max_depth
  */
 function report(label, problems, warnings, depth_summary, max_depth) {
-    const headline = `${label} — max depth ${max_depth}/${TRAVERSAL_STACK_SIZE}`;
+    const headline = `${label} — depth ${max_depth}/${BVH8_TLAS_MAX_DEPTH}`;
 
     if (problems.length === 0) {
         console.log(`%c[TLAS] PASS ${headline}`, 'color: #0c0');
@@ -222,14 +192,14 @@ function read_words(graphics, buffer, word_count) {
  * End-to-end verification of the GPU TLAS build against a real scene database.
  *
  * Builds a synthetic `meshes` table, drives the TLAS through the same calls `GPUSceneContext`
- * makes, reads the tree back and checks it: root word, every node reachable once, every mesh row
- * present exactly once as a leaf payload, every internal box containing its children, and the root
- * containing every instance's world AABB — which is the statement that the extraction pass read the
- * table correctly and the scene-bounds cell was seeded, not zeroed.
+ * makes, reads the tree back and checks it ({@link check_bvh8_tree}): the header, every node
+ * reachable once, every mesh row present exactly once as a leaf's payload, every slot holding the
+ * world AABBs of the instances under it, and the header's box the box of them all — which is the
+ * statement that the extraction pass read the table correctly and the scene-bounds cell was seeded,
+ * not zeroed.
  *
  * Then it exercises the three things only the integration has: a pure movement (rebuild, no rows
- * upload), a removal (a leaf really goes away), and an emptied TLAS (the host-written empty-tree
- * word).
+ * upload), a removal (a leaf really goes away), and an emptied TLAS (the host-written empty tree).
  *
  * @param {GraphicsContext} graphics
  * @returns {Promise<void>}

package/src/shade/renderer/shader/chunk/bvh/bvh8/webgpu/BVH8_INODE_STRUCT.d.ts

@@ -1,6 +1,8 @@
 /**
  * Intermediate node
- * Node is stored as 5 float4's so we can load the entire 80 bytes in 5 global memory accesses
+ * Node is stored as 5 uint4's so we can load the entire 80 bytes in 5 global memory accesses.
+ * Integers rather than floats: all but the first three words are packed bytes, and a packed word whose
+ * bits happen to spell a NaN is not a value WGSL promises to carry through a float unchanged.
  * @see https://github.com/jan-van-bergen/GPU-Raytracer/blob/6559ae2241c8fdea0ddaec959fe1a47ec9b3ab0d/Src/CUDA/Raytracing/BVH8.h#L19
  * @type {WebGPUStruct}
  */

package/src/shade/renderer/shader/chunk/bvh/bvh8/webgpu/BVH8_INODE_STRUCT.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BVH8_INODE_STRUCT.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/shade/renderer/shader/chunk/bvh/bvh8/webgpu/BVH8_INODE_STRUCT.js"],"names":[],"mappings":"AAIA;;;;;GAKG;AACH,gCAFU,YAAY,CAInB;6BAV0B,kCAAkC"}
+{"version":3,"file":"BVH8_INODE_STRUCT.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/shade/renderer/shader/chunk/bvh/bvh8/webgpu/BVH8_INODE_STRUCT.js"],"names":[],"mappings":"AAIA;;;;;;;GAOG;AACH,gCAFU,YAAY,CAInB;6BAZ0B,kCAAkC"}

package/src/shade/renderer/shader/chunk/bvh/bvh8/webgpu/BVH8_INODE_STRUCT.js

@@ -1,14 +1,16 @@
-import { vec4f } from "../../../../type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { vec4u } from "../../../../type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
 import { WebGPUArray } from "../../../../type/WebGPUArray.js";
 import { WebGPUStruct } from "../../../../type/WebGPUStruct.js";
 
 /**
  * Intermediate node
- * Node is stored as 5 float4's so we can load the entire 80 bytes in 5 global memory accesses
+ * Node is stored as 5 uint4's so we can load the entire 80 bytes in 5 global memory accesses.
+ * Integers rather than floats: all but the first three words are packed bytes, and a packed word whose
+ * bits happen to spell a NaN is not a value WGSL promises to carry through a float unchanged.
  * @see https://github.com/jan-van-bergen/GPU-Raytracer/blob/6559ae2241c8fdea0ddaec959fe1a47ec9b3ab0d/Src/CUDA/Raytracing/BVH8.h#L19
  * @type {WebGPUStruct}
  */
 export const BVH8_INODE_STRUCT = WebGPUStruct.from({
-    data: WebGPUArray.from(vec4f, 5),
+    data: WebGPUArray.from(vec4u, 5),
 });
 

package/src/shade/renderer/shader/chunk/bvh/bvh8/webgpu/BVH8_MAX_DEPTH.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Levels of nodes a BVH8 over a geometry may have, root included.
+ *
+ * A traversal keeps one stack entry per level it is below, so this is what the stack is sized by; a
+ * tree deeper than this is refused where it is built ({@link bvh8_build_for_meshlets}) rather than
+ * walked short. Trees over ordinary meshes gain about a level per eightfold in triangles and are 11
+ * deep at a million; a pile of identical triangles, which no split can separate, was 14 deep at
+ * twenty thousand.
+ *
+ * @type {number}
+ */
+export const BVH8_BLAS_MAX_DEPTH: number;
+/**
+ * Levels of nodes the BVH8 over a scene's instances may have.
+ *
+ * It is encoded three binary levels to a node from a Karras tree, whose depth is at most the 30 bits
+ * of a Morton code plus the bits that tell identical codes apart: 16 holds 2^18 instances at one
+ * centroid.
+ *
+ * @type {number}
+ */
+export const BVH8_TLAS_MAX_DEPTH: number;
+/**
+ * Entries in the stack one query walks both trees with.
+ * @type {number}
+ */
+export const BVH8_TRAVERSAL_STACK_SIZE: number;
+//# sourceMappingURL=BVH8_MAX_DEPTH.d.ts.map

package/src/shade/renderer/shader/chunk/bvh/bvh8/webgpu/BVH8_MAX_DEPTH.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BVH8_MAX_DEPTH.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/shade/renderer/shader/chunk/bvh/bvh8/webgpu/BVH8_MAX_DEPTH.js"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,kCAFU,MAAM,CAEsB;AAEtC;;;;;;;;GAQG;AACH,kCAFU,MAAM,CAEsB;AAEtC;;;GAGG;AACH,wCAFU,MAAM,CAEmE"}

package/src/shade/renderer/shader/chunk/bvh/bvh8/webgpu/BVH8_MAX_DEPTH.js

@@ -0,0 +1,29 @@
+/**
+ * Levels of nodes a BVH8 over a geometry may have, root included.
+ *
+ * A traversal keeps one stack entry per level it is below, so this is what the stack is sized by; a
+ * tree deeper than this is refused where it is built ({@link bvh8_build_for_meshlets}) rather than
+ * walked short. Trees over ordinary meshes gain about a level per eightfold in triangles and are 11
+ * deep at a million; a pile of identical triangles, which no split can separate, was 14 deep at
+ * twenty thousand.
+ *
+ * @type {number}
+ */
+export const BVH8_BLAS_MAX_DEPTH = 16;
+
+/**
+ * Levels of nodes the BVH8 over a scene's instances may have.
+ *
+ * It is encoded three binary levels to a node from a Karras tree, whose depth is at most the 30 bits
+ * of a Morton code plus the bits that tell identical codes apart: 16 holds 2^18 instances at one
+ * centroid.
+ *
+ * @type {number}
+ */
+export const BVH8_TLAS_MAX_DEPTH = 16;
+
+/**
+ * Entries in the stack one query walks both trees with.
+ * @type {number}
+ */
+export const BVH8_TRAVERSAL_STACK_SIZE = BVH8_TLAS_MAX_DEPTH + BVH8_BLAS_MAX_DEPTH;

package/src/shade/renderer/shader/chunk/bvh/bvh8/webgpu/chunk_bvh8_node_grid.d.ts

@@ -0,0 +1,25 @@
+/**
+ * The grid a BVH8 node holds its slots' boxes on, and a box's corners in bytes on it:
+ *
+ * ```wgsl
+ * struct BVH8NodeGrid { origin: vec3<f32>, exponent: vec3<u32>, per_cell: vec3<f32> }
+ *
+ * fn bvh8_node_grid(low: vec3<f32>, high: vec3<f32>) -> BVH8NodeGrid
+ * fn bvh8_node_grid_low(grid: BVH8NodeGrid, low: vec3<f32>) -> vec3<u32>
+ * fn bvh8_node_grid_high(grid: BVH8NodeGrid, high: vec3<f32>) -> vec3<u32>
+ * ```
+ *
+ * The grid of a node is its own box's: the origin at the low corner, and on each axis the smallest
+ * power-of-two step that spans the box in 255. `exponent` is that step's exponent byte, the one a
+ * node stores; zero is a step of nothing, for an axis with no extent, and takes every byte to zero.
+ * A low corner is rounded down to the grid and a high one up, so a slot's box comes out holding the
+ * box it was given whenever that box lies inside the node's.
+ *
+ * Every step is a single-precision one, in a fixed order: the arithmetic of `bvh8_node_fit_slots`,
+ * which gives the same words from the same boxes.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_bvh8_node_grid: CodeChunk;
+import { CodeChunk } from "../../../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_bvh8_node_grid.d.ts.map

package/src/shade/renderer/shader/chunk/bvh/bvh8/webgpu/chunk_bvh8_node_grid.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_bvh8_node_grid.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/shade/renderer/shader/chunk/bvh/bvh8/webgpu/chunk_bvh8_node_grid.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,mCAFU,SAAS,CA0EhB;0BAhGuB,mCAAmC"}

package/src/shade/renderer/shader/chunk/bvh/bvh8/webgpu/chunk_bvh8_node_grid.js

@@ -0,0 +1,97 @@
+import { CodeChunk } from "../../../../compiler/CodeChunk.js";
+
+/**
+ * The grid a BVH8 node holds its slots' boxes on, and a box's corners in bytes on it:
+ *
+ * ```wgsl
+ * struct BVH8NodeGrid { origin: vec3<f32>, exponent: vec3<u32>, per_cell: vec3<f32> }
+ *
+ * fn bvh8_node_grid(low: vec3<f32>, high: vec3<f32>) -> BVH8NodeGrid
+ * fn bvh8_node_grid_low(grid: BVH8NodeGrid, low: vec3<f32>) -> vec3<u32>
+ * fn bvh8_node_grid_high(grid: BVH8NodeGrid, high: vec3<f32>) -> vec3<u32>
+ * ```
+ *
+ * The grid of a node is its own box's: the origin at the low corner, and on each axis the smallest
+ * power-of-two step that spans the box in 255. `exponent` is that step's exponent byte, the one a
+ * node stores; zero is a step of nothing, for an axis with no extent, and takes every byte to zero.
+ * A low corner is rounded down to the grid and a high one up, so a slot's box comes out holding the
+ * box it was given whenever that box lies inside the node's.
+ *
+ * Every step is a single-precision one, in a fixed order: the arithmetic of `bvh8_node_fit_slots`,
+ * which gives the same words from the same boxes.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_bvh8_node_grid = CodeChunk.from(
+    //language=WGSL
+    `
+struct BVH8NodeGrid {
+    // the node's low corner
+    origin: vec3<f32>,
+    // the exponent byte of each axis's step
+    exponent: vec3<u32>,
+    // steps to a unit of length; zero where the step is nothing
+    per_cell: vec3<f32>,
+}
+
+// The next float up from a difference that cannot be negative, and the next down: a difference of two
+// floats is rounded, and a box must not shrink by the rounding. Nothing is added to an exact zero.
+fn bvh8_grid_round_up(x: f32) -> f32 {
+    return select(x, bitcast<f32>(bitcast<u32>(x) + 1u), x > 0.0);
+}
+
+fn bvh8_grid_round_down(x: f32) -> f32 {
+    return select(x, bitcast<f32>(bitcast<u32>(x) - 1u), x > 0.0);
+}
+
+// The exponent byte of the smallest power of two that spans an extent in 255 steps; zero, a step of
+// nothing, for no extent at all.
+fn bvh8_grid_step_exponent(extent: f32) -> u32 {
+    if (!(extent > 0.0)) {
+        return 0u;
+    }
+
+    let bits = bitcast<u32>(extent * (1.0 / 255.0));
+
+    // the power of two at or below a 255th of the extent, and the next one up unless that one spans it
+    var exponent = (bits >> 23u) & 0xffu;
+
+    if (extent > 255.0 * bitcast<f32>(exponent << 23u)) {
+        exponent += 1u;
+    }
+
+    return exponent;
+}
+
+fn bvh8_node_grid(low: vec3<f32>, high: vec3<f32>) -> BVH8NodeGrid {
+    let exponent = vec3<u32>(
+        bvh8_grid_step_exponent(bvh8_grid_round_up(high.x - low.x)),
+        bvh8_grid_step_exponent(bvh8_grid_round_up(high.y - low.y)),
+        bvh8_grid_step_exponent(bvh8_grid_round_up(high.z - low.z)),
+    );
+
+    let cell = bitcast<vec3<f32>>(exponent << vec3<u32>(23u));
+
+    return BVH8NodeGrid(low, exponent, select(vec3<f32>(0.0), 1.0 / cell, cell > vec3<f32>(0.0)));
+}
+
+fn bvh8_node_grid_low(grid: BVH8NodeGrid, low: vec3<f32>) -> vec3<u32> {
+    let offset = low - grid.origin;
+
+    return vec3<u32>(floor(vec3<f32>(
+        bvh8_grid_round_down(offset.x),
+        bvh8_grid_round_down(offset.y),
+        bvh8_grid_round_down(offset.z),
+    ) * grid.per_cell));
+}
+
+fn bvh8_node_grid_high(grid: BVH8NodeGrid, high: vec3<f32>) -> vec3<u32> {
+    let offset = high - grid.origin;
+
+    return min(vec3<u32>(ceil(vec3<f32>(
+        bvh8_grid_round_up(offset.x),
+        bvh8_grid_round_up(offset.y),
+        bvh8_grid_round_up(offset.z),
+    ) * grid.per_cell)), vec3<u32>(255u));
+}
+`);

package/src/shade/renderer/shader/chunk/bvh/bvh8/webgpu/chunk_bvh8_node_intersect.d.ts

@@ -1,4 +1,12 @@
 /**
+ * Which of a node's eight slots a ray reaches, as the bits the traversal loop walks: an internal slot
+ * sets one bit among the top eight, placed by the ray's octant so that nearer slots rank higher, and a
+ * leaf slot sets one bit per triangle among the low twenty-four, at the triangle's offset in the node's
+ * run.
+ *
+ * `direction_rcp` is {@link chunk_bvh8_ray_direction_rcp} of the ray's direction, computed once per
+ * query: it must be finite, or a ray parallel to an axis meets no plane at a number.
+ *
  * @see https://github.com/jan-van-bergen/GPU-Raytracer/blob/6559ae2241c8fdea0ddaec959fe1a47ec9b3ab0d/Src/CUDA/Raytracing/BVH8.h#L29
  * @type {CodeChunk}
  */

package/src/shade/renderer/shader/chunk/bvh/bvh8/webgpu/chunk_bvh8_node_intersect.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_bvh8_node_intersect.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/shade/renderer/shader/chunk/bvh/bvh8/webgpu/chunk_bvh8_node_intersect.js"],"names":[],"mappings":"AAQA;;;GAGG;AACH,wCAFU,SAAS,CA8FjB;0BAxGwB,mCAAmC"}
+{"version":3,"file":"chunk_bvh8_node_intersect.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/shade/renderer/shader/chunk/bvh/bvh8/webgpu/chunk_bvh8_node_intersect.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;GAWG;AACH,wCAFU,SAAS,CA+FjB;0BAjHwB,mCAAmC"}

package/src/shade/renderer/shader/chunk/bvh/bvh8/webgpu/chunk_bvh8_node_intersect.js

@@ -7,6 +7,14 @@ import { BVH8_INODE_STRUCT } from "./BVH8_INODE_STRUCT.js";
 import { chunk_sign_extend_s8x4 } from "./chunk_sign_extend_s8x4.js";
 
 /**
+ * Which of a node's eight slots a ray reaches, as the bits the traversal loop walks: an internal slot
+ * sets one bit among the top eight, placed by the ray's octant so that nearer slots rank higher, and a
+ * leaf slot sets one bit per triangle among the low twenty-four, at the triangle's offset in the node's
+ * run.
+ *
+ * `direction_rcp` is {@link chunk_bvh8_ray_direction_rcp} of the ray's direction, computed once per
+ * query: it must be finite, or a ray parallel to an axis meets no plane at a number.
+ *
  * @see https://github.com/jan-van-bergen/GPU-Raytracer/blob/6559ae2241c8fdea0ddaec959fe1a47ec9b3ab0d/Src/CUDA/Raytracing/BVH8.h#L29
  * @type {CodeChunk}
  */
@@ -15,31 +23,32 @@ export const chunk_bvh8_node_intersect = CodeChunk.from(
     `
 fn bvh8_node_intersect(
     ray: ${RAY_STRUCT.wgsl_ref},
+    direction_rcp: vec3<f32>,
     oct_inv4: u32,
     node: ${BVH8_INODE_STRUCT.wgsl_ref},
 ) -> u32{
-    let p = node.data[0].xyz;
+    let p = bitcast<vec3<f32>>(node.data[0].xyz);
 
-	let e_imask = bitcast<u32>(node.data[0].w);
+	let e_imask = node.data[0].w;
 	let e_x = extract_byte(e_imask, 0);
 	let e_y = extract_byte(e_imask, 1);
 	let e_z = extract_byte(e_imask, 2);
 
-    // pre-compute adjusted ray attributes to save a couple of operations inside the later loop
+    // a child's plane at byte q is met at q * adjusted_ray_direction_inv + adjusted_ray_origin
 	let adjusted_ray_direction_inv = vec3<f32>(
 		bitcast<f32>(e_x << 23),
 		bitcast<f32>(e_y << 23),
-		bitcast<f32>(e_z << 23) 
-	) / ray.direction;
-	
-	let adjusted_ray_origin = (p - ray.origin) / ray.direction;
+		bitcast<f32>(e_z << 23)
+	) * direction_rcp;
+
+	let adjusted_ray_origin = (p - ray.origin) * direction_rcp;
 
 	var hit_mask = 0u;
 
     // traverse children, first by word (0..3), (4..7)
     // and then individually inside inner loop
 	for (var i = 0; i < 2; i++) {
-		let meta4 = bitcast<u32>(select( node.data[1].w, node.data[1].z, i == 0 ) );
+		let meta4 = select( node.data[1].w, node.data[1].z, i == 0 );
 
 		let is_inner4   = (meta4 & (meta4 << 1u)) & 0x10101010u;
 		let inner_mask4 = sign_extend_s8x4(is_inner4 << 3u);
@@ -47,14 +56,14 @@ fn bvh8_node_intersect(
 		let child_bits4 = (meta4 >> 5u) & 0x07070707u;
 
 		// Select near and far planes based on ray octant
-		let q_lo_x = bitcast<u32>(select( node.data[2].y, node.data[2].x, i == 0 ));
-		let q_hi_x = bitcast<u32>(select( node.data[2].w, node.data[2].z, i == 0 ));
+		let q_lo_x = select( node.data[2].y, node.data[2].x, i == 0 );
+		let q_hi_x = select( node.data[2].w, node.data[2].z, i == 0 );
 
-		let q_lo_y = bitcast<u32>(select( node.data[3].y, node.data[3].x, i == 0 ));
-		let q_hi_y = bitcast<u32>(select( node.data[3].w, node.data[3].z, i == 0 ));
+		let q_lo_y = select( node.data[3].y, node.data[3].x, i == 0 );
+		let q_hi_y = select( node.data[3].w, node.data[3].z, i == 0 );
 
-		let q_lo_z = bitcast<u32>(select( node.data[4].y, node.data[4].x, i == 0 ));
-		let q_hi_z = bitcast<u32>(select( node.data[4].w, node.data[4].z, i == 0 ));
+		let q_lo_z = select( node.data[4].y, node.data[4].x, i == 0 );
+		let q_hi_z = select( node.data[4].w, node.data[4].z, i == 0 );
 
 		let x_min = select(q_lo_x, q_hi_x, ray.direction.x < 0.0);
 		let x_max = select(q_hi_x, q_lo_x, ray.direction.x < 0.0);

package/src/shade/renderer/shader/chunk/bvh/bvh8/webgpu/chunk_bvh8_node_slot_distances.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Squared distance from a point to the box of each of a BVH8 node's eight slots, and what a walk that
+ * is not a ray's needs to know of a slot besides.
+ *
+ * A node stores one origin and one power-of-two step per axis, and each slot's box as bytes on that
+ * grid, four slots to a word. `bvh8_node_slot_distances_sqr` decodes a word at a time. The builder
+ * rounded each box's low corner down and its high corner up, so a distance here is never more than
+ * the distance to anything under the slot. An empty slot's distance means nothing: mask it with the
+ * node's internal mask, or with the slots' runs, both of which leave an empty slot out.
+ *
+ * `bvh8_node_slot_signed_distances` is the same for a walk that prunes by a signed field: the distance
+ * itself, not its square, and below zero inside a box, where it is how far the nearest face is. A
+ * slot's box holds everything under the slot, so nothing under it is nearer than that, by sign too.
+ *
+ * `bvh8_node_slots_meeting` is the question a box asks: a bit per slot whose box it meets, touching
+ * counted. An empty slot's bit means nothing there either.
+ *
+ * Every question a walk asks is answered for the eight slots at once, of either kind of distance:
+ *
+ * - `bvh8_slots_within` — a bit per slot whose box is nearer than a limit;
+ * - `bvh8_nearest_slot_among` — the nearest of the slots named by such bits;
+ * - `bvh8_node_slot_runs` and `bvh8_slot_runs_within` — the triangles held by the slots nearer than a
+ *   limit, a bit per triangle of the node's run, so that a walk weighs triangles one after another
+ *   with no slot in between;
+ * - `bvh8_slot_runs_of` — the same of the slots named by bits.
+ *
+ * A slot's meta byte is zero for an empty slot, has 24 and up in its low five bits for a child node,
+ * and otherwise names triangles: their offset in the node's run in the low five bits, their count in
+ * unary above. A node holds at most 24 triangles, so the bits of a run stay below 24 and those a child
+ * node's byte makes land above.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_bvh8_node_slot_distances: CodeChunk;
+import { CodeChunk } from "../../../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_bvh8_node_slot_distances.d.ts.map

package/src/shade/renderer/shader/chunk/bvh/bvh8/webgpu/chunk_bvh8_node_slot_distances.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_bvh8_node_slot_distances.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/shade/renderer/shader/chunk/bvh/bvh8/webgpu/chunk_bvh8_node_slot_distances.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,6CAFU,SAAS,CA0LjB;0BA7NwB,mCAAmC"}