@woosh/meep-engine 3.69.0 → 3.70.0

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

@@ -0,0 +1,222 @@
+import { CodeChunk } from "../../../../compiler/CodeChunk.js";
+import { chunk_extract_byte } from "../../../binary/chunk_extract_byte.js";
+import { BVH8_INODE_STRUCT } from "./BVH8_INODE_STRUCT.js";
+
+/**
+ * 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.from(
+    //language=WGSL
+    `
+// a distance to slots 0..3 and to slots 4..7: squared, or signed, as the function that made it says
+struct BVH8SlotDistances {
+    first: vec4<f32>,
+    second: vec4<f32>,
+}
+
+// each slot's triangles as bits of the node's run, slots 0..3 and slots 4..7;
+// a child node's bits are at 24 and up, an empty slot has none
+struct BVH8SlotRuns {
+    first: vec4<u32>,
+    second: vec4<u32>,
+}
+
+fn bvh8_word_bytes(word: u32) -> vec4<f32> {
+    return vec4<f32>((vec4<u32>(word) >> vec4<u32>(0u, 8u, 16u, 24u)) & vec4<u32>(0xffu));
+}
+
+// how far a coordinate lies beyond four slots' extents along one axis: above zero outside them, and
+// within them below zero by the distance to the nearer end;
+// 'along' is the coordinate measured from the node's origin, 'cell' the grid's step on the axis
+fn bvh8_axis_beyond(low_word: u32, high_word: u32, cell: f32, along: f32) -> vec4<f32> {
+    return max(bvh8_word_bytes(low_word) * cell - along, along - bvh8_word_bytes(high_word) * cell);
+}
+
+// how far a coordinate lies outside four slots' extents along one axis, zero within them
+fn bvh8_axis_outside(low_word: u32, high_word: u32, cell: f32, along: f32) -> vec4<f32> {
+    return max(bvh8_axis_beyond(low_word, high_word, cell, along), vec4<f32>(0.0));
+}
+
+// the signed distance to four boxes, from how far the point lies beyond each along the three axes
+fn bvh8_signed_from_beyond(x: vec4<f32>, y: vec4<f32>, z: vec4<f32>) -> vec4<f32> {
+    let zero = vec4<f32>(0.0);
+
+    let outside_x = max(x, zero);
+    let outside_y = max(y, zero);
+    let outside_z = max(z, zero);
+
+    return sqrt(outside_x * outside_x + outside_y * outside_y + outside_z * outside_z) + min(max(x, max(y, z)), zero);
+}
+
+fn bvh8_node_slot_distances_sqr(node: ${BVH8_INODE_STRUCT.wgsl_ref}, position: vec3<f32>) -> BVH8SlotDistances {
+    let exponents = node.data[0].w;
+
+    let cell = vec3<f32>(
+        bitcast<f32>(extract_byte(exponents, 0u) << 23u),
+        bitcast<f32>(extract_byte(exponents, 1u) << 23u),
+        bitcast<f32>(extract_byte(exponents, 2u) << 23u),
+    );
+
+    let along = position - bitcast<vec3<f32>>(node.data[0].xyz);
+
+    let x_first = bvh8_axis_outside(node.data[2].x, node.data[2].z, cell.x, along.x);
+    let y_first = bvh8_axis_outside(node.data[3].x, node.data[3].z, cell.y, along.y);
+    let z_first = bvh8_axis_outside(node.data[4].x, node.data[4].z, cell.z, along.z);
+
+    let x_second = bvh8_axis_outside(node.data[2].y, node.data[2].w, cell.x, along.x);
+    let y_second = bvh8_axis_outside(node.data[3].y, node.data[3].w, cell.y, along.y);
+    let z_second = bvh8_axis_outside(node.data[4].y, node.data[4].w, cell.z, along.z);
+
+    return BVH8SlotDistances(
+        x_first * x_first + y_first * y_first + z_first * z_first,
+        x_second * x_second + y_second * y_second + z_second * z_second,
+    );
+}
+
+fn bvh8_node_slot_signed_distances(node: ${BVH8_INODE_STRUCT.wgsl_ref}, position: vec3<f32>) -> BVH8SlotDistances {
+    let exponents = node.data[0].w;
+
+    let cell = vec3<f32>(
+        bitcast<f32>(extract_byte(exponents, 0u) << 23u),
+        bitcast<f32>(extract_byte(exponents, 1u) << 23u),
+        bitcast<f32>(extract_byte(exponents, 2u) << 23u),
+    );
+
+    let along = position - bitcast<vec3<f32>>(node.data[0].xyz);
+
+    return BVH8SlotDistances(
+        bvh8_signed_from_beyond(
+            bvh8_axis_beyond(node.data[2].x, node.data[2].z, cell.x, along.x),
+            bvh8_axis_beyond(node.data[3].x, node.data[3].z, cell.y, along.y),
+            bvh8_axis_beyond(node.data[4].x, node.data[4].z, cell.z, along.z),
+        ),
+        bvh8_signed_from_beyond(
+            bvh8_axis_beyond(node.data[2].y, node.data[2].w, cell.x, along.x),
+            bvh8_axis_beyond(node.data[3].y, node.data[3].w, cell.y, along.y),
+            bvh8_axis_beyond(node.data[4].y, node.data[4].w, cell.z, along.z),
+        ),
+    );
+}
+
+// a bit per slot whose box meets the box from 'low' to 'high', touching counted
+fn bvh8_node_slots_meeting(node: ${BVH8_INODE_STRUCT.wgsl_ref}, low: vec3<f32>, high: vec3<f32>) -> u32 {
+    let exponents = node.data[0].w;
+
+    let cell = vec3<f32>(
+        bitcast<f32>(extract_byte(exponents, 0u) << 23u),
+        bitcast<f32>(extract_byte(exponents, 1u) << 23u),
+        bitcast<f32>(extract_byte(exponents, 2u) << 23u),
+    );
+
+    let origin = bitcast<vec3<f32>>(node.data[0].xyz);
+
+    // the box, measured from the node's origin as its slots' are
+    let box_low = low - origin;
+    let box_high = high - origin;
+
+    let first = (bvh8_word_bytes(node.data[2].x) * cell.x <= vec4<f32>(box_high.x)) & (bvh8_word_bytes(node.data[2].z) * cell.x >= vec4<f32>(box_low.x))
+        & (bvh8_word_bytes(node.data[3].x) * cell.y <= vec4<f32>(box_high.y)) & (bvh8_word_bytes(node.data[3].z) * cell.y >= vec4<f32>(box_low.y))
+        & (bvh8_word_bytes(node.data[4].x) * cell.z <= vec4<f32>(box_high.z)) & (bvh8_word_bytes(node.data[4].z) * cell.z >= vec4<f32>(box_low.z));
+
+    let second = (bvh8_word_bytes(node.data[2].y) * cell.x <= vec4<f32>(box_high.x)) & (bvh8_word_bytes(node.data[2].w) * cell.x >= vec4<f32>(box_low.x))
+        & (bvh8_word_bytes(node.data[3].y) * cell.y <= vec4<f32>(box_high.y)) & (bvh8_word_bytes(node.data[3].w) * cell.y >= vec4<f32>(box_low.y))
+        & (bvh8_word_bytes(node.data[4].y) * cell.z <= vec4<f32>(box_high.z)) & (bvh8_word_bytes(node.data[4].w) * cell.z >= vec4<f32>(box_low.z));
+
+    let bits = select(vec4<u32>(0u), vec4<u32>(1u, 2u, 4u, 8u), first)
+        | select(vec4<u32>(0u), vec4<u32>(16u, 32u, 64u, 128u), second);
+
+    return bits.x | bits.y | bits.z | bits.w;
+}
+
+// a bit per slot whose box is nearer than the limit
+fn bvh8_slots_within(distances: BVH8SlotDistances, limit_sqr: f32) -> u32 {
+    let first = select(vec4<u32>(0u), vec4<u32>(1u, 2u, 4u, 8u), distances.first < vec4<f32>(limit_sqr));
+    let second = select(vec4<u32>(0u), vec4<u32>(16u, 32u, 64u, 128u), distances.second < vec4<f32>(limit_sqr));
+
+    let bits = first | second;
+
+    return bits.x | bits.y | bits.z | bits.w;
+}
+
+// the nearest of the slots named, the lowest of them when several are as near;
+// 'slots' must name one, and none whose distance is infinite
+fn bvh8_nearest_slot_among(distances: BVH8SlotDistances, slots: u32) -> u32 {
+    // a slot not named stands as far as a number goes, and is told from a named one that far by its bit
+    let far = vec4<f32>(3.4028234e38);
+
+    let first = select(far, distances.first, (vec4<u32>(slots) & vec4<u32>(1u, 2u, 4u, 8u)) != vec4<u32>(0u));
+    let second = select(far, distances.second, (vec4<u32>(slots) & vec4<u32>(16u, 32u, 64u, 128u)) != vec4<u32>(0u));
+
+    let least_of_pair = min(first, second);
+    let least = min(min(least_of_pair.x, least_of_pair.y), min(least_of_pair.z, least_of_pair.w));
+
+    let first_bits = select(vec4<u32>(0u), vec4<u32>(1u, 2u, 4u, 8u), first == vec4<f32>(least));
+    let second_bits = select(vec4<u32>(0u), vec4<u32>(16u, 32u, 64u, 128u), second == vec4<f32>(least));
+
+    let bits = first_bits | second_bits;
+
+    return countTrailingZeros((bits.x | bits.y | bits.z | bits.w) & slots);
+}
+
+fn bvh8_node_slot_runs(node: ${BVH8_INODE_STRUCT.wgsl_ref}) -> BVH8SlotRuns {
+    let shifts = vec4<u32>(0u, 8u, 16u, 24u);
+
+    let meta_first = (vec4<u32>(node.data[1].z) >> shifts) & vec4<u32>(0xffu);
+    let meta_second = (vec4<u32>(node.data[1].w) >> shifts) & vec4<u32>(0xffu);
+
+    return BVH8SlotRuns(
+        (meta_first >> vec4<u32>(5u)) << (meta_first & vec4<u32>(31u)),
+        (meta_second >> vec4<u32>(5u)) << (meta_second & vec4<u32>(31u)),
+    );
+}
+
+// the triangles of the slots named, a bit per triangle of the node's run
+fn bvh8_slot_runs_of(runs: BVH8SlotRuns, slots: u32) -> u32 {
+    let bits = select(vec4<u32>(0u), runs.first, (vec4<u32>(slots) & vec4<u32>(1u, 2u, 4u, 8u)) != vec4<u32>(0u))
+        | select(vec4<u32>(0u), runs.second, (vec4<u32>(slots) & vec4<u32>(16u, 32u, 64u, 128u)) != vec4<u32>(0u));
+
+    return (bits.x | bits.y | bits.z | bits.w) & 0xffffffu;
+}
+
+// the triangles of the slots whose boxes are nearer than the limit, a bit per triangle of the node's run
+fn bvh8_slot_runs_within(runs: BVH8SlotRuns, distances: BVH8SlotDistances, limit_sqr: f32) -> u32 {
+    let bits = select(vec4<u32>(0u), runs.first, distances.first < vec4<f32>(limit_sqr))
+        | select(vec4<u32>(0u), runs.second, distances.second < vec4<f32>(limit_sqr));
+
+    return (bits.x | bits.y | bits.z | bits.w) & 0xffffffu;
+}
+    `, [
+        BVH8_INODE_STRUCT.declaration_chunk,
+        chunk_extract_byte,
+    ]
+);

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

@@ -0,0 +1,20 @@
+/**
+ * Reciprocal of a ray's direction for {@link chunk_bvh8_node_intersect}, finite on every axis.
+ *
+ * The node test places a child's planes as `q * (e / d) + (p - o) / d`. With a component of `d` at
+ * zero both terms are infinite, their sum is a NaN, and what `min` and `max` make of a NaN is up to the
+ * device: one drops it and reaches every node whose other two slabs the ray crosses, another keeps it
+ * and misses the node the ray is inside of. So a component is never let closer to zero than 2^-80, and
+ * keeps its sign — `-0.0` counts as positive, which is how {@link chunk_ray_get_octant_inv4} and the
+ * node test's own near/far selection read it.
+ *
+ * 2^-80 is from the reference implementation. Its reciprocal times a distance stays finite for
+ * distances up to 2^47, and a ray would have to travel 2^56 units for a component that small to move it
+ * by one part in 2^24 of a unit.
+ *
+ * @see https://github.com/jan-van-bergen/GPU-Raytracer/blob/6559ae2241c8fdea0ddaec959fe1a47ec9b3ab0d/Src/CUDA/Raytracing/BVH8.h#L29
+ * @type {CodeChunk}
+ */
+export const chunk_bvh8_ray_direction_rcp: CodeChunk;
+import { CodeChunk } from "../../../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_bvh8_ray_direction_rcp.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_bvh8_ray_direction_rcp.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/shade/renderer/shader/chunk/bvh/bvh8/webgpu/chunk_bvh8_ray_direction_rcp.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;GAgBG;AACH,2CAFU,SAAS,CAYjB;0BA7BwB,mCAAmC"}

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

