@woosh/meep-engine 3.69.0 → 3.70.0

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

@@ -0,0 +1,97 @@
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { PREFIX_SCAN_CSDLDF_HEADER_WORDS } from "../prefix_sum/v1/shader_prefix_scan_csdldf.js";
+
+/**
+ * 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 = 3;
+
+/**
+ * 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.from(
+    //language=WGSL
+    `
+const BVH8_ENCODE_SUMS = ${PREFIX_SCAN_CSDLDF_HEADER_WORDS}u;
+
+fn bvh8_encode_child_nodes(internal_count: u32) -> u32 {
+    if (internal_count == 0u) {
+        // a tree that is one leaf is one node, with nothing counted for it
+        return 0u;
+    }
+
+    return sums[BVH8_ENCODE_SUMS + internal_count - 1u];
+}
+
+fn bvh8_encode_child_nodes_before(node: u32) -> u32 {
+    if (node == 0u) {
+        return 0u;
+    }
+
+    return sums[BVH8_ENCODE_SUMS + node - 1u];
+}
+
+// the leaves' sums follow the child nodes' and carry on from their total
+fn bvh8_encode_leaves_before(node: u32, internal_count: u32) -> u32 {
+    if (node == 0u) {
+        return 0u;
+    }
+
+    return sums[BVH8_ENCODE_SUMS + internal_count + node - 1u] - bvh8_encode_child_nodes(internal_count);
+}
+
+fn bvh8_encode_wide_node(ordinal: u32, internal_count: u32) -> u32 {
+    if (ordinal == 0u) {
+        // the root, whatever the tree
+        return 0u;
+    }
+
+    // the flags' sums follow the leaves' and carry on from theirs
+    let flags = BVH8_ENCODE_SUMS + 2u * internal_count;
+
+    // one more than the wide nodes at or before the one looked for
+    let wanted = sums[flags - 1u] + ordinal + 1u;
+
+    // the first node whose sum reaches it; a step halves what is left of a tree of at most 2^32 nodes
+    var low = 0u;
+    var high = internal_count - 1u;
+
+    for (var step = 0u; step < 32u && low < high; step++) {
+        let middle = (low + high) / 2u;
+
+        if (sums[flags + middle] >= wanted) {
+            high = middle;
+        } else {
+            low = middle + 1u;
+        }
+    }
+
+    return low;
+}
+`);

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

@@ -0,0 +1,49 @@
+/**
+ * @typedef {import("../../../device/pipeline/PipelineEnquiry.js").PipelineEnquiry} PipelineEnquiry
+ */
+/**
+ * Offer the pipelines {@link graph_bvh8_encode_from_bvh2} dispatches — see {@link PipelineEnquiry}.
+ *
+ * @param {PipelineEnquiry} enquiry
+ */
+export function enquire_bvh8_encode_pipelines(enquiry: PipelineEnquiry): void;
+/**
+ * Record the encode of a binary BVH as a BVH8, three binary levels to a node: what
+ * {@link bvh8_encode_from_bvh2} does, word for word, on the device.
+ *
+ * What a node of the wide tree holds, and where it goes, follows from counts of every internal node
+ * of the binary tree and their running sums ({@link chunk_bvh8_encode_sums}). Those are made in one
+ * of two ways, chosen by `leaf_count` and nothing else. Up to
+ * {@link BVH8_ENCODE_SINGLE_WORKGROUP_LEAVES} leaves, by one dispatch of one workgroup,
+ * {@link shader_bvh8_encode_count_single_workgroup}. Above, by four dispatches whatever the tree's
+ * depth: every internal node's parent ({@link shader_bvh8_encode_parents}), the counts
+ * ({@link shader_bvh8_encode_count}), and their sums (`graph_prefix_scan_csdldf`, two dispatches).
+ *
+ * Two dispatches follow either: the slots of each node's children ({@link shader_bvh8_encode_assign}),
+ * and the nodes ({@link shader_bvh8_encode_write}). Both take a lane per node of the wide tree, so
+ * that a lane with a node has no lane without one beside it to wait with.
+ *
+ * The binary tree is in the order `graph_bvh_build_lbvh` writes: `leaf_count - 1` internal nodes
+ * first, the root node 0, and it is fitted. It is at most `BVH8_ENCODE_MAX_BINARY_DEPTH` deep, which
+ * a tree of that builder is.
+ *
+ * `leaf_count` must be at least 1. A tree of no leaves is one empty node, which the caller writes
+ * host-side.
+ *
+ * @param {Object} options
+ * @param {FrameGraph} options.graph
+ * @param {number} options.tree buffer resource ID, the binary tree: `[root][nodes]` in the layout of
+ * {@link BVH_BUFFER_LAYOUT}
+ * @param {number} options.leaf_count leaves in the binary tree, at least 1
+ * @param {number} options.out buffer resource ID to write the BVH8 into, in the layout of
+ * {@link BVH8_TREE_BUFFER_LAYOUT}; at least `bvh8_tree_buffer_size(leaf_count)` bytes
+ * @returns {number} buffer resource ID of the written BVH8
+ */
+export function graph_bvh8_encode_from_bvh2({ graph, tree, leaf_count, out, }: {
+    graph: FrameGraph;
+    tree: number;
+    leaf_count: number;
+    out: number;
+}): number;
+export type PipelineEnquiry = import("../../../device/pipeline/PipelineEnquiry.js").PipelineEnquiry;
+//# sourceMappingURL=graph_bvh8_encode_from_bvh2.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"graph_bvh8_encode_from_bvh2.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/gpu_primitive/bvh8/graph_bvh8_encode_from_bvh2.js"],"names":[],"mappings":"AAqBA;;GAEG;AAEH;;;;GAIG;AACH,uDAFW,eAAe,QASzB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH;IAR+B,KAAK;IACT,IAAI,EAApB,MAAM;IAEU,UAAU,EAA1B,MAAM;IACU,GAAG,EAAnB,MAAM;IAEJ,MAAM,CAmMlB;8BAlPY,OAAO,6CAA6C,EAAE,eAAe"}

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

