@woosh/meep-engine 3.68.0 → 3.70.0

package/src/shade/renderer/gpu_primitive/bvh8/chunk_bvh8_encode_assign.d.ts

@@ -0,0 +1,31 @@
+/**
+ * The slot each child of a wide node is given by the encode of a binary tree as a BVH8
+ * ({@link bvh8_encode_from_bvh2}):
+ *
+ * ```wgsl
+ * struct BVH8EncodeAssignment { slots: u32, internal: u32 }
+ *
+ * fn bvh8_encode_assign(node: u32, children: BVH8EncodeChildren) -> BVH8EncodeAssignment
+ * fn bvh8_encode_slot_of(slots: u32, child: u32) -> u32
+ * fn bvh8_encode_rank(internal: u32, slot: u32) -> u32
+ * ```
+ *
+ * `slots` holds a slot a child, three bits each, in the order `bvh8_encode_gather` lists the
+ * children; `bvh8_encode_slot_of` reads one out. `internal` has a bit per slot that holds a child
+ * node, which is the node's child mask; `bvh8_encode_rank` is how many of those sit below a slot:
+ * where the child node in that slot stands in the node's block of child nodes.
+ *
+ * Cheapest (child, slot) pair first, where a child costs a slot the distance its box's centre lies
+ * from the node's, taken with the slot's signs. Of equal costs the first met wins, children in order
+ * and for a child its slots in order. A child whose box is not a number costs nothing a comparison
+ * can rank; it takes the lowest slot left, so that a tree's shape never depends on what its boxes
+ * hold.
+ *
+ * The enclosing shader declares what {@link chunk_bvh8_encode_gather} reads, and the binary tree is
+ * fitted.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_bvh8_encode_assign: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_bvh8_encode_assign.d.ts.map

package/src/shade/renderer/gpu_primitive/bvh8/chunk_bvh8_encode_assign.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_bvh8_encode_assign.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/gpu_primitive/bvh8/chunk_bvh8_encode_assign.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,uCAFU,SAAS,CAgJjB;0BA7KwB,oCAAoC"}

package/src/shade/renderer/gpu_primitive/bvh8/chunk_bvh8_encode_assign.js

@@ -0,0 +1,175 @@
+import { F32_MAX_DEFINITION } from "../../shader/chunk/math/F32_MAX_DEFINITION.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { chunk_bvh8_encode_gather } from "./chunk_bvh8_encode_gather.js";
+
+/**
+ * The slot each child of a wide node is given by the encode of a binary tree as a BVH8
+ * ({@link bvh8_encode_from_bvh2}):
+ *
+ * ```wgsl
+ * struct BVH8EncodeAssignment { slots: u32, internal: u32 }
+ *
+ * fn bvh8_encode_assign(node: u32, children: BVH8EncodeChildren) -> BVH8EncodeAssignment
+ * fn bvh8_encode_slot_of(slots: u32, child: u32) -> u32
+ * fn bvh8_encode_rank(internal: u32, slot: u32) -> u32
+ * ```
+ *
+ * `slots` holds a slot a child, three bits each, in the order `bvh8_encode_gather` lists the
+ * children; `bvh8_encode_slot_of` reads one out. `internal` has a bit per slot that holds a child
+ * node, which is the node's child mask; `bvh8_encode_rank` is how many of those sit below a slot:
+ * where the child node in that slot stands in the node's block of child nodes.
+ *
+ * Cheapest (child, slot) pair first, where a child costs a slot the distance its box's centre lies
+ * from the node's, taken with the slot's signs. Of equal costs the first met wins, children in order
+ * and for a child its slots in order. A child whose box is not a number costs nothing a comparison
+ * can rank; it takes the lowest slot left, so that a tree's shape never depends on what its boxes
+ * hold.
+ *
+ * The enclosing shader declares what {@link chunk_bvh8_encode_gather} reads, and the binary tree is
+ * fitted.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_bvh8_encode_assign = CodeChunk.from(
+    //language=WGSL
+    `
+const BVH8_ENCODE_SLOT_UNASSIGNED = 0xffffffffu;
+
+struct BVH8EncodeAssignment {
+    // a slot a child, three bits each, in the children's order
+    slots: u32,
+    // a bit per slot that holds a child node
+    internal: u32,
+}
+
+fn bvh8_encode_slot_of(slots: u32, child: u32) -> u32 {
+    return (slots >> (child * 3u)) & 7u;
+}
+
+// how many child nodes sit in the slots below this one
+fn bvh8_encode_rank(internal: u32, slot: u32) -> u32 {
+    return countOneBits(internal & ((1u << slot) - 1u));
+}
+
+struct BVH8EncodeCheapest {
+    cost: f32,
+    // BVH8_ENCODE_SLOT_UNASSIGNED when no open slot has a cost that can be ranked
+    slot: u32,
+}
+
+// The cheapest of the slots still open to a child whose centre lies 'offset' from its node's, and of
+// equal costs the lowest slot.
+fn bvh8_encode_cheapest_slot(offset: vec3<f32>, filled: u32) -> BVH8EncodeCheapest {
+    // the slots still open, the low four and the high four
+    let open_low = (vec4<u32>(filled) & vec4<u32>(1u, 2u, 4u, 8u)) == vec4<u32>(0u);
+    let open_high = (vec4<u32>(filled) & vec4<u32>(16u, 32u, 64u, 128u)) == vec4<u32>(0u);
+
+    // What the child costs each slot, (±x + ±y) + ±z: x is taken against the slot's bit 2, y against
+    // bit 1, z against bit 0.
+    let y = vec4<f32>(offset.y, offset.y, -offset.y, -offset.y);
+    let z = vec4<f32>(offset.z, -offset.z, offset.z, -offset.z);
+
+    let cost_low = (vec4<f32>(offset.x) + y) + z;
+    let cost_high = (vec4<f32>(-offset.x) + y) + z;
+
+    // an open slot, at a cost that is a number below infinity
+    let ranked_low = open_low & (cost_low <= vec4<f32>(F32_MAX));
+    let ranked_high = open_high & (cost_high <= vec4<f32>(F32_MAX));
+
+    let least_of = min(
+        select(vec4<f32>(F32_MAX), cost_low, ranked_low),
+        select(vec4<f32>(F32_MAX), cost_high, ranked_high)
+    );
+
+    let least = min(min(least_of.x, least_of.y), min(least_of.z, least_of.w));
+
+    // the slots at that cost
+    let at = select(vec4<u32>(0u), vec4<u32>(1u, 2u, 4u, 8u), ranked_low & (cost_low == vec4<f32>(least)))
+        | select(vec4<u32>(0u), vec4<u32>(16u, 32u, 64u, 128u), ranked_high & (cost_high == vec4<f32>(least)));
+
+    let slots_at = at.x | at.y | at.z | at.w;
+
+    return BVH8EncodeCheapest(least, select(countTrailingZeros(slots_at), BVH8_ENCODE_SLOT_UNASSIGNED, slots_at == 0u));
+}
+
+fn bvh8_encode_assign(node: u32, children: BVH8EncodeChildren) -> BVH8EncodeAssignment {
+    // each child's centre from the node's, both doubled
+    var offsets: array<vec3<f32>, 8>;
+
+    // each child's cheapest open slot, and what it costs
+    var cheapest_cost: array<f32, 8>;
+    var cheapest_slot: array<u32, 8>;
+
+    let centre = bvh8_encode_low(node) + bvh8_encode_high(node);
+
+    for (var c = 0u; c < children.count; c++) {
+        let child = children.nodes[c];
+
+        let offset = (bvh8_encode_low(child) + bvh8_encode_high(child)) - centre;
+
+        let cheapest = bvh8_encode_cheapest_slot(offset, 0u);
+
+        offsets[c] = offset;
+        cheapest_cost[c] = cheapest.cost;
+        cheapest_slot[c] = cheapest.slot;
+    }
+
+    var assignment = BVH8EncodeAssignment(0u, 0u);
+
+    // children with a slot, and slots with a child
+    var placed = 0u;
+    var filled = 0u;
+
+    // a child a turn: the cheapest (child, slot) pair still open
+    for (var turn = 0u; turn < children.count; turn++) {
+        var min_cost = 0.0;
+        var min_slot = BVH8_ENCODE_SLOT_UNASSIGNED;
+        var min_child = BVH8_ENCODE_SLOT_UNASSIGNED;
+
+        for (var c = 0u; c < children.count; c++) {
+            if ((placed & (1u << c)) != 0u || cheapest_slot[c] == BVH8_ENCODE_SLOT_UNASSIGNED) {
+                continue;
+            }
+
+            // the first child that can be ranked, and after it any that is cheaper
+            if (min_slot == BVH8_ENCODE_SLOT_UNASSIGNED || cheapest_cost[c] < min_cost) {
+                min_cost = cheapest_cost[c];
+                min_slot = cheapest_slot[c];
+                min_child = c;
+            }
+        }
+
+        if (min_slot == BVH8_ENCODE_SLOT_UNASSIGNED) {
+            // no cost can be ranked: the first child still without a slot, into the lowest slot left
+            min_child = countTrailingZeros(~placed);
+            min_slot = countTrailingZeros(~filled);
+        }
+
+        placed |= 1u << min_child;
+        filled |= 1u << min_slot;
+
+        assignment.slots |= min_slot << (min_child * 3u);
+
+        if ((children.internal & (1u << min_child)) != 0u) {
+            assignment.internal |= 1u << min_slot;
+        }
+
+        // A child's cheapest open slot stays its cheapest until that slot is taken; whoever had that
+        // one looks again.
+        for (var c = 0u; c < children.count; c++) {
+            if ((placed & (1u << c)) == 0u && cheapest_slot[c] == min_slot) {
+                let cheapest = bvh8_encode_cheapest_slot(offsets[c], filled);
+
+                cheapest_cost[c] = cheapest.cost;
+                cheapest_slot[c] = cheapest.slot;
+            }
+        }
+    }
+
+    return assignment;
+}
+`, [
+        F32_MAX_DEFINITION,
+        chunk_bvh8_encode_gather,
+    ]
+);

package/src/shade/renderer/gpu_primitive/bvh8/chunk_bvh8_encode_depth.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Levels a binary tree handed to the GPU's encode may have below its root.
+ *
+ * A Karras tree splits on a bit of a 30-bit Morton code or, among equal codes, on a bit of a 32-bit
+ * leaf index, and every level down splits on a later bit.
+ *
+ * @type {number}
+ */
+export const BVH8_ENCODE_MAX_BINARY_DEPTH: number;
+/**
+ * How many nodes lie above an internal node of a binary tree:
+ *
+ * ```wgsl
+ * fn bvh8_encode_depth(node: u32) -> u32
+ * ```
+ *
+ * The encode of a binary tree as a BVH8 ({@link bvh8_encode_from_bvh2}) makes a node of the wide
+ * tree of every internal node whose depth is a multiple of three.
+ *
+ * The enclosing shader declares `parents`, an array of `u32` an internal node: its parent,
+ * `BVH_NULL_NODE` at the root. The tree is at most {@link BVH8_ENCODE_MAX_BINARY_DEPTH} deep.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_bvh8_encode_depth: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_bvh8_encode_depth.d.ts.map

package/src/shade/renderer/gpu_primitive/bvh8/chunk_bvh8_encode_depth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_bvh8_encode_depth.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/gpu_primitive/bvh8/chunk_bvh8_encode_depth.js"],"names":[],"mappings":"AAGA;;;;;;;GAOG;AACH,2CAFU,MAAM,CAEoC;AAEpD;;;;;;;;;;;;;;GAcG;AACH,sCAFU,SAAS,CAqBjB;0BA9CwB,oCAAoC"}

package/src/shade/renderer/gpu_primitive/bvh8/chunk_bvh8_encode_depth.js

@@ -0,0 +1,48 @@
+import { BVH_NULL_NODE_DEFINITION } from "../../shader/chunk/bvh/BVH_NULL_NODE_DEFINITION.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+
+/**
+ * Levels a binary tree handed to the GPU's encode may have below its root.
+ *
+ * A Karras tree splits on a bit of a 30-bit Morton code or, among equal codes, on a bit of a 32-bit
+ * leaf index, and every level down splits on a later bit.
+ *
+ * @type {number}
+ */
+export const BVH8_ENCODE_MAX_BINARY_DEPTH = 30 + 32;
+
+/**
+ * How many nodes lie above an internal node of a binary tree:
+ *
+ * ```wgsl
+ * fn bvh8_encode_depth(node: u32) -> u32
+ * ```
+ *
+ * The encode of a binary tree as a BVH8 ({@link bvh8_encode_from_bvh2}) makes a node of the wide
+ * tree of every internal node whose depth is a multiple of three.
+ *
+ * The enclosing shader declares `parents`, an array of `u32` an internal node: its parent,
+ * `BVH_NULL_NODE` at the root. The tree is at most {@link BVH8_ENCODE_MAX_BINARY_DEPTH} deep.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_bvh8_encode_depth = CodeChunk.from(
+    //language=WGSL
+    `
+const BVH8_ENCODE_MAX_BINARY_DEPTH = ${BVH8_ENCODE_MAX_BINARY_DEPTH}u;
+
+fn bvh8_encode_depth(node: u32) -> u32 {
+    var depth = 0u;
+    var at = parents[node];
+
+    while (at != BVH_NULL_NODE && depth < BVH8_ENCODE_MAX_BINARY_DEPTH) {
+        depth++;
+        at = parents[at];
+    }
+
+    return depth;
+}
+`, [
+        BVH_NULL_NODE_DEFINITION,
+    ]
+);

package/src/shade/renderer/gpu_primitive/bvh8/chunk_bvh8_encode_gather.d.ts

@@ -0,0 +1,26 @@
+/**
+ * What the encode of a binary tree as a BVH8 ({@link bvh8_encode_from_bvh2}) reads of the binary
+ * tree, for one of its nodes:
+ *
+ * ```wgsl
+ * fn bvh8_encode_child_1(node: u32) -> u32
+ * fn bvh8_encode_child_2(node: u32) -> u32    // on a leaf, its payload
+ * fn bvh8_encode_low(node: u32) -> vec3<f32>
+ * fn bvh8_encode_high(node: u32) -> vec3<f32>
+ * fn bvh8_encode_gather(node: u32, internal_count: u32) -> BVH8EncodeChildren
+ * ```
+ *
+ * `bvh8_encode_gather` is the children a node of the binary tree has as a node of the wide one:
+ * what lies `BVH8_ENCODE_LEVELS` below it and the leaves met sooner, with which of them are
+ * nodes of the wide tree themselves.
+ *
+ * The enclosing shader declares `tree`, `array<u32>`: the binary tree, `[root][nodes]` in
+ * the layout of {@link BVH_BUFFER_LAYOUT}, in the order `graph_bvh_build_lbvh` writes one: its
+ * `internal_count` internal nodes first, the root node 0. A node is internal by its index, with no
+ * word of it read.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_bvh8_encode_gather: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_bvh8_encode_gather.d.ts.map

package/src/shade/renderer/gpu_primitive/bvh8/chunk_bvh8_encode_gather.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_bvh8_encode_gather.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/gpu_primitive/bvh8/chunk_bvh8_encode_gather.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,uCAFU,SAAS,CA2FjB;0BArHwB,oCAAoC"}

package/src/shade/renderer/gpu_primitive/bvh8/chunk_bvh8_encode_gather.js

@@ -0,0 +1,118 @@
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { BVH_HEADER_WORDS } from "../bvh/BVH_BUFFER_LAYOUT.js";
+import { BVH_NODE_LAYOUT_DEFINITION } from "../bvh/BVH_NODE_LAYOUT_DEFINITION.js";
+import { BVH8_ENCODE_LEVELS } from "./bvh8_encode_from_bvh2.js";
+
+/**
+ * What the encode of a binary tree as a BVH8 ({@link bvh8_encode_from_bvh2}) reads of the binary
+ * tree, for one of its nodes:
+ *
+ * ```wgsl
+ * fn bvh8_encode_child_1(node: u32) -> u32
+ * fn bvh8_encode_child_2(node: u32) -> u32    // on a leaf, its payload
+ * fn bvh8_encode_low(node: u32) -> vec3<f32>
+ * fn bvh8_encode_high(node: u32) -> vec3<f32>
+ * fn bvh8_encode_gather(node: u32, internal_count: u32) -> BVH8EncodeChildren
+ * ```
+ *
+ * `bvh8_encode_gather` is the children a node of the binary tree has as a node of the wide one:
+ * what lies `BVH8_ENCODE_LEVELS` below it and the leaves met sooner, with which of them are
+ * nodes of the wide tree themselves.
+ *
+ * The enclosing shader declares `tree`, `array<u32>`: the binary tree, `[root][nodes]` in
+ * the layout of {@link BVH_BUFFER_LAYOUT}, in the order `graph_bvh_build_lbvh` writes one: its
+ * `internal_count` internal nodes first, the root node 0. A node is internal by its index, with no
+ * word of it read.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_bvh8_encode_gather = CodeChunk.from(
+    //language=WGSL
+    `
+const BVH8_ENCODE_LEVELS = ${BVH8_ENCODE_LEVELS}u;
+
+// node 0 of the binary tree, in words
+const BVH8_ENCODE_TREE_NODES = ${BVH_HEADER_WORDS}u;
+
+struct BVH8EncodeChildren {
+    // nodes of the binary tree, child 1 before child 2 all the way down
+    nodes: array<u32, 8>,
+    count: u32,
+    // a bit per entry of 'nodes' that is internal, and so a wide node itself
+    internal: u32,
+}
+
+fn bvh8_encode_child_1(node: u32) -> u32 {
+    return tree[BVH8_ENCODE_TREE_NODES + node * BVH_NODE_STRIDE + BVH_NODE_CHILD_1];
+}
+
+// on a leaf, its payload
+fn bvh8_encode_child_2(node: u32) -> u32 {
+    return tree[BVH8_ENCODE_TREE_NODES + node * BVH_NODE_STRIDE + BVH_NODE_CHILD_2];
+}
+
+fn bvh8_encode_low(node: u32) -> vec3<f32> {
+    let at = BVH8_ENCODE_TREE_NODES + node * BVH_NODE_STRIDE + BVH_NODE_BOUNDS;
+
+    return bitcast<vec3<f32>>(vec3<u32>(tree[at], tree[at + 1u], tree[at + 2u]));
+}
+
+fn bvh8_encode_high(node: u32) -> vec3<f32> {
+    let at = BVH8_ENCODE_TREE_NODES + node * BVH_NODE_STRIDE + BVH_NODE_BOUNDS + 3u;
+
+    return bitcast<vec3<f32>>(vec3<u32>(tree[at], tree[at + 1u], tree[at + 2u]));
+}
+
+// The children of a wide node: what lies BVH8_ENCODE_LEVELS below it in the binary tree, and the
+// leaves met sooner. A node that is a leaf is the whole tree, and its own only child.
+fn bvh8_encode_gather(node: u32, internal_count: u32) -> BVH8EncodeChildren {
+    var children: BVH8EncodeChildren;
+
+    if (node >= internal_count) {
+        children.nodes[0] = node;
+        children.count = 1u;
+        children.internal = 0u;
+
+        return children;
+    }
+
+    children.nodes[0] = bvh8_encode_child_1(node);
+    children.nodes[1] = bvh8_encode_child_2(node);
+    children.count = 2u;
+
+    // a level at a time, an internal node gives way to its two children where it stands
+    for (var level = 1u; level < BVH8_ENCODE_LEVELS; level++) {
+        var next: array<u32, 8>;
+        var next_count = 0u;
+
+        for (var c = 0u; c < children.count; c++) {
+            let at = children.nodes[c];
+
+            if (at >= internal_count) {
+                next[next_count] = at;
+                next_count++;
+            } else {
+                next[next_count] = bvh8_encode_child_1(at);
+                next[next_count + 1u] = bvh8_encode_child_2(at);
+                next_count += 2u;
+            }
+        }
+
+        children.nodes = next;
+        children.count = next_count;
+    }
+
+    children.internal = 0u;
+
+    for (var c = 0u; c < children.count; c++) {
+        if (children.nodes[c] < internal_count) {
+            children.internal |= 1u << c;
+        }
+    }
+
+    return children;
+}
+`, [
+        BVH_NODE_LAYOUT_DEFINITION,
+    ]
+);

package/src/shade/renderer/gpu_primitive/bvh8/chunk_bvh8_encode_node.d.ts

@@ -0,0 +1,22 @@
+/**
+ * What the encode of a binary tree as a BVH8 ({@link bvh8_encode_from_bvh2}) writes, for one node of
+ * the binary tree that becomes a node of the wide one:
+ *
+ * ```wgsl
+ * fn bvh8_encode_write_node(node: u32, internal_count: u32, slots: u32, index: u32, child_base: u32, leaf_base: u32, order_offset: u32)
+ * fn bvh8_encode_write_header(leaf_count: u32, order_offset: u32)
+ * ```
+ *
+ * `bvh8_encode_write_node` writes the twenty words of the node at `index` and the payloads of its
+ * leaves, in the run that starts `leaf_base` into the payloads at word `order_offset`. `slots` is
+ * the slot each of the node's children was given, three bits a child in the order
+ * `bvh8_encode_gather` lists them ({@link chunk_bvh8_encode_assign}).
+ *
+ * The enclosing shader declares what {@link chunk_bvh8_encode_gather} reads, fitted, and
+ * `out`, `array<u32>`: the BVH8, in the layout of {@link BVH8_TREE_BUFFER_LAYOUT}.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_bvh8_encode_node: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_bvh8_encode_node.d.ts.map

package/src/shade/renderer/gpu_primitive/bvh8/chunk_bvh8_encode_node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_bvh8_encode_node.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/gpu_primitive/bvh8/chunk_bvh8_encode_node.js"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;;;;;GAkBG;AACH,qCAFU,SAAS,CAiHjB;0BA7IwB,oCAAoC"}

package/src/shade/renderer/gpu_primitive/bvh8/chunk_bvh8_encode_node.js

@@ -0,0 +1,143 @@
+import { chunk_bvh8_node_grid } from "../../shader/chunk/bvh/bvh8/webgpu/chunk_bvh8_node_grid.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.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 "./BVH8_TREE_BUFFER_LAYOUT.js";
+import { chunk_bvh8_encode_gather } from "./chunk_bvh8_encode_gather.js";
+
+/**
+ * What the encode of a binary tree as a BVH8 ({@link bvh8_encode_from_bvh2}) writes, for one node of
+ * the binary tree that becomes a node of the wide one:
+ *
+ * ```wgsl
+ * fn bvh8_encode_write_node(node: u32, internal_count: u32, slots: u32, index: u32, child_base: u32, leaf_base: u32, order_offset: u32)
+ * fn bvh8_encode_write_header(leaf_count: u32, order_offset: u32)
+ * ```
+ *
+ * `bvh8_encode_write_node` writes the twenty words of the node at `index` and the payloads of its
+ * leaves, in the run that starts `leaf_base` into the payloads at word `order_offset`. `slots` is
+ * the slot each of the node's children was given, three bits a child in the order
+ * `bvh8_encode_gather` lists them ({@link chunk_bvh8_encode_assign}).
+ *
+ * The enclosing shader declares what {@link chunk_bvh8_encode_gather} reads, fitted, and
+ * `out`, `array<u32>`: the BVH8, in the layout of {@link BVH8_TREE_BUFFER_LAYOUT}.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_bvh8_encode_node = CodeChunk.from(
+    //language=WGSL
+    `
+const BVH8_ENCODE_OUT_NODES = ${BVH8_TREE_HEADER_WORDS}u;
+const BVH8_ENCODE_OUT_NODE_STRIDE = ${BVH8_TREE_NODE_STRIDE_WORDS}u;
+
+fn bvh8_encode_write_node(node: u32, internal_count: u32, slots: u32, index: u32, child_base: u32, leaf_base: u32, order_offset: u32) {
+    let children = bvh8_encode_gather(node, internal_count);
+
+    let low = bvh8_encode_low(node);
+
+    let grid = bvh8_node_grid(low, bvh8_encode_high(node));
+
+    var boxes: array<u32, 12>;
+
+    // the node of the binary tree in each slot
+    var held: array<u32, 8>;
+
+    var occupied = 0u;
+    var internal = 0u;
+
+    for (var c = 0u; c < children.count; c++) {
+        let child = children.nodes[c];
+        let slot = (slots >> (c * 3u)) & 7u;
+
+        occupied |= 1u << slot;
+        held[slot] = child;
+
+        if ((children.internal & (1u << c)) != 0u) {
+            internal |= 1u << slot;
+        }
+
+        let q_low = bvh8_node_grid_low(grid, bvh8_encode_low(child));
+        let q_high = bvh8_node_grid_high(grid, bvh8_encode_high(child));
+
+        let word = slot >> 2u;
+        let shift = (slot & 3u) * 8u;
+
+        // per axis: two words of low bytes, then two of high
+        boxes[word] |= q_low.x << shift;
+        boxes[2u + word] |= q_high.x << shift;
+        boxes[4u + word] |= q_low.y << shift;
+        boxes[6u + word] |= q_high.y << shift;
+        boxes[8u + word] |= q_low.z << shift;
+        boxes[10u + word] |= q_high.z << shift;
+    }
+
+    var metas = vec2<u32>(0u);
+
+    // leaves in slot order, a run of one each
+    var leaves = 0u;
+
+    for (var slot = 0u; slot < 8u; slot++) {
+        if ((occupied & (1u << slot)) == 0u) {
+            continue;
+        }
+
+        var slot_meta = 0x20u | (24u + slot);
+
+        if ((internal & (1u << slot)) == 0u) {
+            slot_meta = 0x20u | leaves;
+
+            // a leaf's second child word is its payload
+            out[order_offset + leaf_base + leaves] = bvh8_encode_child_2(held[slot]);
+
+            leaves++;
+        }
+
+        let shift = (slot & 3u) * 8u;
+
+        if (slot < 4u) {
+            metas.x |= slot_meta << shift;
+        } else {
+            metas.y |= slot_meta << shift;
+        }
+    }
+
+    let at = BVH8_ENCODE_OUT_NODES + index * BVH8_ENCODE_OUT_NODE_STRIDE;
+
+    out[at] = bitcast<u32>(low.x);
+    out[at + 1u] = bitcast<u32>(low.y);
+    out[at + 2u] = bitcast<u32>(low.z);
+    out[at + 3u] = grid.exponent.x | (grid.exponent.y << 8u) | (grid.exponent.z << 16u) | (internal << 24u);
+    out[at + 4u] = child_base;
+    out[at + 5u] = leaf_base;
+    out[at + 6u] = metas.x;
+    out[at + 7u] = metas.y;
+
+    for (var i = 0u; i < 12u; i++) {
+        out[at + 8u + i] = boxes[i];
+    }
+}
+
+// what stands before the nodes: the root's box, the leaves, and where their payloads start
+fn bvh8_encode_write_header(leaf_count: u32, order_offset: u32) {
+    let low = bvh8_encode_low(0u);
+    let high = bvh8_encode_high(0u);
+
+    out[${BVH8_TREE_BOUNDS_LOW_WORD}u] = bitcast<u32>(low.x);
+    out[${BVH8_TREE_BOUNDS_LOW_WORD + 1}u] = bitcast<u32>(low.y);
+    out[${BVH8_TREE_BOUNDS_LOW_WORD + 2}u] = bitcast<u32>(low.z);
+    out[${BVH8_TREE_LEAF_COUNT_WORD}u] = leaf_count;
+    out[${BVH8_TREE_BOUNDS_HIGH_WORD}u] = bitcast<u32>(high.x);
+    out[${BVH8_TREE_BOUNDS_HIGH_WORD + 1}u] = bitcast<u32>(high.y);
+    out[${BVH8_TREE_BOUNDS_HIGH_WORD + 2}u] = bitcast<u32>(high.z);
+    out[${BVH8_TREE_ORDER_OFFSET_WORD}u] = order_offset;
+}
+`, [
+        chunk_bvh8_node_grid,
+        chunk_bvh8_encode_gather,
+    ]
+);

package/src/shade/renderer/gpu_primitive/bvh8/chunk_bvh8_encode_sums.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Counts the encode of a binary tree as a BVH8 keeps of each internal node of the binary tree, laid
+ * end to end a kind at a time and summed by one scan: its child nodes, its leaves, and whether it is
+ * a node of the wide tree at all.
+ *
+ * @type {number}
+ */
+export const BVH8_ENCODE_COUNTS_PER_NODE: number;
+/**
+ * What the running sums of {@link shader_bvh8_encode_count}'s counts say:
+ *
+ * ```wgsl
+ * fn bvh8_encode_child_nodes(internal_count: u32) -> u32
+ * fn bvh8_encode_child_nodes_before(node: u32) -> u32
+ * fn bvh8_encode_leaves_before(node: u32, internal_count: u32) -> u32
+ * fn bvh8_encode_wide_node(ordinal: u32, internal_count: u32) -> u32
+ * ```
+ *
+ * `bvh8_encode_child_nodes` is every child node of the wide tree, which is every node of it but the
+ * root. The two `before` are what the internal nodes before one hold between them: with the root's
+ * one node, where that node's block of child nodes starts, and where its run of payloads does.
+ *
+ * `bvh8_encode_wide_node` is the internal node that is the `ordinal`th node of the wide tree, counted
+ * in the binary tree's order, for an ordinal below the wide tree's node count. A pass that takes a
+ * lane per node of the wide tree finds its node by it, and so has no lane without one.
+ *
+ * `internal_count` is the binary tree's internal nodes; a tree that is one leaf has none, and nothing
+ * of the sums is read for it. The enclosing shader declares `sums`,
+ * `array<u32>`: what `graph_prefix_scan_csdldf` makes of the counts, each sum including its own
+ * element.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_bvh8_encode_sums: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_bvh8_encode_sums.d.ts.map

package/src/shade/renderer/gpu_primitive/bvh8/chunk_bvh8_encode_sums.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_bvh8_encode_sums.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/gpu_primitive/bvh8/chunk_bvh8_encode_sums.js"],"names":[],"mappings":"AAGA;;;;;;GAMG;AACH,0CAFU,MAAM,CAE6B;AAE7C;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,qCAFU,SAAS,CA6DhB;0BAhGuB,oCAAoC"}