@@ -0,0 +1,30 @@
+import { CodeChunk } from "../../../../compiler/CodeChunk.js";
+
+/**
+ * Reciprocal of a ray's direction for {@link chunk_bvh8_node_intersect}, finite on every axis.
+ *
+ * The node test places a child's planes as `q * (e / d) + (p - o) / d`. With a component of `d` at
+ * zero both terms are infinite, their sum is a NaN, and what `min` and `max` make of a NaN is up to the
+ * device: one drops it and reaches every node whose other two slabs the ray crosses, another keeps it
+ * and misses the node the ray is inside of. So a component is never let closer to zero than 2^-80, and
+ * keeps its sign — `-0.0` counts as positive, which is how {@link chunk_ray_get_octant_inv4} and the
+ * node test's own near/far selection read it.
+ *
+ * 2^-80 is from the reference implementation. Its reciprocal times a distance stays finite for
+ * distances up to 2^47, and a ray would have to travel 2^56 units for a component that small to move it
+ * by one part in 2^24 of a unit.
+ *
+ * @see https://github.com/jan-van-bergen/GPU-Raytracer/blob/6559ae2241c8fdea0ddaec959fe1a47ec9b3ab0d/Src/CUDA/Raytracing/BVH8.h#L29
+ * @type {CodeChunk}
+ */
+export const chunk_bvh8_ray_direction_rcp = CodeChunk.from(
+    //language=WGSL
+    `
+fn bvh8_ray_direction_rcp(direction: vec3<f32>) -> vec3<f32> {
+    // 2^-80
+    let least = vec3<f32>(8.271806e-25);
+
+    return 1.0 / select(max(direction, least), min(direction, -least), direction < vec3<f32>(0.0));
+}
+    `
+);

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