@@ -0,0 +1,265 @@
+import { assert } from "../../../../core/assert.js";
+import { round_up } from "../../../../core/math/round_up.js";
+import { BufferResourceDescriptor } from "../../../device/graph/BufferResourceDescriptor.js";
+import { graph_create_buffer } from "../../shader/graph/graph_create_buffer.js";
+import { bvh_buffer_size } from "../bvh/BVH_BUFFER_LAYOUT.js";
+import {
+    enquire_prefix_scan_csdldf_pipelines,
+    graph_prefix_scan_csdldf,
+    prefix_scan_csdldf_output_descriptor
+} from "../prefix_sum/v1/graph_prefix_scan_csdldf.js";
+import { bvh8_tree_buffer_size } from "./BVH8_TREE_BUFFER_LAYOUT.js";
+import { BVH8_ENCODE_COUNTS_PER_NODE } from "./chunk_bvh8_encode_sums.js";
+import { BVH8_ENCODE_PLACEMENT_STRIDE_WORDS, shader_bvh8_encode_assign } from "./shader_bvh8_encode_assign.js";
+import { shader_bvh8_encode_count } from "./shader_bvh8_encode_count.js";
+import { shader_bvh8_encode_parents } from "./shader_bvh8_encode_parents.js";
+import {
+    BVH8_ENCODE_SINGLE_WORKGROUP_LEAVES,
+    shader_bvh8_encode_count_single_workgroup
+} from "./shader_bvh8_encode_count_single_workgroup.js";
+import { shader_bvh8_encode_write } from "./shader_bvh8_encode_write.js";
+
+/**
+ * @typedef {import("../../../device/pipeline/PipelineEnquiry.js").PipelineEnquiry} PipelineEnquiry
+ */
+
+/**
+ * Offer the pipelines {@link graph_bvh8_encode_from_bvh2} dispatches — see {@link PipelineEnquiry}.
+ *
+ * @param {PipelineEnquiry} enquiry
+ */
+export function enquire_bvh8_encode_pipelines(enquiry) {
+    enquiry.compute.push(shader_bvh8_encode_count_single_workgroup.pipeline);
+    enquiry.compute.push(shader_bvh8_encode_parents.pipeline);
+    enquiry.compute.push(shader_bvh8_encode_count.pipeline);
+    enquire_prefix_scan_csdldf_pipelines(enquiry);
+    enquiry.compute.push(shader_bvh8_encode_assign.pipeline);
+    enquiry.compute.push(shader_bvh8_encode_write.pipeline);
+}
+
+/**
+ * Record the encode of a binary BVH as a BVH8, three binary levels to a node: what
+ * {@link bvh8_encode_from_bvh2} does, word for word, on the device.
+ *
+ * What a node of the wide tree holds, and where it goes, follows from counts of every internal node
+ * of the binary tree and their running sums ({@link chunk_bvh8_encode_sums}). Those are made in one
+ * of two ways, chosen by `leaf_count` and nothing else. Up to
+ * {@link BVH8_ENCODE_SINGLE_WORKGROUP_LEAVES} leaves, by one dispatch of one workgroup,
+ * {@link shader_bvh8_encode_count_single_workgroup}. Above, by four dispatches whatever the tree's
+ * depth: every internal node's parent ({@link shader_bvh8_encode_parents}), the counts
+ * ({@link shader_bvh8_encode_count}), and their sums (`graph_prefix_scan_csdldf`, two dispatches).
+ *
+ * Two dispatches follow either: the slots of each node's children ({@link shader_bvh8_encode_assign}),
+ * and the nodes ({@link shader_bvh8_encode_write}). Both take a lane per node of the wide tree, so
+ * that a lane with a node has no lane without one beside it to wait with.
+ *
+ * The binary tree is in the order `graph_bvh_build_lbvh` writes: `leaf_count - 1` internal nodes
+ * first, the root node 0, and it is fitted. It is at most `BVH8_ENCODE_MAX_BINARY_DEPTH` deep, which
+ * a tree of that builder is.
+ *
+ * `leaf_count` must be at least 1. A tree of no leaves is one empty node, which the caller writes
+ * host-side.
+ *
+ * @param {Object} options
+ * @param {FrameGraph} options.graph
+ * @param {number} options.tree buffer resource ID, the binary tree: `[root][nodes]` in the layout of
+ * {@link BVH_BUFFER_LAYOUT}
+ * @param {number} options.leaf_count leaves in the binary tree, at least 1
+ * @param {number} options.out buffer resource ID to write the BVH8 into, in the layout of
+ * {@link BVH8_TREE_BUFFER_LAYOUT}; at least `bvh8_tree_buffer_size(leaf_count)` bytes
+ * @returns {number} buffer resource ID of the written BVH8
+ */
+export function graph_bvh8_encode_from_bvh2({
+                                                graph,
+                                                tree,
+                                                leaf_count,
+                                                out,
+                                            }) {
+
+    assert.defined(graph, 'graph');
+    assert.isNonNegativeInteger(tree, 'tree');
+    assert.isNonNegativeInteger(out, 'out');
+    assert.isNonNegativeInteger(leaf_count, 'leaf_count');
+    assert.greaterThanOrEqual(leaf_count, 1, 'leaf_count — an empty tree is written host-side');
+
+    const tree_bytes = bvh_buffer_size(leaf_count);
+    const out_bytes = bvh8_tree_buffer_size(leaf_count);
+
+    const internal_count = leaf_count - 1;
+
+    // the assign and write passes are dispatched over the internal nodes, or the one leaf of a tree with none
+    const wide_lanes = Math.max(1, internal_count);
+
+    // Written for the nodes of the wide tree alone, which are the only ones it is read for.
+    const PLACEMENT_DESCRIPTOR = BufferResourceDescriptor.from(
+        round_up(wide_lanes * BVH8_ENCODE_PLACEMENT_STRIDE_WORDS * Uint32Array.BYTES_PER_ELEMENT, 1024),
+        GPUBufferUsage.STORAGE
+    );
+
+    // the counts of every internal node and their sums, both in the scan's own layout; every word read
+    // of either is written
+    const element_count = BVH8_ENCODE_COUNTS_PER_NODE * internal_count;
+
+    const COUNTS_DESCRIPTOR = prefix_scan_csdldf_output_descriptor(element_count);
+
+    /**
+     * @param pass_data
+     * @param {FramePassResources} resources
+     * @param {GraphicsExecutionContext} context
+     */
+    function execute_count_single_workgroup(pass_data, resources, context) {
+        const source = resources.get(pass_data.tree);
+
+        assert.greaterThanOrEqual(source.size, tree_bytes, 'binary tree buffer underflow');
+
+        shader_bvh8_encode_count_single_workgroup.dispatch({
+            encoder: context.encoder,
+            // one workgroup holds the whole of it
+            group_count_x: 1,
+            bindings: {
+                leaf_count,
+                tree: source,
+                sums: resources.get(pass_data.sums),
+            }
+        });
+    }
+
+    /**
+     * @param pass_data
+     * @param {FramePassResources} resources
+     * @param {GraphicsExecutionContext} context
+     */
+    function execute_parents(pass_data, resources, context) {
+        const source = resources.get(pass_data.tree);
+
+        assert.greaterThanOrEqual(source.size, tree_bytes, 'binary tree buffer underflow');
+
+        shader_bvh8_encode_parents.dispatchThreads({
+            encoder: context.encoder,
+            thread_count_x: internal_count,
+            bindings: {
+                leaf_count,
+                tree: source,
+                parents: resources.get(pass_data.parents),
+            }
+        });
+    }
+
+    /**
+     * @param pass_data
+     * @param {FramePassResources} resources
+     * @param {GraphicsExecutionContext} context
+     */
+    function execute_count(pass_data, resources, context) {
+        shader_bvh8_encode_count.dispatchThreads({
+            encoder: context.encoder,
+            thread_count_x: internal_count,
+            bindings: {
+                leaf_count,
+                tree: resources.get(pass_data.tree),
+                parents: resources.get(pass_data.parents),
+                counts: resources.get(pass_data.counts),
+            }
+        });
+    }
+
+    /**
+     * @param pass_data
+     * @param {FramePassResources} resources
+     * @param {GraphicsExecutionContext} context
+     */
+    function execute_assign(pass_data, resources, context) {
+        shader_bvh8_encode_assign.dispatchThreads({
+            encoder: context.encoder,
+            // the wide tree's nodes are fewer, by a count only the device has; the lanes past it return
+            thread_count_x: wide_lanes,
+            bindings: {
+                leaf_count,
+                tree: resources.get(pass_data.tree),
+                sums: resources.get(pass_data.sums),
+                placement: resources.get(pass_data.placement),
+            }
+        });
+    }
+
+    /**
+     * @param pass_data
+     * @param {FramePassResources} resources
+     * @param {GraphicsExecutionContext} context
+     */
+    function execute_write(pass_data, resources, context) {
+        const output = resources.get(pass_data.out);
+
+        assert.greaterThanOrEqual(output.size, out_bytes, 'BVH8 buffer underflow');
+
+        shader_bvh8_encode_write.dispatchThreads({
+            encoder: context.encoder,
+            // as the assign pass is dispatched
+            thread_count_x: wide_lanes,
+            bindings: {
+                leaf_count,
+                tree: resources.get(pass_data.tree),
+                sums: resources.get(pass_data.sums),
+                placement: resources.get(pass_data.placement),
+                out: output,
+            }
+        });
+    }
+
+    /** @type {number} */
+    let sums;
+
+    if (leaf_count <= BVH8_ENCODE_SINGLE_WORKGROUP_LEAVES) {
+        const count_data = {};
+        const count_pass = graph.add("bvh8 encode/count, single workgroup", count_data, execute_count_single_workgroup);
+
+        count_data.tree = count_pass.read(tree);
+        count_data.sums = count_pass.create("bvh8 encode/sums", COUNTS_DESCRIPTOR);
+
+        sums = count_data.sums;
+    } else {
+        // aligned on a 1k boundary to lower memory fragmentation, as the binary build's transients are
+        const PARENTS_DESCRIPTOR = BufferResourceDescriptor.from(
+            round_up(internal_count * Uint32Array.BYTES_PER_ELEMENT, 1024),
+            GPUBufferUsage.STORAGE
+        );
+
+        const parents_data = {};
+        const parents_pass = graph.add("bvh8 encode/parents", parents_data, execute_parents);
+
+        parents_data.tree = parents_pass.read(tree);
+        parents_data.parents = parents_pass.create("bvh8 encode/parents", PARENTS_DESCRIPTOR);
+
+        const count_data = {};
+        const count_pass = graph.add("bvh8 encode/count", count_data, execute_count);
+
+        count_data.tree = count_pass.read(tree);
+        count_data.parents = count_pass.read(parents_data.parents);
+        count_data.counts = count_pass.create("bvh8 encode/counts", COUNTS_DESCRIPTOR);
+
+        // the scan's output is a buffer of its own: it re-reads its input while it writes
+        sums = graph_prefix_scan_csdldf({
+            graph,
+            input: count_data.counts,
+            output: graph_create_buffer(graph, "bvh8 encode/sums", COUNTS_DESCRIPTOR),
+            element_max_count: element_count,
+        });
+    }
+
+    const assign_data = {};
+    const assign_pass = graph.add("bvh8 encode/assign", assign_data, execute_assign);
+
+    assign_data.tree = assign_pass.read(tree);
+    assign_data.sums = assign_pass.read(sums);
+    assign_data.placement = assign_pass.create("bvh8 encode/placement", PLACEMENT_DESCRIPTOR);
+
+    const write_data = {};
+    const write_pass = graph.add("bvh8 encode/write", write_data, execute_write);
+
+    write_data.tree = write_pass.read(tree);
+    write_data.sums = write_pass.read(sums);
+    write_data.placement = write_pass.read(assign_data.placement);
+    write_data.out = write_pass.write(out);
+
+    return write_data.out;
+}

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

