@woosh/meep-engine 3.12.0 → 3.13.1

package/src/shade/renderer/animation/skinning/bounds_refresh/shader_meshlet_bounds_reduce.js

@@ -1,212 +1,215 @@
-import { atomic_u32, u32 } from "../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
-import { WebGPUArray } from "../../../shader/type/WebGPUArray.js";
-import { GEOMETRY_METADATA_STRUCT } from "../../../geometry/GEOMETRY_METADATA_STRUCT.js";
-import { MESHLET_METADATA_STRUCT } from "../../../geometry/meshlet/encoding/MESHLET_METADATA_STRUCT.js";
-import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
-import { ComputeShader } from "../../../shader/ComputeShader.js";
-import { ShaderResourceSetDescriptor } from "../../../shader/resource/ShaderResourceSetDescriptor.js";
-import { SKINNING_BINDING_STRUCT } from "../SKINNING_BINDING_STRUCT.js";
-import { chunk_aabb_atomic_f32 } from "./chunk_aabb_atomic_f32.js";
-
-/**
- * Workgroup size — also the per-meshlet vertex stride. One thread per
- * vertex slot per pass; threads loop by `WORKGROUP_SIZE` for meshlets
- * with `vertex_count > WORKGROUP_SIZE`.
- *
- * Matches the skinning compute shader's WG size so the reduction's
- * memory-access pattern is roughly analogous (sequential vertex reads).
- */
-export const WORKGROUP_SIZE = 64;
-
-// Field offsets resolved at module-load. `.pack()` on the structs
-// reorders fields by alignment, so reading offsets directly off the
-// struct is the only way to be sure these match what the rasterizer
-// expects to read back later.
-const MESHLET_BOUNDS_OFFSET_WORDS = MESHLET_METADATA_STRUCT.get('bounds_box').offset / 4;
-const MESHLET_ADDRESS_OFFSET_WORDS = MESHLET_METADATA_STRUCT.get('address').offset / 4;
-const MESHLET_VERTEX_COUNT_OFFSET_WORDS = MESHLET_METADATA_STRUCT.get('vertex_count').offset / 4;
-const MESHLET_PRIMITIVE_COUNT_OFFSET_WORDS = MESHLET_METADATA_STRUCT.get('primitive_count').offset / 4;
-const MESHLET_STRIDE_WORDS = MESHLET_METADATA_STRUCT.size / 4;
-
-const GEOMETRY_BBOX_OFFSET_WORDS = GEOMETRY_METADATA_STRUCT.get('bounding_box').offset / 4;
-const GEOMETRY_STRIDE_WORDS = GEOMETRY_METADATA_STRUCT.size / 4;
-
-const resources = new ShaderResourceSetDescriptor();
-resources.createGroup()
-    // First-workgroup offset in this sub-dispatch (workgroup units).
-    // One workgroup per pair, so this matches the skinning shader's
-    // `dispatch_offset` semantic.
-    .addUniform('dispatch_offset', u32)
-    .addStorageBuffer('skinning_bindings', WebGPUArray.from(SKINNING_BINDING_STRUCT), false)
-    .addStorageBuffer('dispatch_lookup', WebGPUArray.from(u32), false)
-    // Clone vertex data: positions live at `address + index_section_size`
-    // (see `chunk_meshlet_compute_attribute_section_offset`). Read-only
-    // here — the skinning compute already wrote the deformed positions
-    // before this pass runs.
-    .addStorageBuffer('meshlet_data', WebGPUArray.from(u32), false)
-    // Same buffer the rasterizer reads as typed structs, bound here as
-    // a flat `atomic<u32>` array. We atomicLoad meshlet header fields
-    // (address / vertex_count / primitive_count) and atomic-merge the
-    // computed bounds into `bounds_box`.
-    .addStorageBuffer('meshlet_metadata_atomic', WebGPUArray.from(atomic_u32), true)
-    .addStorageBuffer('geometry_metadata_atomic', WebGPUArray.from(atomic_u32), true);
-
-const body = CodeChunk.from(
-    //language=WGSL
-    `
-const MESHLET_BOUNDS_OFFSET: u32         = ${MESHLET_BOUNDS_OFFSET_WORDS}u;
-const MESHLET_ADDRESS_OFFSET: u32        = ${MESHLET_ADDRESS_OFFSET_WORDS}u;
-const MESHLET_VERTEX_COUNT_OFFSET: u32   = ${MESHLET_VERTEX_COUNT_OFFSET_WORDS}u;
-const MESHLET_PRIMITIVE_COUNT_OFFSET: u32 = ${MESHLET_PRIMITIVE_COUNT_OFFSET_WORDS}u;
-const MESHLET_STRIDE: u32                = ${MESHLET_STRIDE_WORDS}u;
-const GEOMETRY_BBOX_OFFSET: u32          = ${GEOMETRY_BBOX_OFFSET_WORDS}u;
-const GEOMETRY_STRIDE: u32               = ${GEOMETRY_STRIDE_WORDS}u;
-
-// Workgroup-shared reduction storage. Each thread parks its
-// per-vertex-strip min/max here for tree reduction. Sized to the
-// workgroup width.
-var<workgroup> wg_min: array<vec3<f32>, ${WORKGROUP_SIZE}>;
-var<workgroup> wg_max: array<vec3<f32>, ${WORKGROUP_SIZE}>;
-
-@compute @workgroup_size(${WORKGROUP_SIZE},1,1)
-fn main(
-    @builtin(workgroup_id) wg_id: vec3<u32>,
-    @builtin(local_invocation_index) local_id: u32,
-) {
-    let pair_index = wg_id.x + dispatch_offset;
-
-    let lookup_base = pair_index * 2u;
-    let binding_index = dispatch_lookup[lookup_base];
-    let meshlet_local = dispatch_lookup[lookup_base + 1u];
-
-    let binding = skinning_bindings[binding_index];
-    let clone_meshlet_abs = binding.clone_meshlet_metadata_offset + meshlet_local;
-    let m_base_words = clone_meshlet_abs * MESHLET_STRIDE;
-
-    // Meshlet header reads — atomicLoad because the buffer is bound
-    // atomic-typed. These values are stable across the pass (the
-    // scatter pass only resets bounds_box, not the header), so reads
-    // are uniform-control-flow safe.
-    let address         = atomicLoad(&meshlet_metadata_atomic[m_base_words + MESHLET_ADDRESS_OFFSET]);
-    let primitive_count = atomicLoad(&meshlet_metadata_atomic[m_base_words + MESHLET_PRIMITIVE_COUNT_OFFSET]);
-    let vertex_count    = atomicLoad(&meshlet_metadata_atomic[m_base_words + MESHLET_VERTEX_COUNT_OFFSET]);
-
-    // Attribute section base = address + index_section_size, where
-    // index_section_size = ceil(primitive_count * 3 / 4) u32 words.
-    // Position is the first attribute at offset 0 within the section,
-    // stored as 3 contiguous f32s per vertex. Matches the skinning
-    // shader's clone-write addressing.
-    let index_section_size = (primitive_count * 3u + 3u) >> 2u;
-    let attribute_section = address + index_section_size;
-
-    // Per-thread min/max accumulators. WGSL disallows the const
-    // expression \`bitcast<f32>(0x7F800000u)\` because the resulting
-    // \`f32\` is not representable as a literal (it's ±inf). We use
-    // the largest finite f32 instead — for our purposes (vertex
-    // positions, well-bounded in metres), it's effectively infinite:
-    // any real vertex coordinate is many orders of magnitude
-    // smaller, so the merge math is identical.
-    //
-    // Note that the storage sentinels in \`meshlet.bounds_box\` and
-    // \`geometry.bounding_box\` ARE true ±inf — the scatter pass
-    // writes the u32 bit pattern directly via \`atomicStore\`, no
-    // const-fold involved, and \`aabb_atomic_min_f32\` bitcasts
-    // back to f32 at runtime where ±inf is a valid value.
-    var thread_min = vec3<f32>( 3.4028234e38);
-    var thread_max = vec3<f32>(-3.4028234e38);
-
-    // Stride loop over the meshlet's vertex slots. Most meshlets fit
-    // in a single WG_SIZE pass; larger ones cycle.
-    var v: u32 = local_id;
-    loop {
-        if v >= vertex_count { break; }
-        let pos_addr = attribute_section + v * 3u;
-        let p = vec3<f32>(
-            bitcast<f32>(meshlet_data[pos_addr]),
-            bitcast<f32>(meshlet_data[pos_addr + 1u]),
-            bitcast<f32>(meshlet_data[pos_addr + 2u]),
-        );
-        thread_min = min(thread_min, p);
-        thread_max = max(thread_max, p);
-        v = v + ${WORKGROUP_SIZE}u;
-    }
-
-    // Power-of-2 tree reduction in workgroup memory. WG_SIZE = 64 is
-    // a power of two, so the standard halving stride works with no
-    // tail handling. Subgroup ops would be a bit faster but require
-    // the "subgroups" extension; this works on every device.
-    wg_min[local_id] = thread_min;
-    wg_max[local_id] = thread_max;
-    workgroupBarrier();
-
-    var stride: u32 = ${WORKGROUP_SIZE >>> 1}u;
-    loop {
-        if stride == 0u { break; }
-        if local_id < stride {
-            wg_min[local_id] = min(wg_min[local_id], wg_min[local_id + stride]);
-            wg_max[local_id] = max(wg_max[local_id], wg_max[local_id + stride]);
-        }
-        workgroupBarrier();
-        stride = stride >> 1u;
-    }
-
-    // Thread 0 owns the writes. Atomic-merge into both the meshlet's
-    // own bounds_box (single contributor per meshlet — could be
-    // atomicStore, but using min/max keeps the scatter's sentinel as
-    // the identity element and means a re-run is idempotent) AND into
-    // the binding's clone geometry's bounding_box (cross-workgroup
-    // contention — CAS-spin handles it).
-    if local_id == 0u {
-        let final_min = wg_min[0];
-        let final_max = wg_max[0];
-
-        let m_bounds_base = m_base_words + MESHLET_BOUNDS_OFFSET;
-        aabb_atomic_min_f32(&meshlet_metadata_atomic[m_bounds_base + 0u], final_min.x);
-        aabb_atomic_min_f32(&meshlet_metadata_atomic[m_bounds_base + 1u], final_min.y);
-        aabb_atomic_min_f32(&meshlet_metadata_atomic[m_bounds_base + 2u], final_min.z);
-        aabb_atomic_max_f32(&meshlet_metadata_atomic[m_bounds_base + 3u], final_max.x);
-        aabb_atomic_max_f32(&meshlet_metadata_atomic[m_bounds_base + 4u], final_max.y);
-        aabb_atomic_max_f32(&meshlet_metadata_atomic[m_bounds_base + 5u], final_max.z);
-
-        let g_base = binding.clone_geometry_index * GEOMETRY_STRIDE + GEOMETRY_BBOX_OFFSET;
-        aabb_atomic_min_f32(&geometry_metadata_atomic[g_base + 0u], final_min.x);
-        aabb_atomic_min_f32(&geometry_metadata_atomic[g_base + 1u], final_min.y);
-        aabb_atomic_min_f32(&geometry_metadata_atomic[g_base + 2u], final_min.z);
-        aabb_atomic_max_f32(&geometry_metadata_atomic[g_base + 3u], final_max.x);
-        aabb_atomic_max_f32(&geometry_metadata_atomic[g_base + 4u], final_max.y);
-        aabb_atomic_max_f32(&geometry_metadata_atomic[g_base + 5u], final_max.z);
-    }
-}
-`, [chunk_aabb_atomic_f32]);
-
-/**
- * Compute shader that reduces a clone meshlet's deformed vertex
- * positions to a tight AABB, atomic-writes the result to the meshlet's
- * `bounds_box`, and atomic-merges the same bounds into the owning
- * clone geometry's `bounding_box`.
- *
- * Workgroup-per-pair dispatch: one workgroup per (binding, meshlet)
- * row in `dispatch_lookup`. Each thread handles a stride of vertices,
- * the workgroup reduces via shared memory + tree halving, and thread 0
- * commits the result.
- *
- * The geometry-level merge is what lets the rasterizer's per-geometry
- * sphere/AABB culling use post-deformation bounds without a second
- * full pass — the sphere derive shader downstream just reads the
- * accumulated `bounding_box` and computes its surrounding sphere.
- *
- * Must run AFTER `shader_meshlet_apply_skinning` (which writes the
- * deformed positions this pass reads) and AFTER
- * `shader_meshlet_bounds_scatter` (which seeds the meshlet and
- * geometry bounds with ±inf sentinels).
- *
- * Pagination: with one workgroup per pair, the host splits into
- * multiple sub-dispatches when `total_pair_count >
- * maxComputeWorkgroupsPerDimension`. The `dispatch_offset` uniform
- * advances per sub-dispatch.
- */
-export const shader_meshlet_bounds_reduce = ComputeShader.from({
-    label: "Skinning/MeshletBoundsReduce",
-    resources,
-    body,
-});
+import { atomic_u32, u32 } from "../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../../../shader/type/WebGPUArray.js";
+import { GEOMETRY_METADATA_STRUCT } from "../../../geometry/GEOMETRY_METADATA_STRUCT.js";
+import { MESHLET_METADATA_STRUCT } from "../../../geometry/meshlet/encoding/MESHLET_METADATA_STRUCT.js";
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../../../shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../../../shader/resource/ShaderResourceSetDescriptor.js";
+import { SKINNING_BINDING_STRUCT } from "../SKINNING_BINDING_STRUCT.js";
+import { chunk_aabb_atomic_f32 } from "./chunk_aabb_atomic_f32.js";
+
+/**
+ * Workgroup size — also the per-meshlet vertex stride. One thread per
+ * vertex slot per pass; threads loop by `WORKGROUP_SIZE` for meshlets
+ * with `vertex_count > WORKGROUP_SIZE`.
+ *
+ * Matches the skinning compute shader's WG size so the reduction's
+ * memory-access pattern is roughly analogous (sequential vertex reads).
+ */
+export const WORKGROUP_SIZE = 64;
+
+// Field offsets resolved at module-load. `.pack()` on the structs
+// reorders fields by alignment, so reading offsets directly off the
+// struct is the only way to be sure these match what the rasterizer
+// expects to read back later.
+const MESHLET_BOUNDS_OFFSET_WORDS = MESHLET_METADATA_STRUCT.get('bounds_box').offset / 4;
+const MESHLET_ADDRESS_OFFSET_WORDS = MESHLET_METADATA_STRUCT.get('address').offset / 4;
+const MESHLET_VERTEX_COUNT_OFFSET_WORDS = MESHLET_METADATA_STRUCT.get('vertex_count').offset / 4;
+const MESHLET_PRIMITIVE_COUNT_OFFSET_WORDS = MESHLET_METADATA_STRUCT.get('primitive_count').offset / 4;
+const MESHLET_STRIDE_WORDS = MESHLET_METADATA_STRUCT.size / 4;
+
+const GEOMETRY_BBOX_OFFSET_WORDS = GEOMETRY_METADATA_STRUCT.get('bounding_box').offset / 4;
+const GEOMETRY_STRIDE_WORDS = GEOMETRY_METADATA_STRUCT.size / 4;
+
+const resources = new ShaderResourceSetDescriptor();
+
+// per-dispatch, four bytes, read-only: immediate data rather than a uniform buffer, allocated once
+// per paginated sub-dispatch
+resources.setImmediate("dispatch_offset", u32);
+resources.createGroup()
+    // First-workgroup offset in this sub-dispatch (workgroup units).
+    // One workgroup per pair, so this matches the skinning shader's
+    // `dispatch_offset` semantic.
+    .addStorageBuffer('skinning_bindings', WebGPUArray.from(SKINNING_BINDING_STRUCT), false)
+    .addStorageBuffer('dispatch_lookup', WebGPUArray.from(u32), false)
+    // Clone vertex data: positions live at `address + index_section_size`
+    // (see `chunk_meshlet_compute_attribute_section_offset`). Read-only
+    // here — the skinning compute already wrote the deformed positions
+    // before this pass runs.
+    .addStorageBuffer('meshlet_data', WebGPUArray.from(u32), false)
+    // Same buffer the rasterizer reads as typed structs, bound here as
+    // a flat `atomic<u32>` array. We atomicLoad meshlet header fields
+    // (address / vertex_count / primitive_count) and atomic-merge the
+    // computed bounds into `bounds_box`.
+    .addStorageBuffer('meshlet_metadata_atomic', WebGPUArray.from(atomic_u32), true)
+    .addStorageBuffer('geometry_metadata_atomic', WebGPUArray.from(atomic_u32), true);
+
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+const MESHLET_BOUNDS_OFFSET: u32         = ${MESHLET_BOUNDS_OFFSET_WORDS}u;
+const MESHLET_ADDRESS_OFFSET: u32        = ${MESHLET_ADDRESS_OFFSET_WORDS}u;
+const MESHLET_VERTEX_COUNT_OFFSET: u32   = ${MESHLET_VERTEX_COUNT_OFFSET_WORDS}u;
+const MESHLET_PRIMITIVE_COUNT_OFFSET: u32 = ${MESHLET_PRIMITIVE_COUNT_OFFSET_WORDS}u;
+const MESHLET_STRIDE: u32                = ${MESHLET_STRIDE_WORDS}u;
+const GEOMETRY_BBOX_OFFSET: u32          = ${GEOMETRY_BBOX_OFFSET_WORDS}u;
+const GEOMETRY_STRIDE: u32               = ${GEOMETRY_STRIDE_WORDS}u;
+
+// Workgroup-shared reduction storage. Each thread parks its
+// per-vertex-strip min/max here for tree reduction. Sized to the
+// workgroup width.
+var<workgroup> wg_min: array<vec3<f32>, ${WORKGROUP_SIZE}>;
+var<workgroup> wg_max: array<vec3<f32>, ${WORKGROUP_SIZE}>;
+
+@compute @workgroup_size(${WORKGROUP_SIZE},1,1)
+fn main(
+    @builtin(workgroup_id) wg_id: vec3<u32>,
+    @builtin(local_invocation_index) local_id: u32,
+) {
+    let pair_index = wg_id.x + dispatch_offset;
+
+    let lookup_base = pair_index * 2u;
+    let binding_index = dispatch_lookup[lookup_base];
+    let meshlet_local = dispatch_lookup[lookup_base + 1u];
+
+    let binding = skinning_bindings[binding_index];
+    let clone_meshlet_abs = binding.clone_meshlet_metadata_offset + meshlet_local;
+    let m_base_words = clone_meshlet_abs * MESHLET_STRIDE;
+
+    // Meshlet header reads — atomicLoad because the buffer is bound
+    // atomic-typed. These values are stable across the pass (the
+    // scatter pass only resets bounds_box, not the header), so reads
+    // are uniform-control-flow safe.
+    let address         = atomicLoad(&meshlet_metadata_atomic[m_base_words + MESHLET_ADDRESS_OFFSET]);
+    let primitive_count = atomicLoad(&meshlet_metadata_atomic[m_base_words + MESHLET_PRIMITIVE_COUNT_OFFSET]);
+    let vertex_count    = atomicLoad(&meshlet_metadata_atomic[m_base_words + MESHLET_VERTEX_COUNT_OFFSET]);
+
+    // Attribute section base = address + index_section_size, where
+    // index_section_size = ceil(primitive_count * 3 / 4) u32 words.
+    // Position is the first attribute at offset 0 within the section,
+    // stored as 3 contiguous f32s per vertex. Matches the skinning
+    // shader's clone-write addressing.
+    let index_section_size = (primitive_count * 3u + 3u) >> 2u;
+    let attribute_section = address + index_section_size;
+
+    // Per-thread min/max accumulators. WGSL disallows the const
+    // expression \`bitcast<f32>(0x7F800000u)\` because the resulting
+    // \`f32\` is not representable as a literal (it's ±inf). We use
+    // the largest finite f32 instead — for our purposes (vertex
+    // positions, well-bounded in metres), it's effectively infinite:
+    // any real vertex coordinate is many orders of magnitude
+    // smaller, so the merge math is identical.
+    //
+    // Note that the storage sentinels in \`meshlet.bounds_box\` and
+    // \`geometry.bounding_box\` ARE true ±inf — the scatter pass
+    // writes the u32 bit pattern directly via \`atomicStore\`, no
+    // const-fold involved, and \`aabb_atomic_min_f32\` bitcasts
+    // back to f32 at runtime where ±inf is a valid value.
+    var thread_min = vec3<f32>( 3.4028234e38);
+    var thread_max = vec3<f32>(-3.4028234e38);
+
+    // Stride loop over the meshlet's vertex slots. Most meshlets fit
+    // in a single WG_SIZE pass; larger ones cycle.
+    var v: u32 = local_id;
+    loop {
+        if v >= vertex_count { break; }
+        let pos_addr = attribute_section + v * 3u;
+        let p = vec3<f32>(
+            bitcast<f32>(meshlet_data[pos_addr]),
+            bitcast<f32>(meshlet_data[pos_addr + 1u]),
+            bitcast<f32>(meshlet_data[pos_addr + 2u]),
+        );
+        thread_min = min(thread_min, p);
+        thread_max = max(thread_max, p);
+        v = v + ${WORKGROUP_SIZE}u;
+    }
+
+    // Power-of-2 tree reduction in workgroup memory. WG_SIZE = 64 is
+    // a power of two, so the standard halving stride works with no
+    // tail handling. Subgroup ops would be a bit faster but require
+    // the "subgroups" extension; this works on every device.
+    wg_min[local_id] = thread_min;
+    wg_max[local_id] = thread_max;
+    workgroupBarrier();
+
+    var stride: u32 = ${WORKGROUP_SIZE >>> 1}u;
+    loop {
+        if stride == 0u { break; }
+        if local_id < stride {
+            wg_min[local_id] = min(wg_min[local_id], wg_min[local_id + stride]);
+            wg_max[local_id] = max(wg_max[local_id], wg_max[local_id + stride]);
+        }
+        workgroupBarrier();
+        stride = stride >> 1u;
+    }
+
+    // Thread 0 owns the writes. Atomic-merge into both the meshlet's
+    // own bounds_box (single contributor per meshlet — could be
+    // atomicStore, but using min/max keeps the scatter's sentinel as
+    // the identity element and means a re-run is idempotent) AND into
+    // the binding's clone geometry's bounding_box (cross-workgroup
+    // contention — CAS-spin handles it).
+    if local_id == 0u {
+        let final_min = wg_min[0];
+        let final_max = wg_max[0];
+
+        let m_bounds_base = m_base_words + MESHLET_BOUNDS_OFFSET;
+        aabb_atomic_min_f32(&meshlet_metadata_atomic[m_bounds_base + 0u], final_min.x);
+        aabb_atomic_min_f32(&meshlet_metadata_atomic[m_bounds_base + 1u], final_min.y);
+        aabb_atomic_min_f32(&meshlet_metadata_atomic[m_bounds_base + 2u], final_min.z);
+        aabb_atomic_max_f32(&meshlet_metadata_atomic[m_bounds_base + 3u], final_max.x);
+        aabb_atomic_max_f32(&meshlet_metadata_atomic[m_bounds_base + 4u], final_max.y);
+        aabb_atomic_max_f32(&meshlet_metadata_atomic[m_bounds_base + 5u], final_max.z);
+
+        let g_base = binding.clone_geometry_index * GEOMETRY_STRIDE + GEOMETRY_BBOX_OFFSET;
+        aabb_atomic_min_f32(&geometry_metadata_atomic[g_base + 0u], final_min.x);
+        aabb_atomic_min_f32(&geometry_metadata_atomic[g_base + 1u], final_min.y);
+        aabb_atomic_min_f32(&geometry_metadata_atomic[g_base + 2u], final_min.z);
+        aabb_atomic_max_f32(&geometry_metadata_atomic[g_base + 3u], final_max.x);
+        aabb_atomic_max_f32(&geometry_metadata_atomic[g_base + 4u], final_max.y);
+        aabb_atomic_max_f32(&geometry_metadata_atomic[g_base + 5u], final_max.z);
+    }
+}
+`, [chunk_aabb_atomic_f32]);
+
+/**
+ * Compute shader that reduces a clone meshlet's deformed vertex
+ * positions to a tight AABB, atomic-writes the result to the meshlet's
+ * `bounds_box`, and atomic-merges the same bounds into the owning
+ * clone geometry's `bounding_box`.
+ *
+ * Workgroup-per-pair dispatch: one workgroup per (binding, meshlet)
+ * row in `dispatch_lookup`. Each thread handles a stride of vertices,
+ * the workgroup reduces via shared memory + tree halving, and thread 0
+ * commits the result.
+ *
+ * The geometry-level merge is what lets the rasterizer's per-geometry
+ * sphere/AABB culling use post-deformation bounds without a second
+ * full pass — the sphere derive shader downstream just reads the
+ * accumulated `bounding_box` and computes its surrounding sphere.
+ *
+ * Must run AFTER `shader_meshlet_apply_skinning` (which writes the
+ * deformed positions this pass reads) and AFTER
+ * `shader_meshlet_bounds_scatter` (which seeds the meshlet and
+ * geometry bounds with ±inf sentinels).
+ *
+ * Pagination: with one workgroup per pair, the host splits into
+ * multiple sub-dispatches when `total_pair_count >
+ * maxComputeWorkgroupsPerDimension`. The `dispatch_offset` uniform
+ * advances per sub-dispatch.
+ */
+export const shader_meshlet_bounds_reduce = ComputeShader.from({
+    label: "Skinning/MeshletBoundsReduce",
+    resources,
+    body,
+});

package/src/shade/renderer/animation/skinning/bounds_refresh/shader_meshlet_bounds_scatter.d.ts

@@ -7,7 +7,7 @@ export const WORKGROUP_SIZE: 64;
  * Linear-thread dispatch: one thread per (binding, meshlet) pair in
  * the skinning context's `dispatch_lookup`. With workgroup size 64,
  * `ceil(total_pair_count / 64)` workgroups cover everything; the
- * `dispatch_offset` uniform lets the host paginate when
+ * `settings.dispatch_offset` immediate lets the host paginate when
  * `total_pair_count > maxComputeWorkgroupsPerDimension * 64`
  * (currently won't trigger — 65535 * 64 ≈ 4M pairs).
  *

package/src/shade/renderer/animation/skinning/bounds_refresh/shader_meshlet_bounds_scatter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_meshlet_bounds_scatter.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/animation/skinning/bounds_refresh/shader_meshlet_bounds_scatter.js"],"names":[],"mappings":"AASA,gCAAiC;AAwFjC;;;;;;;;;;;;;;;;;GAiBG;AACH,0DAIG;8BAlH2B,kCAAkC"}
+{"version":3,"file":"shader_meshlet_bounds_scatter.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/animation/skinning/bounds_refresh/shader_meshlet_bounds_scatter.js"],"names":[],"mappings":"AAUA,gCAAiC;AAsGjC;;;;;;;;;;;;;;;;;GAiBG;AACH,0DAIG;8BAhI2B,kCAAkC"}