@woosh/meep-engine 3.68.0 → 3.70.0

package/src/shade/renderer/gpu_primitive/bvh/BVH_BUFFER_LAYOUT.js

@@ -1,70 +1,70 @@
-import { assert } from "../../../../core/assert.js";
-import { BVH2_NODE_STRUCT } from "../../shader/chunk/bvh/BVH2_NODE_STRUCT.js";
-import { BVH_STRUCT } from "../../shader/chunk/bvh/BVH_STRUCT.js";
-
-/**
- * The BVH buffer's byte contract, resolved from the structs the traversal shaders read rather than
- * restated as literals — `.pack()` and WGSL layout rules decide these offsets, and a builder that
- * hard-codes them is one struct edit away from writing trees nothing can traverse.
- *
- * The layout every RT consumer depends on:
- *
- *   [u32 root][node 0][node 1] ... where a node is
- *   [min.x, min.y, min.z, max.x, max.y, max.z : f32][child_1 : u32][child_2 : u32]
- *
- * A node is a leaf exactly when `child_1 == BVH_NULL_NODE`, and then `child_2` carries the payload
- * (for the TLAS, a row in the scene database's `meshes` table). An internal node always has two
- * real children with meaningful bounds — the distance-ordered point queries dereference both before
- * descending, so a placeholder child is not an option.
- *
- * @see BVH2_NODE_STRUCT
- * @see BVH_STRUCT
- */
-
-/**
- * Words per node.
- * @type {number}
- */
-export const BVH_NODE_STRIDE_WORDS = BVH2_NODE_STRUCT.size / Uint32Array.BYTES_PER_ELEMENT;
-
-/**
- * Word offset of the node's six bounds floats, within the node.
- * @type {number}
- */
-export const BVH_NODE_BOUNDS_WORD = BVH2_NODE_STRUCT.get('bounds').offset / Uint32Array.BYTES_PER_ELEMENT;
-
-/**
- * Word offset of `child_1` within the node — the field whose `BVH_NULL_NODE` value means "leaf".
- * @type {number}
- */
-export const BVH_NODE_CHILD_1_WORD = BVH2_NODE_STRUCT.get('child_1').offset / Uint32Array.BYTES_PER_ELEMENT;
-
-/**
- * Word offset of `child_2` within the node — right child, or payload on a leaf.
- * @type {number}
- */
-export const BVH_NODE_CHILD_2_WORD = BVH2_NODE_STRUCT.get('child_2').offset / Uint32Array.BYTES_PER_ELEMENT;
-
-/**
- * Words the `root` header occupies in front of node 0. This is the `+ 4` in every sizing expression
- * in the tree.
- * @type {number}
- */
-export const BVH_HEADER_WORDS = BVH_STRUCT.get('nodes').offset / Uint32Array.BYTES_PER_ELEMENT;
-
-/**
- * Bytes a complete tree over `leaf_count` leaves occupies, header included.
- *
- * A Karras hierarchy over N leaves is exactly `2N - 1` nodes: `N - 1` internal and `N` leaves. One
- * leaf is the degenerate case — a single leaf node, no internal node at all.
- *
- * @param {number} leaf_count
- * @returns {number}
- */
-export function bvh_buffer_size(leaf_count) {
-    assert.isNonNegativeInteger(leaf_count, 'leaf_count');
-
-    const node_count = leaf_count === 0 ? 0 : 2 * leaf_count - 1;
-
-    return BVH_HEADER_WORDS * Uint32Array.BYTES_PER_ELEMENT + node_count * BVH2_NODE_STRUCT.size;
-}
+import { assert } from "../../../../core/assert.js";
+import { BVH2_NODE_STRUCT } from "../../shader/chunk/bvh/BVH2_NODE_STRUCT.js";
+import { BVH_STRUCT } from "../../shader/chunk/bvh/BVH_STRUCT.js";
+
+/**
+ * The BVH buffer's byte contract, resolved from the structs the traversal shaders read rather than
+ * restated as literals — `.pack()` and WGSL layout rules decide these offsets, and a builder that
+ * hard-codes them is one struct edit away from writing trees nothing can traverse.
+ *
+ * The layout every reader of a binary tree depends on:
+ *
+ *   [u32 root][node 0][node 1] ... where a node is
+ *   [min.x, min.y, min.z, max.x, max.y, max.z : f32][child_1 : u32][child_2 : u32]
+ *
+ * A node is a leaf exactly when `child_1 == BVH_NULL_NODE`, and then `child_2` carries the payload
+ * (for the tree over a scene's instances, a row in the scene database's `meshes` table). An internal node always has two
+ * real children with meaningful bounds — the distance-ordered point queries dereference both before
+ * descending, so a placeholder child is not an option.
+ *
+ * @see BVH2_NODE_STRUCT
+ * @see BVH_STRUCT
+ */
+
+/**
+ * Words per node.
+ * @type {number}
+ */
+export const BVH_NODE_STRIDE_WORDS = BVH2_NODE_STRUCT.size / Uint32Array.BYTES_PER_ELEMENT;
+
+/**
+ * Word offset of the node's six bounds floats, within the node.
+ * @type {number}
+ */
+export const BVH_NODE_BOUNDS_WORD = BVH2_NODE_STRUCT.get('bounds').offset / Uint32Array.BYTES_PER_ELEMENT;
+
+/**
+ * Word offset of `child_1` within the node — the field whose `BVH_NULL_NODE` value means "leaf".
+ * @type {number}
+ */
+export const BVH_NODE_CHILD_1_WORD = BVH2_NODE_STRUCT.get('child_1').offset / Uint32Array.BYTES_PER_ELEMENT;
+
+/**
+ * Word offset of `child_2` within the node — right child, or payload on a leaf.
+ * @type {number}
+ */
+export const BVH_NODE_CHILD_2_WORD = BVH2_NODE_STRUCT.get('child_2').offset / Uint32Array.BYTES_PER_ELEMENT;
+
+/**
+ * Words the `root` header occupies in front of node 0. This is the `+ 4` in every sizing expression
+ * in the tree.
+ * @type {number}
+ */
+export const BVH_HEADER_WORDS = BVH_STRUCT.get('nodes').offset / Uint32Array.BYTES_PER_ELEMENT;
+
+/**
+ * Bytes a complete tree over `leaf_count` leaves occupies, header included.
+ *
+ * A Karras hierarchy over N leaves is exactly `2N - 1` nodes: `N - 1` internal and `N` leaves. One
+ * leaf is the degenerate case — a single leaf node, no internal node at all.
+ *
+ * @param {number} leaf_count
+ * @returns {number}
+ */
+export function bvh_buffer_size(leaf_count) {
+    assert.isNonNegativeInteger(leaf_count, 'leaf_count');
+
+    const node_count = leaf_count === 0 ? 0 : 2 * leaf_count - 1;
+
+    return BVH_HEADER_WORDS * Uint32Array.BYTES_PER_ELEMENT + node_count * BVH2_NODE_STRUCT.size;
+}