@@ -0,0 +1,30 @@
+/**
+ * What a BVH8 that owns its buffer is bound as: the layout of {@link BVH8_TREE_BUFFER_LAYOUT}, every
+ * part of which is a whole number of `vec4<u32>`.
+ *
+ * @type {WebGPUArray}
+ */
+export const BVH8_TREE_TYPE: WebGPUArray;
+/**
+ * Reads of a BVH8 that owns its buffer ({@link BVH8_TREE_BUFFER_LAYOUT}), bound as
+ * {@link BVH8_TREE_TYPE}:
+ *
+ * ```wgsl
+ * fn bvh8_tree_read_node(tree, index: u32) -> BVH8Node
+ * fn bvh8_tree_read_payload(tree, node: BVH8Node, offset: u32) -> u32
+ * fn bvh8_tree_leaf_count(tree) -> u32
+ * fn bvh8_tree_bounds_low(tree) -> vec3<f32>
+ * fn bvh8_tree_bounds_high(tree) -> vec3<f32>
+ * ```
+ *
+ * A node's leaf slots each hold one leaf, and a walk has them as bits of the node's run, as it has a
+ * mesh's triangles: `bvh8_tree_read_payload` gives the payload of the leaf at an offset in that run.
+ *
+ * The root is node 0, and a tree of no leaves has one: a walk starts there without asking.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_bvh8_tree_read: CodeChunk;
+import { WebGPUArray } from "../../../../type/WebGPUArray.js";
+import { CodeChunk } from "../../../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_bvh8_tree_read.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_bvh8_tree_read.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/shade/renderer/shader/chunk/bvh/bvh8/webgpu/chunk_bvh8_tree_read.js"],"names":[],"mappings":"AAcA;;;;;GAKG;AACH,6BAFU,WAAW,CAEiC;AAgBtD;;;;;;;;;;;;;;;;;;GAkBG;AACH,mCAFU,SAAS,CAqCjB;4BA/E0B,iCAAiC;0BAFnC,mCAAmC"}

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

@@ -0,0 +1,91 @@
+import { assert } from "../../../../../../../core/assert.js";
+import {
+    BVH8_TREE_BOUNDS_HIGH_WORD,
+    BVH8_TREE_BOUNDS_LOW_WORD,
+    BVH8_TREE_HEADER_WORDS,
+    BVH8_TREE_LEAF_COUNT_WORD,
+    BVH8_TREE_NODE_STRIDE_WORDS,
+    BVH8_TREE_ORDER_OFFSET_WORD
+} from "../../../../../gpu_primitive/bvh8/BVH8_TREE_BUFFER_LAYOUT.js";
+import { CodeChunk } from "../../../../compiler/CodeChunk.js";
+import { vec4u } from "../../../../type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../../../../type/WebGPUArray.js";
+import { BVH8_INODE_STRUCT } from "./BVH8_INODE_STRUCT.js";
+
+/**
+ * What a BVH8 that owns its buffer is bound as: the layout of {@link BVH8_TREE_BUFFER_LAYOUT}, every
+ * part of which is a whole number of `vec4<u32>`.
+ *
+ * @type {WebGPUArray}
+ */
+export const BVH8_TREE_TYPE = WebGPUArray.from(vec4u);
+
+// the header's fields are read as components of its two vectors, and a node as five whole vectors
+const HEADER_VECTORS = BVH8_TREE_HEADER_WORDS / 4;
+const NODE_VECTORS = BVH8_TREE_NODE_STRIDE_WORDS / 4;
+
+const COMPONENTS = 'xyzw';
+
+assert.equal(BVH8_TREE_BOUNDS_LOW_WORD, 0, 'the reads below take the low corner from the first vector');
+assert.equal(BVH8_TREE_BOUNDS_HIGH_WORD, 4, 'the reads below take the high corner from the second vector');
+assert.isInteger(HEADER_VECTORS, 'HEADER_VECTORS');
+assert.equal(NODE_VECTORS, 5, 'the reads below take a node as five vectors');
+
+const LEAF_COUNT = `tree[${BVH8_TREE_LEAF_COUNT_WORD >> 2}].${COMPONENTS[BVH8_TREE_LEAF_COUNT_WORD & 3]}`;
+const ORDER_OFFSET = `tree[${BVH8_TREE_ORDER_OFFSET_WORD >> 2}].${COMPONENTS[BVH8_TREE_ORDER_OFFSET_WORD & 3]}`;
+
+/**
+ * Reads of a BVH8 that owns its buffer ({@link BVH8_TREE_BUFFER_LAYOUT}), bound as
+ * {@link BVH8_TREE_TYPE}:
+ *
+ * ```wgsl
+ * fn bvh8_tree_read_node(tree, index: u32) -> BVH8Node
+ * fn bvh8_tree_read_payload(tree, node: BVH8Node, offset: u32) -> u32
+ * fn bvh8_tree_leaf_count(tree) -> u32
+ * fn bvh8_tree_bounds_low(tree) -> vec3<f32>
+ * fn bvh8_tree_bounds_high(tree) -> vec3<f32>
+ * ```
+ *
+ * A node's leaf slots each hold one leaf, and a walk has them as bits of the node's run, as it has a
+ * mesh's triangles: `bvh8_tree_read_payload` gives the payload of the leaf at an offset in that run.
+ *
+ * The root is node 0, and a tree of no leaves has one: a walk starts there without asking.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_bvh8_tree_read = CodeChunk.from(
+    //language=WGSL
+    `
+fn bvh8_tree_read_node(tree: ptr<storage, array<vec4<u32>>, read>, index: u32) -> ${BVH8_INODE_STRUCT.wgsl_ref} {
+    let at = ${HEADER_VECTORS}u + index * ${NODE_VECTORS}u;
+
+    return ${BVH8_INODE_STRUCT.wgsl_ref}(array<vec4<u32>, 5>(tree[at], tree[at + 1u], tree[at + 2u], tree[at + 3u], tree[at + 4u]));
+}
+
+fn bvh8_tree_read_payload(tree: ptr<storage, array<vec4<u32>>, read>, node: ${BVH8_INODE_STRUCT.wgsl_ref}, offset: u32) -> u32 {
+    // the node's run starts at its triangle base, in the payloads behind the nodes
+    let word = ${ORDER_OFFSET} + node.data[1].y + offset;
+
+    let four = tree[word >> 2u];
+
+    // one of the four by two selects: a vector indexed by a variable is put in memory first
+    let pair = select(four.xy, four.zw, (word & 2u) != 0u);
+
+    return select(pair.x, pair.y, (word & 1u) != 0u);
+}
+
+fn bvh8_tree_leaf_count(tree: ptr<storage, array<vec4<u32>>, read>) -> u32 {
+    return ${LEAF_COUNT};
+}
+
+fn bvh8_tree_bounds_low(tree: ptr<storage, array<vec4<u32>>, read>) -> vec3<f32> {
+    return bitcast<vec3<f32>>(tree[0].xyz);
+}
+
+fn bvh8_tree_bounds_high(tree: ptr<storage, array<vec4<u32>>, read>) -> vec3<f32> {
+    return bitcast<vec3<f32>>(tree[1].xyz);
+}
+    `, [
+        BVH8_INODE_STRUCT.declaration_chunk,
+    ]
+);

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

@@ -0,0 +1,23 @@
+/**
+ * Bytes {@link chunk_bvh8_waiting_slots} holds: four to a word, four words.
+ * @type {number}
+ */
+export const BVH8_WAITING_SLOTS_CAPACITY: number;
+/**
+ * Sixteen bytes kept last in, first out, in four words: for each node a walk has left waiting on its
+ * traversal stack, which of the node's eight slots are still to visit.
+ *
+ * A walk that keeps these beside the stack rather than in it writes one word of a stack entry instead
+ * of two. A function's array costs by the words that are ever indexed, on hardware that keeps it in
+ * registers, and these four words are never indexed: a push or a pop moves all of them by a byte.
+ *
+ * - `bvh8_waiting_slots_push` puts a byte in front; `slots` must fit a byte. A seventeenth pushes the
+ *   oldest out.
+ * - `bvh8_waiting_slots_latest` is the byte last pushed, zero when there is none.
+ * - `bvh8_waiting_slots_pop` drops it.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_bvh8_waiting_slots: CodeChunk;
+import { CodeChunk } from "../../../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_bvh8_waiting_slots.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_bvh8_waiting_slots.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/shade/renderer/shader/chunk/bvh/bvh8/webgpu/chunk_bvh8_waiting_slots.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,0CAFU,MAAM,CAE8B;AAE9C;;;;;;;;;;;;;;GAcG;AACH,uCAFU,SAAS,CAkBjB;0BAvCwB,mCAAmC"}

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

@@ -0,0 +1,40 @@
+import { CodeChunk } from "../../../../compiler/CodeChunk.js";
+
+/**
+ * Bytes {@link chunk_bvh8_waiting_slots} holds: four to a word, four words.
+ * @type {number}
+ */
+export const BVH8_WAITING_SLOTS_CAPACITY = 16;
+
+/**
+ * Sixteen bytes kept last in, first out, in four words: for each node a walk has left waiting on its
+ * traversal stack, which of the node's eight slots are still to visit.
+ *
+ * A walk that keeps these beside the stack rather than in it writes one word of a stack entry instead
+ * of two. A function's array costs by the words that are ever indexed, on hardware that keeps it in
+ * registers, and these four words are never indexed: a push or a pop moves all of them by a byte.
+ *
+ * - `bvh8_waiting_slots_push` puts a byte in front; `slots` must fit a byte. A seventeenth pushes the
+ *   oldest out.
+ * - `bvh8_waiting_slots_latest` is the byte last pushed, zero when there is none.
+ * - `bvh8_waiting_slots_pop` drops it.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_bvh8_waiting_slots = CodeChunk.from(
+    //language=WGSL
+    `
+// the latest byte is the low byte of x, the oldest the high byte of w
+fn bvh8_waiting_slots_push(waiting: vec4<u32>, slots: u32) -> vec4<u32> {
+    return (waiting << vec4<u32>(8u)) | vec4<u32>(slots, waiting.xyz >> vec3<u32>(24u));
+}
+
+fn bvh8_waiting_slots_latest(waiting: vec4<u32>) -> u32 {
+    return waiting.x & 0xffu;
+}
+
+fn bvh8_waiting_slots_pop(waiting: vec4<u32>) -> vec4<u32> {
+    return (waiting >> vec4<u32>(8u)) | (vec4<u32>(waiting.yzw, 0u) << vec4<u32>(24u));
+}
+    `
+);

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"chunk_ray_query_blas_nearest.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/geometry/ray/chunk_ray_query_blas_nearest.js"],"names":[],"mappings":"AAWA,qDAwFE;0BAnGwB,gCAAgC"}
+{"version":3,"file":"chunk_ray_query_blas_nearest.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/geometry/ray/chunk_ray_query_blas_nearest.js"],"names":[],"mappings":"AAiBA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,2CAFU,SAAS,CAiHjB;0BAtJwB,gCAAgC"}