@@ -0,0 +1,37 @@
+/**
+ * Words of `placement` an internal node of the binary tree has.
+ * @type {number}
+ */
+export const BVH8_ENCODE_PLACEMENT_STRIDE_WORDS: number;
+/**
+ * Of an internal node's `placement`, the word its own lane writes: the slot of each of its children,
+ * three bits a child.
+ *
+ * @type {number}
+ */
+export const BVH8_ENCODE_PLACEMENT_SLOTS_WORD: number;
+/**
+ * Of an internal node's `placement`, the word the lane of the wide node it is a child of writes:
+ * that node, times eight, and in the low three bits this node's rank among its child nodes.
+ *
+ * @type {number}
+ */
+export const BVH8_ENCODE_PLACEMENT_PARENT_WORD: number;
+/**
+ * The slots of every node of the wide tree's children — the pass of
+ * {@link graph_bvh8_encode_from_bvh2} between the scan and the write, over more leaves than one
+ * workgroup takes.
+ *
+ * A lane per node of the wide tree, which finds the node of the binary tree it stands for by its
+ * ordinal ({@link chunk_bvh8_encode_sums}): the dispatch covers the binary tree's internal nodes,
+ * and the lanes past the wide tree's node count return at once, whole workgroups of them.
+ *
+ * `placement` is written for the nodes of the wide tree alone: by a node's own lane the slots of its
+ * children, and by the lane of the node it is a child of, whose that is and its rank there. Each
+ * word has one writer, and the root has no second word.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_bvh8_encode_assign: ComputeShader;
+import { ComputeShader } from "../../shader/ComputeShader.js";
+//# sourceMappingURL=shader_bvh8_encode_assign.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shader_bvh8_encode_assign.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/gpu_primitive/bvh8/shader_bvh8_encode_assign.js"],"names":[],"mappings":"AASA;;;GAGG;AACH,iDAFU,MAAM,CAEoC;AAEpD;;;;;GAKG;AACH,+CAFU,MAAM,CAEkC;AAElD;;;;;GAKG;AACH,gDAFU,MAAM,CAEmC;AA4DnD;;;;;;;;;;;;;;GAcG;AACH,wCAFU,aAAa,CAMpB;8BA3G2B,+BAA+B"}

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

@@ -0,0 +1,109 @@
+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_assign } from "./chunk_bvh8_encode_assign.js";
+import { chunk_bvh8_encode_sums } from "./chunk_bvh8_encode_sums.js";
+import { BVH8_ENCODE_WORKGROUP_SIZE } from "./shader_bvh8_encode_parents.js";
+
+/**
+ * Words of `placement` an internal node of the binary tree has.
+ * @type {number}
+ */
+export const BVH8_ENCODE_PLACEMENT_STRIDE_WORDS = 2;
+
+/**
+ * Of an internal node's `placement`, the word its own lane writes: the slot of each of its children,
+ * three bits a child.
+ *
+ * @type {number}
+ */
+export const BVH8_ENCODE_PLACEMENT_SLOTS_WORD = 0;
+
+/**
+ * Of an internal node's `placement`, the word the lane of the wide node it is a child of writes:
+ * that node, times eight, and in the low three bits this node's rank among its child nodes.
+ *
+ * @type {number}
+ */
+export const BVH8_ENCODE_PLACEMENT_PARENT_WORD = 1;
+
+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)
+    // two words an internal node: the slots of its children, and its place in its parent
+    .addStorageBuffer("placement", 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;
+
+    // the root, and every child node
+    if (ordinal > bvh8_encode_child_nodes(internal_count)) {
+        return;
+    }
+
+    let node = bvh8_encode_wide_node(ordinal, internal_count);
+
+    let children = bvh8_encode_gather(node, internal_count);
+
+    let assignment = bvh8_encode_assign(node, children);
+
+    placement[node * PLACEMENT_STRIDE + PLACEMENT_SLOTS] = assignment.slots;
+
+    // each child node is told whose it is, and where it stands among that node's child nodes
+    for (var c = 0u; c < children.count; c++) {
+        if ((children.internal & (1u << c)) == 0u) {
+            continue;
+        }
+
+        let rank = bvh8_encode_rank(assignment.internal, bvh8_encode_slot_of(assignment.slots, c));
+
+        placement[children.nodes[c] * PLACEMENT_STRIDE + PLACEMENT_PARENT] = node * 8u + rank;
+    }
+}
+`, [
+        chunk_bvh8_encode_sums,
+        chunk_bvh8_encode_assign,
+    ]
+);
+
+/**
+ * The slots of every node of the wide tree's children — the pass of
+ * {@link graph_bvh8_encode_from_bvh2} between the scan and the write, over more leaves than one
+ * workgroup takes.
+ *
+ * A lane per node of the wide tree, which finds the node of the binary tree it stands for by its
+ * ordinal ({@link chunk_bvh8_encode_sums}): the dispatch covers the binary tree's internal nodes,
+ * and the lanes past the wide tree's node count return at once, whole workgroups of them.
+ *
+ * `placement` is written for the nodes of the wide tree alone: by a node's own lane the slots of its
+ * children, and by the lane of the node it is a child of, whose that is and its rank there. Each
+ * word has one writer, and the root has no second word.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_bvh8_encode_assign = ComputeShader.from({
+    label: "BVH8Encode/Assign",
+    resources,
+    body,
+});

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

@@ -0,0 +1,15 @@
+/**
+ * Which nodes of a binary tree become nodes of the wide one, and how many child nodes and how many
+ * leaves each will hold — the second pass of {@link graph_bvh8_encode_from_bvh2} over more leaves
+ * than one workgroup takes.
+ *
+ * A lane per internal node. `counts` is written whole, in the form `graph_prefix_scan_csdldf` takes:
+ * the child nodes of every internal node in node order, then the leaves of every one, then a one
+ * for every one that is a node of the wide tree; zeroes for a node that is not. What their running
+ * sums say is in {@link chunk_bvh8_encode_sums}.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_bvh8_encode_count: ComputeShader;
+import { ComputeShader } from "../../shader/ComputeShader.js";
+//# sourceMappingURL=shader_bvh8_encode_count.d.ts.map

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

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

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

@@ -0,0 +1,85 @@
+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 { 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";
+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; of a node this reads its two child words
+    .addStorageBuffer("tree", WebGPUArray.from(u32), false)
+    // a word an internal node
+    .addStorageBuffer("parents", WebGPUArray.from(u32), false)
+    // what the prefix scan takes: how many elements, then the elements
+    .addStorageBuffer("counts", WebGPUArray.from(u32), true);
+
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+const COUNTS = ${PREFIX_SCAN_CSDLDF_HEADER_WORDS}u;
+
+@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;
+    }
+
+    var child_nodes = 0u;
+    var leaves = 0u;
+    var wide = 0u;
+
+    if (bvh8_encode_depth(node) % BVH8_ENCODE_LEVELS == 0u) {
+        // a node of the wide tree
+        let children = bvh8_encode_gather(node, internal_count);
+
+        child_nodes = countOneBits(children.internal);
+        leaves = children.count - child_nodes;
+        wide = 1u;
+    }
+
+    // the counts of every node, a kind at a time end to end: one scan sums them all
+    counts[COUNTS + node] = child_nodes;
+    counts[COUNTS + internal_count + node] = leaves;
+    counts[COUNTS + 2u * internal_count + node] = wide;
+
+    if (node == 0u) {
+        counts[0] = ${BVH8_ENCODE_COUNTS_PER_NODE}u * internal_count;
+    }
+}
+`, [
+        chunk_bvh8_encode_depth,
+        chunk_bvh8_encode_gather,
+    ]
+);
+
+/**
+ * Which nodes of a binary tree become nodes of the wide one, and how many child nodes and how many
+ * leaves each will hold — the second pass of {@link graph_bvh8_encode_from_bvh2} over more leaves
+ * than one workgroup takes.
+ *
+ * A lane per internal node. `counts` is written whole, in the form `graph_prefix_scan_csdldf` takes:
+ * the child nodes of every internal node in node order, then the leaves of every one, then a one
+ * for every one that is a node of the wide tree; zeroes for a node that is not. What their running
+ * sums say is in {@link chunk_bvh8_encode_sums}.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_bvh8_encode_count = ComputeShader.from({
+    label: "BVH8Encode/Count",
+    resources,
+    body,
+});