package/src/shade/renderer/gpu_primitive/bvh/BVH_BUILD_SETTINGS_STRUCT.d.ts

@@ -1,10 +1,10 @@
 /**
  * `root_word_offset` value meaning "this tree has no root word".
  *
- * A TLAS buffer is `{root: u32, nodes: array<node>}` and every consumer reads that first word. A
- * BLAS has no header at all — its root is node 0 by convention, asserted on the way in at
- * `meshlet_batch_to_bvh` and relied on by `chunk_ray_query_blas_*`. One emission kernel serves
- * both, so "where does the root word go" has to include "nowhere".
+ * A tree that owns its buffer is `{root: u32, nodes: array<node>}`, and its readers take the root
+ * from that first word. A tree laid among others in a shared buffer has no header at all: its root
+ * is node 0 by convention. One emission kernel serves both, so "where does the root word go" has to
+ * include "nowhere".
  *
  * @type {number}
  */
@@ -17,9 +17,8 @@ export const BVH_NO_ROOT_WORD: number;
  * local to the tree.
  *
  * `node_word_offset` is where node 0 starts, in u32 words from the beginning of the bound buffer.
- * A TLAS owns its buffer and puts node 0 straight after the root word, so it passes 1. A BLAS lives
- * at some address inside a shared arena of every geometry's nodes, so it passes that address in
- * words. Keeping this a parameter rather than a constant is what lets one emission kernel and one
+ * A tree that owns its buffer puts node 0 straight after the root word, so it passes 1. One that
+ * lives at some address inside a shared arena passes that address in words. Keeping this a parameter rather than a constant is what lets one emission kernel and one
  * refit kernel serve a tree that owns its buffer and a tree that is a tenant in someone else's.
  *
  * `parents_offset` and `leaf_nodes_offset` say the same thing about the other two arrays the refit

