@woosh/meep-engine 3.68.0 → 3.70.0

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

@@ -0,0 +1,26 @@
+/**
+ * The most leaves {@link shader_bvh8_encode_count_single_workgroup} counts.
+ *
+ * A thread takes four internal nodes of the binary tree, and a tree has one fewer of those than
+ * leaves.
+ *
+ * @type {number}
+ */
+export const BVH8_ENCODE_SINGLE_WORKGROUP_LEAVES: number;
+/**
+ * The first three steps of {@link graph_bvh8_encode_from_bvh2} over at most
+ * {@link BVH8_ENCODE_SINGLE_WORKGROUP_LEAVES} leaves, in one workgroup and one dispatch: the parents,
+ * the counts and their running sums, each behind a barrier. `sums` comes out as the passes and the
+ * prefix scan between them leave it, word for word ({@link chunk_bvh8_encode_sums}).
+ *
+ * The parents are the workgroup's own memory. The sums are scanned in two steps: a thread sums its
+ * own nodes, then adds what the threads before it summed.
+ *
+ * A tree of one leaf has no internal node and nothing is written for it; nothing of `sums` is read
+ * for one either.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_bvh8_encode_count_single_workgroup: ComputeShader;
+import { ComputeShader } from "../../shader/ComputeShader.js";
+//# sourceMappingURL=shader_bvh8_encode_count_single_workgroup.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shader_bvh8_encode_count_single_workgroup.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/gpu_primitive/bvh8/shader_bvh8_encode_count_single_workgroup.js"],"names":[],"mappings":"AAsBA;;;;;;;GAOG;AACH,kDAFU,MAAM,CAEqE;AAuJrF;;;;;;;;;;;;;GAaG;AACH,wDAFU,aAAa,CAMpB;8BApM2B,+BAA+B"}

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

@@ -0,0 +1,200 @@
+import { assert } from "../../../../core/assert.js";
+import { BVH_NULL_NODE_DEFINITION } from "../../shader/chunk/bvh/BVH_NULL_NODE_DEFINITION.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import { u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
+import { BVH_HEADER_WORDS } from "../bvh/BVH_BUFFER_LAYOUT.js";
+import { BVH_NODE_LAYOUT_DEFINITION } from "../bvh/BVH_NODE_LAYOUT_DEFINITION.js";
+import { PREFIX_SCAN_CSDLDF_HEADER_WORDS } from "../prefix_sum/v1/shader_prefix_scan_csdldf.js";
+import { chunk_bvh8_encode_depth } from "./chunk_bvh8_encode_depth.js";
+import { chunk_bvh8_encode_gather } from "./chunk_bvh8_encode_gather.js";
+import { BVH8_ENCODE_COUNTS_PER_NODE } from "./chunk_bvh8_encode_sums.js";
+
+const WORKGROUP_SIZE = 256;
+
+/**
+ * Internal nodes of the binary tree a thread takes: a run of this many, in node order.
+ * @type {number}
+ */
+const NODES_PER_THREAD = 4;
+
+/**
+ * The most leaves {@link shader_bvh8_encode_count_single_workgroup} counts.
+ *
+ * A thread takes four internal nodes of the binary tree, and a tree has one fewer of those than
+ * leaves.
+ *
+ * @type {number}
+ */
+export const BVH8_ENCODE_SINGLE_WORKGROUP_LEAVES = WORKGROUP_SIZE * NODES_PER_THREAD;
+
+const INTERNAL_NODES = BVH8_ENCODE_SINGLE_WORKGROUP_LEAVES - 1;
+
+// A node's three counts, and a thread's and the tree's sums of them, share a word: child nodes, of
+// which a tree has fewer than leaves; leaves; and nodes of the wide tree, fewer than internal nodes.
+const CHILD_NODE_BITS = 10;
+const LEAF_BITS = 11;
+const WIDE_BITS = 10;
+
+assert.lessThan(BVH8_ENCODE_SINGLE_WORKGROUP_LEAVES - 2, 1 << CHILD_NODE_BITS, 'the child nodes of a tree this large do not fit their bits');
+assert.lessThan(BVH8_ENCODE_SINGLE_WORKGROUP_LEAVES, 1 << LEAF_BITS, 'the leaves of a tree this large do not fit their bits');
+assert.lessThan(INTERNAL_NODES, 1 << WIDE_BITS, 'the wide nodes of a tree this large do not fit their bits');
+assert.lessThanOrEqual(CHILD_NODE_BITS + LEAF_BITS + WIDE_BITS, 32, 'the three sums do not fit a word');
+
+const resources = new ShaderResourceSetDescriptor();
+
+// leaves in the binary tree
+resources.setImmediate("leaf_count", u32);
+
+resources.createGroup()
+    // `[root][nodes]`, in the layout of BVH_BUFFER_LAYOUT; of a node this reads its two child words
+    .addStorageBuffer("tree", WebGPUArray.from(u32), false)
+    // what the prefix scan would make of shader_bvh8_encode_count's counts
+    .addStorageBuffer("sums", WebGPUArray.from(u32), true);
+
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+const NODES_PER_THREAD = ${NODES_PER_THREAD}u;
+
+const SUMS = ${PREFIX_SCAN_CSDLDF_HEADER_WORDS}u;
+
+// of a word of counts: child nodes in the low bits, leaves above them, wide nodes above both
+const LEAF_SHIFT = ${CHILD_NODE_BITS}u;
+const WIDE_SHIFT = ${CHILD_NODE_BITS + LEAF_BITS}u;
+const CHILD_NODE_MASK = ${(1 << CHILD_NODE_BITS) - 1}u;
+const LEAF_MASK = ${(1 << LEAF_BITS) - 1}u;
+
+// the parent of every internal node of the binary tree
+var<workgroup> parents: array<u32, ${INTERNAL_NODES}>;
+
+// what each thread's own nodes count between them
+var<workgroup> thread_counts: array<u32, ${WORKGROUP_SIZE}>;
+
+@compute @workgroup_size(${WORKGROUP_SIZE}, 1, 1)
+fn main(@builtin(local_invocation_index) thread_id: u32) {
+    // the internal nodes come first, one fewer than there are leaves
+    let internal_count = leaf_count - 1u;
+
+    // this thread's nodes, a run in node order
+    let first = thread_id * NODES_PER_THREAD;
+
+    // Parents, as shader_bvh8_encode_parents finds them.
+    for (var k = 0u; k < NODES_PER_THREAD; k++) {
+        let node = first + k;
+
+        if (node < internal_count) {
+            let at = ${BVH_HEADER_WORDS}u + node * BVH_NODE_STRIDE;
+
+            let child_1 = tree[at + BVH_NODE_CHILD_1];
+            let child_2 = tree[at + BVH_NODE_CHILD_2];
+
+            if (child_1 < internal_count) {
+                parents[child_1] = node;
+            }
+
+            if (child_2 < internal_count) {
+                parents[child_2] = node;
+            }
+        }
+    }
+
+    if (thread_id == 0u) {
+        // nothing is above the root
+        parents[0] = BVH_NULL_NODE;
+    }
+
+    workgroupBarrier();
+
+    // Counts, as shader_bvh8_encode_count finds them: nothing for a node that is not a node of the
+    // wide tree.
+    var counted: array<u32, ${NODES_PER_THREAD}>;
+    var counted_by_thread = 0u;
+
+    for (var k = 0u; k < NODES_PER_THREAD; k++) {
+        let node = first + k;
+
+        if (node < internal_count && bvh8_encode_depth(node) % BVH8_ENCODE_LEVELS == 0u) {
+            let children = bvh8_encode_gather(node, internal_count);
+
+            let child_nodes = countOneBits(children.internal);
+
+            counted[k] = child_nodes | ((children.count - child_nodes) << LEAF_SHIFT) | (1u << WIDE_SHIFT);
+            counted_by_thread += counted[k];
+        }
+    }
+
+    thread_counts[thread_id] = counted_by_thread;
+
+    workgroupBarrier();
+
+    if (first >= internal_count) {
+        // no node of this thread's to sum to
+        return;
+    }
+
+    // The scan: the threads before this one, then this thread's own nodes in order, each sum
+    // including its node. A kind's sums carry on from the whole of the kinds before it.
+    var running = 0u;
+    var whole = 0u;
+
+    let threads = (internal_count + NODES_PER_THREAD - 1u) / NODES_PER_THREAD;
+
+    for (var t = 0u; t < threads; t++) {
+        let counted_by = thread_counts[t];
+
+        whole += counted_by;
+
+        if (t < thread_id) {
+            running += counted_by;
+        }
+    }
+
+    let child_nodes = whole & CHILD_NODE_MASK;
+    let leaves = (whole >> LEAF_SHIFT) & LEAF_MASK;
+
+    for (var k = 0u; k < NODES_PER_THREAD; k++) {
+        let node = first + k;
+
+        if (node < internal_count) {
+            running += counted[k];
+
+            sums[SUMS + node] = running & CHILD_NODE_MASK;
+            sums[SUMS + internal_count + node] = child_nodes + ((running >> LEAF_SHIFT) & LEAF_MASK);
+            sums[SUMS + 2u * internal_count + node] = child_nodes + leaves + (running >> WIDE_SHIFT);
+        }
+    }
+
+    if (thread_id == 0u) {
+        sums[0] = ${BVH8_ENCODE_COUNTS_PER_NODE}u * internal_count;
+    }
+}
+`, [
+        BVH_NULL_NODE_DEFINITION,
+        BVH_NODE_LAYOUT_DEFINITION,
+        chunk_bvh8_encode_depth,
+        chunk_bvh8_encode_gather,
+    ]
+);
+
+/**
+ * The first three steps of {@link graph_bvh8_encode_from_bvh2} over at most
+ * {@link BVH8_ENCODE_SINGLE_WORKGROUP_LEAVES} leaves, in one workgroup and one dispatch: the parents,
+ * the counts and their running sums, each behind a barrier. `sums` comes out as the passes and the
+ * prefix scan between them leave it, word for word ({@link chunk_bvh8_encode_sums}).
+ *
+ * The parents are the workgroup's own memory. The sums are scanned in two steps: a thread sums its
+ * own nodes, then adds what the threads before it summed.
+ *
+ * A tree of one leaf has no internal node and nothing is written for it; nothing of `sums` is read
+ * for one either.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_bvh8_encode_count_single_workgroup = ComputeShader.from({
+    label: "BVH8Encode/CountSingleWorkgroup",
+    resources,
+    body,
+});

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

@@ -0,0 +1,19 @@
+/**
+ * Lanes to a workgroup of the encode's passes that take a lane per internal node of the binary tree.
+ * @type {number}
+ */
+export const BVH8_ENCODE_WORKGROUP_SIZE: number;
+/**
+ * The parent of every internal node of a binary tree, from the nodes' child words — the first pass
+ * of {@link graph_bvh8_encode_from_bvh2} over more leaves than one workgroup takes.
+ *
+ * A lane per internal node writes the word of each child of its that is internal, and the root's
+ * lane the root's. Every node but the root is the child of one node, so every word has one writer.
+ *
+ * The tree is in the builder's order: internal nodes first, the root node 0.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_bvh8_encode_parents: ComputeShader;
+import { ComputeShader } from "../../shader/ComputeShader.js";
+//# sourceMappingURL=shader_bvh8_encode_parents.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shader_bvh8_encode_parents.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/gpu_primitive/bvh8/shader_bvh8_encode_parents.js"],"names":[],"mappings":"AASA;;;GAGG;AACH,yCAFU,MAAM,CAE6B;AAoD7C;;;;;;;;;;GAUG;AACH,yCAFU,aAAa,CAMpB;8BA9E2B,+BAA+B"}

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

@@ -0,0 +1,81 @@
+import { BVH_NULL_NODE_DEFINITION } from "../../shader/chunk/bvh/BVH_NULL_NODE_DEFINITION.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import { u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
+import { BVH_HEADER_WORDS } from "../bvh/BVH_BUFFER_LAYOUT.js";
+import { BVH_NODE_LAYOUT_DEFINITION } from "../bvh/BVH_NODE_LAYOUT_DEFINITION.js";
+
+/**
+ * Lanes to a workgroup of the encode's passes that take a lane per internal node of the binary tree.
+ * @type {number}
+ */
+export const BVH8_ENCODE_WORKGROUP_SIZE = 64;
+
+const resources = new ShaderResourceSetDescriptor();
+
+// leaves in the binary tree
+resources.setImmediate("leaf_count", u32);
+
+resources.createGroup()
+    // `[root][nodes]`, in the layout of BVH_BUFFER_LAYOUT; of a node this reads its two child words
+    .addStorageBuffer("tree", WebGPUArray.from(u32), false)
+    // a word an internal node of the binary tree
+    .addStorageBuffer("parents", WebGPUArray.from(u32), true);
+
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+@compute @workgroup_size(${BVH8_ENCODE_WORKGROUP_SIZE}, 1, 1)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+    let node = gid.x;
+
+    // the internal nodes come first, one fewer than there are leaves
+    let internal_count = leaf_count - 1u;
+
+    if (node >= internal_count) {
+        return;
+    }
+
+    let at = ${BVH_HEADER_WORDS}u + node * BVH_NODE_STRIDE;
+
+    let child_1 = tree[at + BVH_NODE_CHILD_1];
+    let child_2 = tree[at + BVH_NODE_CHILD_2];
+
+    // a leaf's parent is nobody's to ask
+    if (child_1 < internal_count) {
+        parents[child_1] = node;
+    }
+
+    if (child_2 < internal_count) {
+        parents[child_2] = node;
+    }
+
+    if (node == 0u) {
+        // nothing is above the root
+        parents[0] = BVH_NULL_NODE;
+    }
+}
+`, [
+        BVH_NULL_NODE_DEFINITION,
+        BVH_NODE_LAYOUT_DEFINITION,
+    ]
+);
+
+/**
+ * The parent of every internal node of a binary tree, from the nodes' child words — the first pass
+ * of {@link graph_bvh8_encode_from_bvh2} over more leaves than one workgroup takes.
+ *
+ * A lane per internal node writes the word of each child of its that is internal, and the root's
+ * lane the root's. Every node but the root is the child of one node, so every word has one writer.
+ *
+ * The tree is in the builder's order: internal nodes first, the root node 0.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_bvh8_encode_parents = ComputeShader.from({
+    label: "BVH8Encode/Parents",
+    resources,
+    body,
+});

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

@@ -0,0 +1,14 @@
+/**
+ * Write the BVH8 — the last pass of {@link graph_bvh8_encode_from_bvh2} over more leaves than one
+ * workgroup takes.
+ *
+ * A lane per node of the wide tree, found as {@link shader_bvh8_encode_assign} finds it; the lane
+ * writes that node, the payloads of its leaves, and at the root the header. Where a node goes is its
+ * parent's block of child nodes, from the sums, and its rank there, from what the assign pass left
+ * it: no lane reads a word another writes.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_bvh8_encode_write: ComputeShader;
+import { ComputeShader } from "../../shader/ComputeShader.js";
+//# sourceMappingURL=shader_bvh8_encode_write.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shader_bvh8_encode_write.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/gpu_primitive/bvh8/shader_bvh8_encode_write.js"],"names":[],"mappings":"AAqFA;;;;;;;;;;GAUG;AACH,uCAFU,aAAa,CAMpB;8BAnG2B,+BAA+B"}

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

@@ -0,0 +1,101 @@
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import { u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
+import { chunk_bvh8_encode_node } from "./chunk_bvh8_encode_node.js";
+import { chunk_bvh8_encode_sums } from "./chunk_bvh8_encode_sums.js";
+import {
+    BVH8_ENCODE_PLACEMENT_PARENT_WORD,
+    BVH8_ENCODE_PLACEMENT_SLOTS_WORD,
+    BVH8_ENCODE_PLACEMENT_STRIDE_WORDS
+} from "./shader_bvh8_encode_assign.js";
+import { BVH8_ENCODE_WORKGROUP_SIZE } from "./shader_bvh8_encode_parents.js";
+
+const resources = new ShaderResourceSetDescriptor();
+
+// leaves in the binary tree
+resources.setImmediate("leaf_count", u32);
+
+resources.createGroup()
+    // `[root][nodes]`, in the layout of BVH_BUFFER_LAYOUT, fitted
+    .addStorageBuffer("tree", WebGPUArray.from(u32), false)
+    // the running sums of what shader_bvh8_encode_count wrote, each including its own element
+    .addStorageBuffer("sums", WebGPUArray.from(u32), false)
+    // what shader_bvh8_encode_assign wrote of each node of the wide tree
+    .addStorageBuffer("placement", WebGPUArray.from(u32), false)
+    // the BVH8, in the layout of BVH8_TREE_BUFFER_LAYOUT
+    .addStorageBuffer("out", WebGPUArray.from(u32), true);
+
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+const PLACEMENT_STRIDE = ${BVH8_ENCODE_PLACEMENT_STRIDE_WORDS}u;
+const PLACEMENT_SLOTS = ${BVH8_ENCODE_PLACEMENT_SLOTS_WORD}u;
+const PLACEMENT_PARENT = ${BVH8_ENCODE_PLACEMENT_PARENT_WORD}u;
+
+@compute @workgroup_size(${BVH8_ENCODE_WORKGROUP_SIZE}, 1, 1)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+    // a lane per node of the wide tree
+    let ordinal = gid.x;
+
+    // the binary tree's internal nodes come first, one fewer than there are leaves
+    let internal_count = leaf_count - 1u;
+
+    // every child node of the tree, which is every node of it but the root
+    let child_nodes = bvh8_encode_child_nodes(internal_count);
+
+    if (ordinal > child_nodes) {
+        return;
+    }
+
+    let node = bvh8_encode_wide_node(ordinal, internal_count);
+
+    let order_offset = BVH8_ENCODE_OUT_NODES + (1u + child_nodes) * BVH8_ENCODE_OUT_NODE_STRIDE;
+
+    // The root is node 0. Any other is a child of a wide node, in that node's block of child nodes,
+    // which starts after the root and every block before it.
+    var index = 0u;
+
+    if (node != 0u) {
+        let place = placement[node * PLACEMENT_STRIDE + PLACEMENT_PARENT];
+
+        index = 1u + bvh8_encode_child_nodes_before(place >> 3u) + (place & 7u);
+    }
+
+    bvh8_encode_write_node(
+        node,
+        internal_count,
+        placement[node * PLACEMENT_STRIDE + PLACEMENT_SLOTS],
+        index,
+        1u + bvh8_encode_child_nodes_before(node),
+        bvh8_encode_leaves_before(node, internal_count),
+        order_offset
+    );
+
+    if (node == 0u) {
+        bvh8_encode_write_header(leaf_count, order_offset);
+    }
+}
+`, [
+        chunk_bvh8_encode_sums,
+        chunk_bvh8_encode_node,
+    ]
+);
+
+/**
+ * Write the BVH8 — the last pass of {@link graph_bvh8_encode_from_bvh2} over more leaves than one
+ * workgroup takes.
+ *
+ * A lane per node of the wide tree, found as {@link shader_bvh8_encode_assign} finds it; the lane
+ * writes that node, the payloads of its leaves, and at the root the header. Where a node goes is its
+ * parent's block of child nodes, from the sums, and its rank there, from what the assign pass left
+ * it: no lane reads a word another writes.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_bvh8_encode_write = ComputeShader.from({
+    label: "BVH8Encode/Write",
+    resources,
+    body,
+});

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

@@ -0,0 +1,19 @@
+/**
+ * On-device verification of the BVH8 encode.
+ *
+ * For each of a set of leaf sets it builds the binary tree as the scene's is built
+ * (`graph_bvh_build_lbvh`), encodes it ({@link graph_bvh8_encode_from_bvh2}), reads both back, and
+ * holds the encoded tree to {@link bvh8_encode_from_bvh2} run over the binary tree the device built:
+ * every word of the header, the nodes and the payloads, and the words past them left alone. The
+ * counts sit either side of where the encode changes recording and of its workgroups' edges.
+ *
+ * It reports each tree's depth against what a walk's stack holds, and the per-pass GPU time of the
+ * build and the encode together at three counts: one workgroup's worth of leaves, one leaf more —
+ * the same work as many dispatches — and a hundred thousand.
+ *
+ * One graph and one submission per case, as `verify_gpu_bvh_build` has it.
+ *
+ * @param {GraphicsContext} graphics
+ */
+export function verify_gpu_bvh8_encode(graphics: GraphicsContext): void;
+//# sourceMappingURL=verify_gpu_bvh8_encode.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"verify_gpu_bvh8_encode.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/gpu_primitive/bvh8/verify_gpu_bvh8_encode.js"],"names":[],"mappings":"AA0MA;;;;;;;;;;;;;;;;GAgBG;AACH,wEAIC"}