@woosh/meep-engine 3.12.0 → 3.13.0

package/src/shade/renderer/geometry/bvh/shader_blas_refit_leaf_bounds.js

@@ -1,121 +1,125 @@
-import { f32, u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
-import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
-import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
-import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-import { ComputeShader } from "../../shader/ComputeShader.js";
-import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
-import {
-    BVH_NODE_BOUNDS_WORD,
-    BVH_NODE_CHILD_2_WORD,
-    BVH_NODE_STRIDE_WORDS
-} from "../../gpu_primitive/bvh/BVH_BUFFER_LAYOUT.js";
-import {
-    chunk_geometry_read_triangle_bounds
-} from "../../shader/chunk/geometry/format/chunk_geometry_read_triangle_bounds.js";
-import { GEOMETRY_METADATA_STRUCT } from "../GEOMETRY_METADATA_STRUCT.js";
-import { GEOMETRY_ATTRIBUTE_DATA_TYPE } from "../GEOMETRY_ATTRIBUTE_DATA_TYPE.js";
-import { MESHLET_METADATA_STRUCT } from "../meshlet/encoding/MESHLET_METADATA_STRUCT.js";
-
-export const BLAS_LEAF_BOUNDS_WORKGROUP_SIZE = 64;
-
-/**
- * Which tree, and where it lives.
- *
- * @type {WebGPUStruct}
- */
-export const BLAS_LEAF_BOUNDS_SETTINGS_STRUCT = WebGPUStruct.from({
-    /**
-     * Leaves in this tree — one triangle each, so also its triangle count.
-     */
-    leaf_count: u32,
-    /**
-     * u32 word the tree's node 0 starts at inside the shared node arena.
-     */
-    node_word_offset: u32,
-    /**
-     * Word this tree's leaf list starts at inside the shared leaf-node arena.
-     */
-    leaf_nodes_offset: u32,
-    /**
-     * Row in the geometry table whose meshlets the leaves index into. For a skinned mesh this is
-     * the per-instance clone, whose vertex region the skinning pass has already deformed — which is
-     * the entire point: the source's positions are the rest pose.
-     */
-    geometry_index: u32,
-}, "BlasLeafBoundsSettings");
-
-const resources = new ShaderResourceSetDescriptor();
-resources.createGroup()
-    .addUniform("settings", BLAS_LEAF_BOUNDS_SETTINGS_STRUCT)
-    // node index of each leaf ordinal, as tree construction published it
-    .addStorageBuffer("leaf_nodes", WebGPUArray.from(u32), false)
-    .addStorageBuffer("geometries", WebGPUArray.from(GEOMETRY_METADATA_STRUCT), false)
-    .addStorageBuffer("meshlet_metadata", WebGPUArray.from(MESHLET_METADATA_STRUCT), false)
-    .addStorageBuffer("meshlet_data", GEOMETRY_ATTRIBUTE_DATA_TYPE, false)
-    // the node arena, flat. Only leaf bounds are written, and a leaf is written by one thread.
-    .addStorageBuffer("nodes", WebGPUArray.from(f32), true);
-
-const body = CodeChunk.from(
-    //language=WGSL
-    `
-const NODE_STRIDE = ${BVH_NODE_STRIDE_WORDS}u;
-const NODE_BOUNDS = ${BVH_NODE_BOUNDS_WORD}u;
-const NODE_CHILD_2 = ${BVH_NODE_CHILD_2_WORD}u;
-
-@compute @workgroup_size(${BLAS_LEAF_BOUNDS_WORKGROUP_SIZE}, 1, 1)
-fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
-    let i = gid.x;
-
-    if (i >= settings.leaf_count) {
-        return;
-    }
-
-    let leaf_node = leaf_nodes[settings.leaf_nodes_offset + i];
-
-    let node_word = settings.node_word_offset + leaf_node * NODE_STRIDE;
-
-    // The leaf already says which triangle it holds — its payload is what the ray query hands to
-    // the triangle test. Reading it back means no side table has to agree with the tree about
-    // which leaf is which.
-    let meshlet_triangle_id = bitcast<u32>(nodes[node_word + NODE_CHILD_2]);
-
-    let bounds = geometry_read_triangle_bounds(
-        geometries[settings.geometry_index],
-        meshlet_triangle_id
-    );
-
-    nodes[node_word + NODE_BOUNDS] = bounds.min.x;
-    nodes[node_word + NODE_BOUNDS + 1u] = bounds.min.y;
-    nodes[node_word + NODE_BOUNDS + 2u] = bounds.min.z;
-    nodes[node_word + NODE_BOUNDS + 3u] = bounds.max.x;
-    nodes[node_word + NODE_BOUNDS + 4u] = bounds.max.y;
-    nodes[node_word + NODE_BOUNDS + 5u] = bounds.max.z;
-}
-`, [
-    chunk_geometry_read_triangle_bounds,
-]);
-
-/**
- * Recompute a BLAS's leaf bounds from the geometry's current vertex positions.
- *
- * The first half of a refit-only update, and the only half that knows what a triangle is: one
- * thread per leaf reads the triangle its node names, takes the AABB of that triangle as the vertex
- * buffer holds it *now*, and writes it into the node. {@link shader_bvh_refit} then carries those
- * bounds up the tree, unchanged from the TLAS build — topology is frozen, so there is nothing to
- * emit and nothing to sort.
- *
- * For a skinned mesh this runs against the per-instance clone, after the skinning pass has deformed
- * its vertex region. Reading the source instead would produce the rest pose, which is what a clone
- * without its own BLAS gets today.
- *
- * Plain (non-atomic) node access, unlike the refit: every leaf is written by exactly one thread and
- * read by nobody until the next dispatch, so there is no cross-workgroup communication here to
- * discipline.
- *
- * @type {ComputeShader}
- */
-export const shader_blas_refit_leaf_bounds = ComputeShader.from({
-    label: "BLAS/RefitLeafBounds",
-    resources,
-    body,
-});
+import { f32, u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import {
+    BVH_NODE_BOUNDS_WORD,
+    BVH_NODE_CHILD_2_WORD,
+    BVH_NODE_STRIDE_WORDS
+} from "../../gpu_primitive/bvh/BVH_BUFFER_LAYOUT.js";
+import {
+    chunk_geometry_read_triangle_bounds
+} from "../../shader/chunk/geometry/format/chunk_geometry_read_triangle_bounds.js";
+import { GEOMETRY_METADATA_STRUCT } from "../GEOMETRY_METADATA_STRUCT.js";
+import { GEOMETRY_ATTRIBUTE_DATA_TYPE } from "../GEOMETRY_ATTRIBUTE_DATA_TYPE.js";
+import { MESHLET_METADATA_STRUCT } from "../meshlet/encoding/MESHLET_METADATA_STRUCT.js";
+
+export const BLAS_LEAF_BOUNDS_WORKGROUP_SIZE = 64;
+
+/**
+ * Which tree, and where it lives.
+ *
+ * @type {WebGPUStruct}
+ */
+export const BLAS_LEAF_BOUNDS_SETTINGS_STRUCT = WebGPUStruct.from({
+    /**
+     * Leaves in this tree — one triangle each, so also its triangle count.
+     */
+    leaf_count: u32,
+    /**
+     * u32 word the tree's node 0 starts at inside the shared node arena.
+     */
+    node_word_offset: u32,
+    /**
+     * Word this tree's leaf list starts at inside the shared leaf-node arena.
+     */
+    leaf_nodes_offset: u32,
+    /**
+     * Row in the geometry table whose meshlets the leaves index into. For a skinned mesh this is
+     * the per-instance clone, whose vertex region the skinning pass has already deformed — which is
+     * the entire point: the source's positions are the rest pose.
+     */
+    geometry_index: u32,
+}, "BlasLeafBoundsSettings");
+
+const resources = new ShaderResourceSetDescriptor();
+
+// per-dispatch, 16 bytes, read-only: immediate data rather than a uniform buffer. Runs once per
+// skinned BLAS per frame, so the buffer it used to need was allocated that often too.
+resources.setImmediate("settings", BLAS_LEAF_BOUNDS_SETTINGS_STRUCT);
+
+resources.createGroup()
+    // node index of each leaf ordinal, as tree construction published it
+    .addStorageBuffer("leaf_nodes", WebGPUArray.from(u32), false)
+    .addStorageBuffer("geometries", WebGPUArray.from(GEOMETRY_METADATA_STRUCT), false)
+    .addStorageBuffer("meshlet_metadata", WebGPUArray.from(MESHLET_METADATA_STRUCT), false)
+    .addStorageBuffer("meshlet_data", GEOMETRY_ATTRIBUTE_DATA_TYPE, false)
+    // the node arena, flat. Only leaf bounds are written, and a leaf is written by one thread.
+    .addStorageBuffer("nodes", WebGPUArray.from(f32), true);
+
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+const NODE_STRIDE = ${BVH_NODE_STRIDE_WORDS}u;
+const NODE_BOUNDS = ${BVH_NODE_BOUNDS_WORD}u;
+const NODE_CHILD_2 = ${BVH_NODE_CHILD_2_WORD}u;
+
+@compute @workgroup_size(${BLAS_LEAF_BOUNDS_WORKGROUP_SIZE}, 1, 1)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+    let i = gid.x;
+
+    if (i >= settings.leaf_count) {
+        return;
+    }
+
+    let leaf_node = leaf_nodes[settings.leaf_nodes_offset + i];
+
+    let node_word = settings.node_word_offset + leaf_node * NODE_STRIDE;
+
+    // The leaf already says which triangle it holds — its payload is what the ray query hands to
+    // the triangle test. Reading it back means no side table has to agree with the tree about
+    // which leaf is which.
+    let meshlet_triangle_id = bitcast<u32>(nodes[node_word + NODE_CHILD_2]);
+
+    let bounds = geometry_read_triangle_bounds(
+        geometries[settings.geometry_index],
+        meshlet_triangle_id
+    );
+
+    nodes[node_word + NODE_BOUNDS] = bounds.min.x;
+    nodes[node_word + NODE_BOUNDS + 1u] = bounds.min.y;
+    nodes[node_word + NODE_BOUNDS + 2u] = bounds.min.z;
+    nodes[node_word + NODE_BOUNDS + 3u] = bounds.max.x;
+    nodes[node_word + NODE_BOUNDS + 4u] = bounds.max.y;
+    nodes[node_word + NODE_BOUNDS + 5u] = bounds.max.z;
+}
+`, [
+    chunk_geometry_read_triangle_bounds,
+]);
+
+/**
+ * Recompute a BLAS's leaf bounds from the geometry's current vertex positions.
+ *
+ * The first half of a refit-only update, and the only half that knows what a triangle is: one
+ * thread per leaf reads the triangle its node names, takes the AABB of that triangle as the vertex
+ * buffer holds it *now*, and writes it into the node. {@link shader_bvh_refit} then carries those
+ * bounds up the tree, unchanged from the TLAS build — topology is frozen, so there is nothing to
+ * emit and nothing to sort.
+ *
+ * For a skinned mesh this runs against the per-instance clone, after the skinning pass has deformed
+ * its vertex region. Reading the source instead would produce the rest pose, which is what a clone
+ * without its own BLAS gets today.
+ *
+ * Plain (non-atomic) node access, unlike the refit: every leaf is written by exactly one thread and
+ * read by nobody until the next dispatch, so there is no cross-workgroup communication here to
+ * discipline.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_blas_refit_leaf_bounds = ComputeShader.from({
+    label: "BLAS/RefitLeafBounds",
+    resources,
+    body,
+});

package/src/shade/renderer/geometry/meshlet/GPUMeshletManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUMeshletManager.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/meshlet/GPUMeshletManager.js"],"names":[],"mappings":"AAgEA;IAoEI;;;;;OAKG;IACH,sFAiCC;IAxFD,6BAEC;IAOD,iCAEC;IA+ED,gBAKC;IAED;;;;OAIG;IACH,sBAHW,MAAM,uBACN,MAAM,QAiDhB;IA+PD;;;;;;;;;;;OAWG;IACH,qBAJW,4BAA4B,GAE1B,OAAO,CAiBnB;IAED;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,+BAHW,4BAA4B,GAC1B,4BAA4B,CA8BxC;IAED;;;;;;;;;;;;OAYG;IACH,8CAmHC;IAED,gBAGC;IAED;;;;OAIG;IACH,gCAFa,4BAA4B,CA6BxC;IAED,mCASC;IAED,wCAQC;IAED,+BAYC;;CACJ;AAzuBD;IACI;;OAEG;IACH,qBAAQ;IACR;;OAEG;IACH,iBAAI;IAEJ;;;OAGG;IACH,WAFU,MAAM,CAEF;IAEd;;;OAGG;IACH,eAFU,MAAM,CAEE;IAElB;;;OAGG;IACH,0BAFU,WAAW,CAEI;IAEzB;;;OAGG;IACH,aAAsB;CACzB"}
+{"version":3,"file":"GPUMeshletManager.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/meshlet/GPUMeshletManager.js"],"names":[],"mappings":"AA+DA;IAoEI;;;;;OAKG;IACH,sFAiCC;IAxFD,6BAEC;IAOD,iCAEC;IA+ED,gBAKC;IAED;;;;OAIG;IACH,sBAHW,MAAM,uBACN,MAAM,QAiDhB;IA+PD;;;;;;;;;;;OAWG;IACH,qBAJW,4BAA4B,GAE1B,OAAO,CAiBnB;IAED;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,+BAHW,4BAA4B,GAC1B,4BAA4B,CA8BxC;IAED;;;;;;;;;;;;OAYG;IACH,8CA4GC;IAED,gBAGC;IAED;;;;OAIG;IACH,gCAFa,4BAA4B,CA6BxC;IAED,mCASC;IAED,wCAQC;IAED,+BAYC;;CACJ;AAluBD;IACI;;OAEG;IACH,qBAAQ;IACR;;OAEG;IACH,iBAAI;IAEJ;;;OAGG;IACH,WAFU,MAAM,CAEF;IAEd;;;OAGG;IACH,eAFU,MAAM,CAEE;IAElB;;;OAGG;IACH,0BAFU,WAAW,CAEI;IAEzB;;;OAGG;IACH,aAAsB;CACzB"}