package/src/shade/renderer/gpu_primitive/bvh/BVH_BUILD_SETTINGS_STRUCT.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BVH_BUILD_SETTINGS_STRUCT.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/gpu_primitive/bvh/BVH_BUILD_SETTINGS_STRUCT.js"],"names":[],"mappings":"AAGA;;;;;;;;;GASG;AACH,+BAFU,MAAM,CAE2B;AAE3C;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wCAFU,YAAY,CAQC;6BA3CM,mCAAmC"}
+{"version":3,"file":"BVH_BUILD_SETTINGS_STRUCT.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/gpu_primitive/bvh/BVH_BUILD_SETTINGS_STRUCT.js"],"names":[],"mappings":"AAGA;;;;;;;;;GASG;AACH,+BAFU,MAAM,CAE2B;AAE3C;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wCAFU,YAAY,CAQC;6BA1CM,mCAAmC"}

package/src/shade/renderer/gpu_primitive/bvh/BVH_BUILD_SETTINGS_STRUCT.js

@@ -4,10 +4,10 @@ import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
 /**
  * `root_word_offset` value meaning "this tree has no root word".
  *
- * A TLAS buffer is `{root: u32, nodes: array<node>}` and every consumer reads that first word. A
- * BLAS has no header at all — its root is node 0 by convention, asserted on the way in at
- * `meshlet_batch_to_bvh` and relied on by `chunk_ray_query_blas_*`. One emission kernel serves
- * both, so "where does the root word go" has to include "nowhere".
+ * A tree that owns its buffer is `{root: u32, nodes: array<node>}`, and its readers take the root
+ * from that first word. A tree laid among others in a shared buffer has no header at all: its root
+ * is node 0 by convention. One emission kernel serves both, so "where does the root word go" has to
+ * include "nowhere".
  *
  * @type {number}
  */
@@ -21,9 +21,8 @@ export const BVH_NO_ROOT_WORD = 0xffffffff;
  * local to the tree.
  *
  * `node_word_offset` is where node 0 starts, in u32 words from the beginning of the bound buffer.
- * A TLAS owns its buffer and puts node 0 straight after the root word, so it passes 1. A BLAS lives
- * at some address inside a shared arena of every geometry's nodes, so it passes that address in
- * words. Keeping this a parameter rather than a constant is what lets one emission kernel and one
+ * A tree that owns its buffer puts node 0 straight after the root word, so it passes 1. One that
+ * lives at some address inside a shared arena passes that address in words. Keeping this a parameter rather than a constant is what lets one emission kernel and one
  * refit kernel serve a tree that owns its buffer and a tree that is a tenant in someone else's.
  *
  * `parents_offset` and `leaf_nodes_offset` say the same thing about the other two arrays the refit

package/src/shade/renderer/gpu_primitive/bvh/graph_bvh_build_lbvh.d.ts

@@ -25,9 +25,9 @@ export function enquire_bvh_build_lbvh_pipelines(enquiry: PipelineEnquiry): void
  *
  * The output honours the format in {@link BVH_BUFFER_LAYOUT}: a `u32` root word, then `2N-1` nodes
  * with internal nodes at `[0, N-2]` (root = 0, by Karras's construction) and leaf `j` at `(N-1)+j`.
- * That ordering differs from the CPU path's slot-order-with-holes, which is legal because no
- * consumer reads node *order* — only the node format and the root word. It is also exactly the
- * BLAS convention (root at node 0), which is why the same recorder serves the geometry side later.
+ * That ordering differs from the CPU path's slot-order-with-holes, which is legal because no walk
+ * reads node *order* — only the node format and the root word. `graph_bvh8_encode_from_bvh2` does
+ * read it: there a node is internal by its index.
  *
  * `element_count` must be at least 1. A single leaf needs no special case on either path: there
  * is nothing to sort, emission skips the internal node and writes leaf 0 at node 0 with

package/src/shade/renderer/gpu_primitive/bvh/graph_bvh_build_lbvh.js

@@ -48,9 +48,9 @@ export function enquire_bvh_build_lbvh_pipelines(enquiry) {
  *
  * The output honours the format in {@link BVH_BUFFER_LAYOUT}: a `u32` root word, then `2N-1` nodes
  * with internal nodes at `[0, N-2]` (root = 0, by Karras's construction) and leaf `j` at `(N-1)+j`.
- * That ordering differs from the CPU path's slot-order-with-holes, which is legal because no
- * consumer reads node *order* — only the node format and the root word. It is also exactly the
- * BLAS convention (root at node 0), which is why the same recorder serves the geometry side later.
+ * That ordering differs from the CPU path's slot-order-with-holes, which is legal because no walk
+ * reads node *order* — only the node format and the root word. `graph_bvh8_encode_from_bvh2` does
+ * read it: there a node is internal by its index.
  *
  * `element_count` must be at least 1. A single leaf needs no special case on either path: there
  * is nothing to sort, emission skips the internal node and writes leaf 0 at node 0 with

package/src/shade/renderer/gpu_primitive/bvh/shader_bvh_build_single_workgroup.js

@@ -133,7 +133,7 @@ fn main(@builtin(local_invocation_index) thread_id: u32) {
     }
 
     if (thread_id == 0u) {
-        // see shader_bvh_emit_hierarchy: a BLAS has no root word and says so with NO_ROOT_WORD
+        // see shader_bvh_emit_hierarchy: a tree with no header says so with NO_ROOT_WORD
         if (settings.root_word_offset != NO_ROOT_WORD) {
             atomicStore(&nodes[settings.root_word_offset], 0u);
         }

package/src/shade/renderer/gpu_primitive/bvh/shader_bvh_emit_hierarchy.d.ts

@@ -5,8 +5,8 @@ export const BVH_EMIT_WORKGROUP_SIZE: 64;
  * `k` (root = 0), leaf `j` at node `(n-1)+j`, `2n-1` nodes in total.
  *
  * Node indices are local to the tree; where node 0 actually lands is `settings.node_word_offset`,
- * so the same kernel writes a TLAS that owns its buffer and a BLAS that is a tenant in a shared
- * arena. Root-at-node-0 is what both conventions want, which is why one kernel can serve them.
+ * so the same kernel writes a tree that owns its buffer and one that is a tenant in a shared
+ * arena. Root-at-node-0 is what both want, which is why one kernel can serve them.
  *
  * One dispatch of `n` threads with a tail `if`, which is the canonical LBVH formulation: thread `i`
  * always writes leaf `(n-1)+i`, and threads below `n-1` additionally wire internal node `i`'s two

package/src/shade/renderer/gpu_primitive/bvh/shader_bvh_emit_hierarchy.js

@@ -103,7 +103,7 @@ fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
 
     if (i == 0u) {
         // Constant by construction, but a tree whose format has a root word has consumers that read
-        // it. A BLAS has none — its root is node 0 by convention — and says so with NO_ROOT_WORD.
+        // it. A tree with no header — its root node 0 by convention — says so with NO_ROOT_WORD.
         if (settings.root_word_offset != NO_ROOT_WORD) {
             nodes[settings.root_word_offset] = 0u;
         }
@@ -124,8 +124,8 @@ fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
  * `k` (root = 0), leaf `j` at node `(n-1)+j`, `2n-1` nodes in total.
  *
  * Node indices are local to the tree; where node 0 actually lands is `settings.node_word_offset`,
- * so the same kernel writes a TLAS that owns its buffer and a BLAS that is a tenant in a shared
- * arena. Root-at-node-0 is what both conventions want, which is why one kernel can serve them.
+ * so the same kernel writes a tree that owns its buffer and one that is a tenant in a shared
+ * arena. Root-at-node-0 is what both want, which is why one kernel can serve them.
  *
  * One dispatch of `n` threads with a tail `if`, which is the canonical LBVH formulation: thread `i`
  * always writes leaf `(n-1)+i`, and threads below `n-1` additionally wire internal node `i`'s two

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

@@ -0,0 +1,69 @@
+/**
+ * The most nodes a tree over `leaf_count` leaves can have. A node of the tree stands for an internal
+ * node of the binary tree it is encoded from, of which there are one fewer than leaves; a tree of
+ * one leaf, or none, is still one node.
+ *
+ * @param {number} leaf_count
+ * @returns {number}
+ */
+export function bvh8_tree_node_capacity(leaf_count: number): number;
+/**
+ * Bytes that hold any tree over `leaf_count` leaves: the header, as many nodes as such a tree can
+ * have, and a payload a leaf, to a whole `vec4<u32>`.
+ *
+ * @param {number} leaf_count
+ * @returns {number}
+ */
+export function bvh8_tree_buffer_size(leaf_count: number): number;
+/**
+ * The byte contract of a BVH8 that owns its buffer: a tree over leaves that each carry a payload,
+ * as the top-level structure over a scene's instances is.
+ *
+ *     [low.x, low.y, low.z : f32][leaf_count : u32][high.x, high.y, high.z : f32][order_offset : u32]
+ *     [node 0][node 1] ...                 BVH8_INODE_STRUCT each, the root first
+ *     [payload][payload] ...               a u32 a leaf, from word `order_offset`
+ *
+ * The header's box is the box of everything in the tree. A node keeps its slots' boxes and not its
+ * own, so the root's has nowhere else to be.
+ *
+ * A leaf slot of a node holds one leaf, and names it as a run of one: its payload is at
+ * `order_offset + base_index_triangle + offset`, the offset in the slot's meta. The payloads of a
+ * node's leaf slots sit together there, in slot order.
+ *
+ * A tree of no leaves is a header that counts none and one node with every slot empty: a walk
+ * starts at node 0 without asking, and finds nothing there.
+ *
+ * Every part is a whole number of `vec4<u32>`, so the buffer binds as `array<vec4<u32>>`: a node is
+ * five of them, and `order_offset` a multiple of four.
+ */
+/**
+ * Words of header in front of node 0.
+ * @type {number}
+ */
+export const BVH8_TREE_HEADER_WORDS: number;
+/**
+ * Word of the header the tree's low corner starts at; three floats.
+ * @type {number}
+ */
+export const BVH8_TREE_BOUNDS_LOW_WORD: number;
+/**
+ * Word of the header that counts the tree's leaves.
+ * @type {number}
+ */
+export const BVH8_TREE_LEAF_COUNT_WORD: number;
+/**
+ * Word of the header the tree's high corner starts at; three floats.
+ * @type {number}
+ */
+export const BVH8_TREE_BOUNDS_HIGH_WORD: number;
+/**
+ * Word of the header that says which word of the buffer the payloads start at.
+ * @type {number}
+ */
+export const BVH8_TREE_ORDER_OFFSET_WORD: number;
+/**
+ * Words a node takes.
+ * @type {number}
+ */
+export const BVH8_TREE_NODE_STRIDE_WORDS: number;
+//# sourceMappingURL=BVH8_TREE_BUFFER_LAYOUT.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"BVH8_TREE_BUFFER_LAYOUT.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/gpu_primitive/bvh8/BVH8_TREE_BUFFER_LAYOUT.js"],"names":[],"mappings":"AA6DA;;;;;;;GAOG;AACH,oDAHW,MAAM,GACJ,MAAM,CAMlB;AAED;;;;;;GAMG;AACH,kDAHW,MAAM,GACJ,MAAM,CAQlB;AArFD;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH;;;GAGG;AACH,qCAFU,MAAM,CAEwB;AAExC;;;GAGG;AACH,wCAFU,MAAM,CAE2B;AAE3C;;;GAGG;AACH,wCAFU,MAAM,CAE2B;AAE3C;;;GAGG;AACH,yCAFU,MAAM,CAE4B;AAE5C;;;GAGG;AACH,0CAFU,MAAM,CAE6B;AAE7C;;;GAGG;AACH,0CAFU,MAAM,CAEkF"}

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

@@ -0,0 +1,89 @@
+import { assert } from "../../../../core/assert.js";
+import { BVH8_INODE_STRUCT } from "../../shader/chunk/bvh/bvh8/webgpu/BVH8_INODE_STRUCT.js";
+
+/**
+ * The byte contract of a BVH8 that owns its buffer: a tree over leaves that each carry a payload,
+ * as the top-level structure over a scene's instances is.
+ *
+ *     [low.x, low.y, low.z : f32][leaf_count : u32][high.x, high.y, high.z : f32][order_offset : u32]
+ *     [node 0][node 1] ...                 BVH8_INODE_STRUCT each, the root first
+ *     [payload][payload] ...               a u32 a leaf, from word `order_offset`
+ *
+ * The header's box is the box of everything in the tree. A node keeps its slots' boxes and not its
+ * own, so the root's has nowhere else to be.
+ *
+ * A leaf slot of a node holds one leaf, and names it as a run of one: its payload is at
+ * `order_offset + base_index_triangle + offset`, the offset in the slot's meta. The payloads of a
+ * node's leaf slots sit together there, in slot order.
+ *
+ * A tree of no leaves is a header that counts none and one node with every slot empty: a walk
+ * starts at node 0 without asking, and finds nothing there.
+ *
+ * Every part is a whole number of `vec4<u32>`, so the buffer binds as `array<vec4<u32>>`: a node is
+ * five of them, and `order_offset` a multiple of four.
+ */
+
+/**
+ * Words of header in front of node 0.
+ * @type {number}
+ */
+export const BVH8_TREE_HEADER_WORDS = 8;
+
+/**
+ * Word of the header the tree's low corner starts at; three floats.
+ * @type {number}
+ */
+export const BVH8_TREE_BOUNDS_LOW_WORD = 0;
+
+/**
+ * Word of the header that counts the tree's leaves.
+ * @type {number}
+ */
+export const BVH8_TREE_LEAF_COUNT_WORD = 3;
+
+/**
+ * Word of the header the tree's high corner starts at; three floats.
+ * @type {number}
+ */
+export const BVH8_TREE_BOUNDS_HIGH_WORD = 4;
+
+/**
+ * Word of the header that says which word of the buffer the payloads start at.
+ * @type {number}
+ */
+export const BVH8_TREE_ORDER_OFFSET_WORD = 7;
+
+/**
+ * Words a node takes.
+ * @type {number}
+ */
+export const BVH8_TREE_NODE_STRIDE_WORDS = BVH8_INODE_STRUCT.size / Uint32Array.BYTES_PER_ELEMENT;
+
+/**
+ * The most nodes a tree over `leaf_count` leaves can have. A node of the tree stands for an internal
+ * node of the binary tree it is encoded from, of which there are one fewer than leaves; a tree of
+ * one leaf, or none, is still one node.
+ *
+ * @param {number} leaf_count
+ * @returns {number}
+ */
+export function bvh8_tree_node_capacity(leaf_count) {
+    assert.isNonNegativeInteger(leaf_count, 'leaf_count');
+
+    return Math.max(1, leaf_count - 1);
+}
+
+/**
+ * Bytes that hold any tree over `leaf_count` leaves: the header, as many nodes as such a tree can
+ * have, and a payload a leaf, to a whole `vec4<u32>`.
+ *
+ * @param {number} leaf_count
+ * @returns {number}
+ */
+export function bvh8_tree_buffer_size(leaf_count) {
+    const words = BVH8_TREE_HEADER_WORDS
+        + bvh8_tree_node_capacity(leaf_count) * BVH8_TREE_NODE_STRIDE_WORDS
+        + Math.ceil(leaf_count / 4) * 4;
+
+    return words * Uint32Array.BYTES_PER_ELEMENT;
+}

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

@@ -0,0 +1,41 @@
+/**
+ * Encode a binary BVH as a BVH8, three binary levels to a node. The reference for the passes that do
+ * it on the GPU: they are held to this, word for word.
+ *
+ * **Which nodes.** An internal node of the binary tree whose depth is a multiple of three becomes a
+ * node of the wide tree; the root is at depth 0. Its children are what lies three levels below it,
+ * and the leaves met sooner: at most eight, taken child 1 before child 2 all the way down. One of
+ * them that is internal is itself at a depth that is a multiple of three, so it is a node too; one
+ * that is a leaf fills a leaf slot. A binary tree that is a single leaf is one node with that leaf
+ * in a slot.
+ *
+ * **Which slots.** A node's children are given its slots by {@link bvh8_assign_slots_greedy}: a
+ * child costs a slot the distance its box's centre lies from the node's centre, taken with the
+ * slot's signs — the bit of an axis set where the child should lie high on it. The cost is worked
+ * in single precision as `(±x + ±y) + ±z`, where an axis's term is the child's `low + high` less the
+ * node's. A child whose box is not a number costs nothing a comparison can rank: it takes the lowest
+ * slot left once the others have theirs, so that a tree's shape never depends on what its boxes hold.
+ *
+ * **Where.** Counting a node's child nodes and its leaves, in the order of the binary tree's own
+ * node indices: a node's child nodes are the block that starts at one more than the child nodes of
+ * every node before it, in slot order; its leaves' payloads are the run that starts at the leaves
+ * of every node before it, in slot order. The root is node 0. So a node finds its own place from
+ * its parent's block and the slot it has there, with no word from the parent.
+ *
+ * **Boxes.** A node's box is the binary node's, and its slots are fitted to it by
+ * {@link bvh8_node_fit_slots}.
+ *
+ * @param {Uint32Array} out the BVH8, in the layout of {@link BVH8_TREE_BUFFER_LAYOUT}; at least
+ * `bvh8_tree_buffer_size(leaf_count) / 4` words. Words past the tree written are left as they are.
+ * @param {Uint32Array} tree the binary tree as u32 words, `[root][node 0][node 1] ...`, in the layout
+ * of {@link BVH_BUFFER_LAYOUT}: `2 * leaf_count - 1` nodes, fitted
+ * @param {number} leaf_count
+ * @returns {number} nodes in the BVH8
+ */
+export function bvh8_encode_from_bvh2(out: Uint32Array, tree: Uint32Array, leaf_count: number): number;
+/**
+ * Binary levels a node of the wide tree stands for.
+ * @type {number}
+ */
+export const BVH8_ENCODE_LEVELS: number;
+//# sourceMappingURL=bvh8_encode_from_bvh2.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bvh8_encode_from_bvh2.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/gpu_primitive/bvh8/bvh8_encode_from_bvh2.js"],"names":[],"mappings":"AAgCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,2CAPW,WAAW,QAEX,WAAW,cAEX,MAAM,GACJ,MAAM,CA2RlB;AAjUD;;;GAGG;AACH,iCAFU,MAAM,CAEoB"}