@woosh/meep-engine 3.12.0 → 3.13.0

package/src/shade/renderer/animation/shader_animation_tick.js

@@ -1,125 +1,128 @@
-import { f32, u32 } from "../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
-import { WebGPUArray } from "../shader/type/WebGPUArray.js";
-import { CodeChunk } from "../shader/compiler/CodeChunk.js";
-import { ComputeShader } from "../shader/ComputeShader.js";
-import { ShaderResourceSetDescriptor } from "../shader/resource/ShaderResourceSetDescriptor.js";
-import { ANIMATION_DATABASE_SPEC } from "./ANIMATION_DATABASE_SPEC.js";
-import { AnimationClipFlags } from "./AnimationClipFlags.js";
-
-const CLIP_TABLE = ANIMATION_DATABASE_SPEC.get('animation_clips');
-
-/**
- * Workgroup size for the tick pass. Exported so dispatchers can pair it
- * with `animation_clips.dispatch_group_count(WORKGROUP_SIZE)` — the
- * page iterator's slot-to-workgroup mapping is computed against this
- * value, so the two must agree.
- */
-export const WORKGROUP_SIZE = 64;
-
-// rw variant — our `animation_database` binding is read_write so the
-// tick can advance `clip.time` in place. The iterator's `_setup` and
-// `_read` need matching access mode on their database parameter.
-const PG_PREFIX = CLIP_TABLE.page_iterator_symbol_prefix(WORKGROUP_SIZE, true);
-
-// `dt` is a single f32 uniform — seconds elapsed since the last tick.
-// `animation_database` is read_write because the tick advances the
-// `time` field of each playing clip in place.
-const resources = new ShaderResourceSetDescriptor();
-resources.createGroup()
-    .addUniform('dt', f32)
-    .addStorageBuffer('animation_database', WebGPUArray.from(u32), true);
-
-const body = CodeChunk.from(
-    //language=WGSL
-    `
-const FLAG_PLAYING: u32 = ${AnimationClipFlags.Playing}u;
-const FLAG_LOOP:    u32 = ${AnimationClipFlags.Loop}u;
-
-@compute @workgroup_size(${WORKGROUP_SIZE},1,1)
-fn main(
-    @builtin(workgroup_id) wg_id: vec3<u32>,
-    @builtin(local_invocation_index) local_id: u32,
-) {
-    if !${PG_PREFIX}_setup(&animation_database, wg_id.x, local_id) {
-        return;
-    }
-
-    let slot_in_page = ${PG_PREFIX}_slot_in_page(local_id);
-
-    if slot_in_page >= ${PG_PREFIX}_ELEMENTS_PER_PAGE {
-        return;
-    }
-    if !${PG_PREFIX}_is_occupied(slot_in_page) {
-        return;
-    }
-
-    let clip = ${PG_PREFIX}_read(&animation_database, slot_in_page);
-
-    // The Playing bit gates time advance entirely. A stopped clip
-    // doesn't even need a write — the upload-buffer dedupe would
-    // collapse it, but skipping saves the store entirely.
-    if (clip.flags & FLAG_PLAYING) == 0u {
-        return;
-    }
-
-    let clip_id = ${PG_PREFIX}_slot_to_index(slot_in_page);
-
-    let advance = dt * clip.playback_rate;
-    var new_time = clip.time + advance;
-
-    // "clip.time" is the playback offset relative to "clip.time_start",
-    // not an absolute curve-clock value — the apply shader does
-    // "effective_time = clip.time + clip.time_start" when sampling
-    // curves. So we wrap / clamp in "[0, duration]", not in
-    // "[time_start, time_end]".
-    let span = clip.time_end - clip.time_start;
-
-    if span <= 0.0 {
-        // Zero-length clip — pin to 0 and skip the wrap/clamp math.
-        // Avoids division by zero in the loop branch and gives a
-        // deterministic value the apply shader can read.
-        new_time = 0.0;
-    } else if (clip.flags & FLAG_LOOP) != 0u {
-        // Wrap into [0, duration). Uses fmod-style positive modulo
-        // so negative playback_rates wrap cleanly too.
-        new_time = new_time - floor(new_time / span) * span;
-    } else {
-        // Non-looping: clamp to the playback range. Once clamped, the
-        // clip "completes" — time stops advancing on its own (advance
-        // adds zero in subsequent frames because new_time == clip.time
-        // would already equal duration). The Playing bit is left set
-        // so the host can decide whether to stop, rewind, or flip the
-        // Loop bit on.
-        new_time = clamp(new_time, 0.0, span);
-    }
-
-    ${CLIP_TABLE.marshalling_method_write_field('time')}(&animation_database, clip_id, new_time);
-}
-`, [
-        CLIP_TABLE.chunk_iterate(WORKGROUP_SIZE, true),
-        CLIP_TABLE.wgsl_gen_write_field_code('time'),
-    ]
-);
-
-/**
- * GPU-side animation playback driver: one thread per clip slot via the
- * page iterator. For each clip with the {@link AnimationClipFlags.Playing}
- * bit set, advances `time` by `dt * playback_rate`, then either wraps
- * modulo `[time_start, time_end]` (if {@link AnimationClipFlags.Loop} is
- * set) or clamps to that range (if not).
- *
- * Run before `shader_animation_apply` each frame — the apply pass reads
- * `clip.time` to evaluate tracks, so the tick must land first. The
- * `dt` uniform is the wall-clock seconds elapsed since the previous
- * tick; the host owns its measurement.
- *
- * Dispatch via
- * `shader_animation_tick.dispatch({ group_count_x: animation_clips.dispatch_group_count(WORKGROUP_SIZE), ... })`.
- * Skip the dispatch when `group_count_x === 0` — no clips registered
- * means no work to do.
- */
-export const shader_animation_tick = ComputeShader.from({
-    label: "Animation/Tick",
-    body,
-    resources,
-});
+import { f32, u32 } from "../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../shader/type/WebGPUArray.js";
+import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../shader/resource/ShaderResourceSetDescriptor.js";
+import { ANIMATION_DATABASE_SPEC } from "./ANIMATION_DATABASE_SPEC.js";
+import { AnimationClipFlags } from "./AnimationClipFlags.js";
+
+const CLIP_TABLE = ANIMATION_DATABASE_SPEC.get('animation_clips');
+
+/**
+ * Workgroup size for the tick pass. Exported so dispatchers can pair it
+ * with `animation_clips.dispatch_group_count(WORKGROUP_SIZE)` — the
+ * page iterator's slot-to-workgroup mapping is computed against this
+ * value, so the two must agree.
+ */
+export const WORKGROUP_SIZE = 64;
+
+// rw variant — our `animation_database` binding is read_write so the
+// tick can advance `clip.time` in place. The iterator's `_setup` and
+// `_read` need matching access mode on their database parameter.
+const PG_PREFIX = CLIP_TABLE.page_iterator_symbol_prefix(WORKGROUP_SIZE, true);
+
+// `dt` is a single f32 uniform — seconds elapsed since the last tick.
+// `animation_database` is read_write because the tick advances the
+// `time` field of each playing clip in place.
+const resources = new ShaderResourceSetDescriptor();
+
+// per-frame, four bytes, read-only: immediate data rather than a uniform buffer holding one f32
+resources.setImmediate("dt", f32);
+
+resources.createGroup()
+    .addStorageBuffer('animation_database', WebGPUArray.from(u32), true);
+
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+const FLAG_PLAYING: u32 = ${AnimationClipFlags.Playing}u;
+const FLAG_LOOP:    u32 = ${AnimationClipFlags.Loop}u;
+
+@compute @workgroup_size(${WORKGROUP_SIZE},1,1)
+fn main(
+    @builtin(workgroup_id) wg_id: vec3<u32>,
+    @builtin(local_invocation_index) local_id: u32,
+) {
+    if !${PG_PREFIX}_setup(&animation_database, wg_id.x, local_id) {
+        return;
+    }
+
+    let slot_in_page = ${PG_PREFIX}_slot_in_page(local_id);
+
+    if slot_in_page >= ${PG_PREFIX}_ELEMENTS_PER_PAGE {
+        return;
+    }
+    if !${PG_PREFIX}_is_occupied(slot_in_page) {
+        return;
+    }
+
+    let clip = ${PG_PREFIX}_read(&animation_database, slot_in_page);
+
+    // The Playing bit gates time advance entirely. A stopped clip
+    // doesn't even need a write — the upload-buffer dedupe would
+    // collapse it, but skipping saves the store entirely.
+    if (clip.flags & FLAG_PLAYING) == 0u {
+        return;
+    }
+
+    let clip_id = ${PG_PREFIX}_slot_to_index(slot_in_page);
+
+    let advance = dt * clip.playback_rate;
+    var new_time = clip.time + advance;
+
+    // "clip.time" is the playback offset relative to "clip.time_start",
+    // not an absolute curve-clock value — the apply shader does
+    // "effective_time = clip.time + clip.time_start" when sampling
+    // curves. So we wrap / clamp in "[0, duration]", not in
+    // "[time_start, time_end]".
+    let span = clip.time_end - clip.time_start;
+
+    if span <= 0.0 {
+        // Zero-length clip — pin to 0 and skip the wrap/clamp math.
+        // Avoids division by zero in the loop branch and gives a
+        // deterministic value the apply shader can read.
+        new_time = 0.0;
+    } else if (clip.flags & FLAG_LOOP) != 0u {
+        // Wrap into [0, duration). Uses fmod-style positive modulo
+        // so negative playback_rates wrap cleanly too.
+        new_time = new_time - floor(new_time / span) * span;
+    } else {
+        // Non-looping: clamp to the playback range. Once clamped, the
+        // clip "completes" — time stops advancing on its own (advance
+        // adds zero in subsequent frames because new_time == clip.time
+        // would already equal duration). The Playing bit is left set
+        // so the host can decide whether to stop, rewind, or flip the
+        // Loop bit on.
+        new_time = clamp(new_time, 0.0, span);
+    }
+
+    ${CLIP_TABLE.marshalling_method_write_field('time')}(&animation_database, clip_id, new_time);
+}
+`, [
+        CLIP_TABLE.chunk_iterate(WORKGROUP_SIZE, true),
+        CLIP_TABLE.wgsl_gen_write_field_code('time'),
+    ]
+);
+
+/**
+ * GPU-side animation playback driver: one thread per clip slot via the
+ * page iterator. For each clip with the {@link AnimationClipFlags.Playing}
+ * bit set, advances `time` by `dt * playback_rate`, then either wraps
+ * modulo `[time_start, time_end]` (if {@link AnimationClipFlags.Loop} is
+ * set) or clamps to that range (if not).
+ *
+ * Run before `shader_animation_apply` each frame — the apply pass reads
+ * `clip.time` to evaluate tracks, so the tick must land first. The
+ * `dt` uniform is the wall-clock seconds elapsed since the previous
+ * tick; the host owns its measurement.
+ *
+ * Dispatch via
+ * `shader_animation_tick.dispatch({ group_count_x: animation_clips.dispatch_group_count(WORKGROUP_SIZE), ... })`.
+ * Skip the dispatch when `group_count_x === 0` — no clips registered
+ * means no work to do.
+ */
+export const shader_animation_tick = ComputeShader.from({
+    label: "Animation/Tick",
+    body,
+    resources,
+});

package/src/shade/renderer/animation/skinning/GPUMeshSkinningContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUMeshSkinningContext.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/animation/skinning/GPUMeshSkinningContext.js"],"names":[],"mappings":"AA0EA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH;IA2MI;;;;;;;OAOG;IACH,sEAPW;QACV,UAAgB,qBAAqB;QACrC,iBAAuB,sBAAsB;QAC7C,aAAmB,kBAAkB;QACrC,MAAY,YAAY;KACrB,EAYH;IAED;;;;;;OAMG;IACH,iCAEC;IAED;;;;;;OAMG;IACH,2BAEC;IAED;;;;;;;OAOG;IACH,wCAEC;IAED;;;;;;;;;;;;;;OAcG;IACH,mCAFa,MAAM,CAelB;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,iCAFW,MAAM,QAmBhB;IAED;;;;;;;OAOG;IACH,gCAFa,MAAM,GAAC,SAAS,CAI5B;IAED;;;;;;;;;;OAUG;IACH,gCAYC;IAED;;;;;;;;OAQG;IACH,4BAFW,MAAM,QAYhB;IAyCD;;;;;;;;;;;;;;;OAeG;IACH,8CA2NC;IAsSD,gBAiBC;;CACJ"}
+{"version":3,"file":"GPUMeshSkinningContext.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/animation/skinning/GPUMeshSkinningContext.js"],"names":[],"mappings":"AAyEA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH;IA2MI;;;;;;;OAOG;IACH,sEAPW;QACV,UAAgB,qBAAqB;QACrC,iBAAuB,sBAAsB;QAC7C,aAAmB,kBAAkB;QACrC,MAAY,YAAY;KACrB,EAYH;IAED;;;;;;OAMG;IACH,iCAEC;IAED;;;;;;OAMG;IACH,2BAEC;IAED;;;;;;;OAOG;IACH,wCAEC;IAED;;;;;;;;;;;;;;OAcG;IACH,mCAFa,MAAM,CAelB;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,iCAFW,MAAM,QAmBhB;IAED;;;;;;;OAOG;IACH,gCAFa,MAAM,GAAC,SAAS,CAI5B;IAED;;;;;;;;;;OAUG;IACH,gCAYC;IAED;;;;;;;;OAQG;IACH,4BAFW,MAAM,QAYhB;IAyCD;;;;;;;;;;;;;;;OAeG;IACH,8CAkNC;IAsSD,gBAiBC;;CACJ"}

package/src/shade/renderer/animation/skinning/GPUMeshSkinningContext.js

@@ -1,5 +1,4 @@
 import { assert } from "../../../../core/assert.js";
-import { u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
 import { write_gpu_typed_buffer } from "../../shader/type/serde/write_gpu_typed_buffer.js";
 import {
     shader_geometry_sphere_derive,
@@ -600,13 +599,11 @@ export class GPUMeshSkinningContext {
         // work is identical to a single huge dispatch.
         for (let offset = 0; offset < total; offset += max_workgroups) {
             const this_chunk = Math.min(max_workgroups, total - offset);
-            const dispatch_offset = cmd_ctx.allocateTransientValueBuffer(u32, offset);
-
             shader_meshlet_apply_skinning.dispatch({
                 encoder: cmd_ctx,
                 group_count_x: this_chunk,
                 bindings: {
-                    dispatch_offset,
+                    dispatch_offset: offset,
                     meshlet_data: meshlets.buffer_data,
                     meshlet_metadata: meshlets.buffer_metadata,
                     skin_matrices: this.#animation_manager.skin_matrices_buffer,
@@ -657,17 +654,14 @@ export class GPUMeshSkinningContext {
                 const this_chunk = Math.min(max_workgroups, total_workgroups - offset_wg);
                 // dispatch_offset is in *pair* units for scatter — the
                 // shader does `gid.x + dispatch_offset`.
-                const dispatch_offset = cmd_ctx.allocateTransientValueBuffer(
-                    u32,
-                    offset_wg * BOUNDS_SCATTER_WORKGROUP_SIZE
-                );
-                const total_pair_count = cmd_ctx.allocateTransientValueBuffer(u32, total);
                 shader_meshlet_bounds_scatter.dispatch({
                     encoder: cmd_ctx,
                     group_count_x: this_chunk,
                     bindings: {
-                        dispatch_offset,
-                        total_pair_count,
+                        settings: {
+                            dispatch_offset: offset_wg * BOUNDS_SCATTER_WORKGROUP_SIZE,
+                            total_pair_count: total,
+                        },
                         skinning_bindings: this.#bindings_buffer,
                         dispatch_lookup: this.#dispatch_lookup_buffer,
                         meshlet_metadata_atomic: meshlets.buffer_metadata,
@@ -682,13 +676,11 @@ export class GPUMeshSkinningContext {
         // skinning; same pagination.
         for (let offset = 0; offset < total; offset += max_workgroups) {
             const this_chunk = Math.min(max_workgroups, total - offset);
-            const dispatch_offset = cmd_ctx.allocateTransientValueBuffer(u32, offset);
-
             shader_meshlet_bounds_reduce.dispatch({
                 encoder: cmd_ctx,
                 group_count_x: this_chunk,
                 bindings: {
-                    dispatch_offset,
+                    dispatch_offset: offset,
                     skinning_bindings: this.#bindings_buffer,
                     dispatch_lookup: this.#dispatch_lookup_buffer,
                     meshlet_data: meshlets.buffer_data,
@@ -705,12 +697,11 @@ export class GPUMeshSkinningContext {
         {
             const total_workgroups = Math.ceil(binding_count / SPHERE_DERIVE_WORKGROUP_SIZE);
             if (total_workgroups > 0) {
-                const binding_count_u = cmd_ctx.allocateTransientValueBuffer(u32, binding_count);
                 shader_geometry_sphere_derive.dispatch({
                     encoder: cmd_ctx,
                     group_count_x: total_workgroups,
                     bindings: {
-                        binding_count: binding_count_u,
+                        binding_count,
                         skinning_bindings: this.#bindings_buffer,
                         geometry_metadata_atomic: geometry_metadata_buffer,
                     },
@@ -725,12 +716,11 @@ export class GPUMeshSkinningContext {
         {
             const total_workgroups = Math.ceil(binding_count / MESH_BOUNDS_REFRESH_WORKGROUP_SIZE);
             if (total_workgroups > 0) {
-                const binding_count_u = cmd_ctx.allocateTransientValueBuffer(u32, binding_count);
                 shader_skinned_mesh_bounds_refresh.dispatch({
                     encoder: cmd_ctx,
                     group_count_x: total_workgroups,
                     bindings: {
-                        binding_count: binding_count_u,
+                        binding_count,
                         skinning_bindings: this.#bindings_buffer,
                         scene_database: scene_database_buffer,
                         geometries: geometry_metadata_buffer,

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

@@ -1 +1 @@
-{"version":3,"file":"shader_geometry_sphere_derive.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/animation/skinning/bounds_refresh/shader_geometry_sphere_derive.js"],"names":[],"mappings":"AAQA,gCAAiC;AAsEjC;;;;;;;;;;;;;;GAcG;AACH,0DAIG;8BA7F2B,kCAAkC"}
+{"version":3,"file":"shader_geometry_sphere_derive.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/animation/skinning/bounds_refresh/shader_geometry_sphere_derive.js"],"names":[],"mappings":"AAQA,gCAAiC;AAwEjC;;;;;;;;;;;;;;GAcG;AACH,0DAIG;8BA/F2B,kCAAkC"}

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

@@ -1,98 +1,100 @@
-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 { 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";
-
-export const WORKGROUP_SIZE = 64;
-
-const GEOMETRY_BBOX_OFFSET_WORDS = GEOMETRY_METADATA_STRUCT.get('bounding_box').offset / 4;
-const GEOMETRY_SPHERE_OFFSET_WORDS = GEOMETRY_METADATA_STRUCT.get('bounding_sphere').offset / 4;
-const GEOMETRY_STRIDE_WORDS = GEOMETRY_METADATA_STRUCT.size / 4;
-
-const resources = new ShaderResourceSetDescriptor();
-resources.createGroup()
-    // Number of active skinning bindings. Threads past `binding_count`
-    // early-out (the dispatch is sized to `ceil(binding_count/64)`
-    // workgroups, so the tail can have up to 63 idle threads).
-    .addUniform('binding_count', u32)
-    .addStorageBuffer('skinning_bindings', WebGPUArray.from(SKINNING_BINDING_STRUCT), false)
-    // Same buffer the rasterizer reads as a typed struct array; we
-    // atomicLoad the freshly-merged `bounding_box` cells and
-    // atomicStore the derived sphere into `bounding_sphere`. Atomic
-    // store is the simplest way to write through an atomic-typed
-    // view; only one thread (this binding's) writes its geometry's
-    // sphere, so there's no contention.
-    .addStorageBuffer('geometry_metadata_atomic', WebGPUArray.from(atomic_u32), true);
-
-const body = CodeChunk.from(
-    //language=WGSL
-    `
-const GEOMETRY_BBOX_OFFSET: u32   = ${GEOMETRY_BBOX_OFFSET_WORDS}u;
-const GEOMETRY_SPHERE_OFFSET: u32 = ${GEOMETRY_SPHERE_OFFSET_WORDS}u;
-const GEOMETRY_STRIDE: u32        = ${GEOMETRY_STRIDE_WORDS}u;
-
-@compute @workgroup_size(${WORKGROUP_SIZE},1,1)
-fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
-    let binding_index = gid.x;
-    if binding_index >= binding_count {
-        return;
-    }
-
-    let binding = skinning_bindings[binding_index];
-    let g_base = binding.clone_geometry_index * GEOMETRY_STRIDE;
-
-    // Read the freshly-merged bounding box. The reduce pass wrote
-    // these atomically; by the time this dispatch runs (after the
-    // reduce pass's barrier), they're stable. atomicLoad is the
-    // correct read through an atomic-typed binding.
-    let bbox_base = g_base + GEOMETRY_BBOX_OFFSET;
-    let min_x = bitcast<f32>(atomicLoad(&geometry_metadata_atomic[bbox_base + 0u]));
-    let min_y = bitcast<f32>(atomicLoad(&geometry_metadata_atomic[bbox_base + 1u]));
-    let min_z = bitcast<f32>(atomicLoad(&geometry_metadata_atomic[bbox_base + 2u]));
-    let max_x = bitcast<f32>(atomicLoad(&geometry_metadata_atomic[bbox_base + 3u]));
-    let max_y = bitcast<f32>(atomicLoad(&geometry_metadata_atomic[bbox_base + 4u]));
-    let max_z = bitcast<f32>(atomicLoad(&geometry_metadata_atomic[bbox_base + 5u]));
-
-    let min_v = vec3<f32>(min_x, min_y, min_z);
-    let max_v = vec3<f32>(max_x, max_y, max_z);
-
-    // Conservative sphere from the AABB: center at the box midpoint,
-    // radius = half the box diagonal. Slightly larger than the
-    // minimum enclosing sphere (which would need a Miniball-style
-    // iterative solver), but cheap and tight enough for culling.
-    // Same convention as "computeBoundingSphereFromBox" on the CPU
-    // side.
-    let center = (min_v + max_v) * 0.5;
-    let radius = length(max_v - min_v) * 0.5;
-
-    let sphere_base = g_base + GEOMETRY_SPHERE_OFFSET;
-    atomicStore(&geometry_metadata_atomic[sphere_base + 0u], bitcast<u32>(center.x));
-    atomicStore(&geometry_metadata_atomic[sphere_base + 1u], bitcast<u32>(center.y));
-    atomicStore(&geometry_metadata_atomic[sphere_base + 2u], bitcast<u32>(center.z));
-    atomicStore(&geometry_metadata_atomic[sphere_base + 3u], bitcast<u32>(radius));
-}
-`);
-
-/**
- * Compute shader that derives each active clone geometry's
- * `bounding_sphere` from its freshly-merged `bounding_box`.
- *
- * One thread per active skinning binding (= one per clone geometry).
- * Reads the 6 box cells, computes center = (min+max)/2 and radius =
- * length(max-min)/2 — the box-derived conservative sphere — and
- * writes the 4 sphere cells. No cross-thread contention since each
- * binding owns its own geometry row.
- *
- * Must run AFTER `shader_meshlet_bounds_reduce` (which finalizes the
- * `bounding_box` cells this pass reads) and BEFORE the mesh-instance
- * bounds-refresh pass (which reads `bounding_sphere` to project into
- * world space).
- */
-export const shader_geometry_sphere_derive = ComputeShader.from({
-    label: "Skinning/GeometrySphereDerive",
-    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 { 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";
+
+export const WORKGROUP_SIZE = 64;
+
+const GEOMETRY_BBOX_OFFSET_WORDS = GEOMETRY_METADATA_STRUCT.get('bounding_box').offset / 4;
+const GEOMETRY_SPHERE_OFFSET_WORDS = GEOMETRY_METADATA_STRUCT.get('bounding_sphere').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
+resources.setImmediate("binding_count", u32);
+resources.createGroup()
+    // Number of active skinning bindings. Threads past `binding_count`
+    // early-out (the dispatch is sized to `ceil(binding_count/64)`
+    // workgroups, so the tail can have up to 63 idle threads).
+    .addStorageBuffer('skinning_bindings', WebGPUArray.from(SKINNING_BINDING_STRUCT), false)
+    // Same buffer the rasterizer reads as a typed struct array; we
+    // atomicLoad the freshly-merged `bounding_box` cells and
+    // atomicStore the derived sphere into `bounding_sphere`. Atomic
+    // store is the simplest way to write through an atomic-typed
+    // view; only one thread (this binding's) writes its geometry's
+    // sphere, so there's no contention.
+    .addStorageBuffer('geometry_metadata_atomic', WebGPUArray.from(atomic_u32), true);
+
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+const GEOMETRY_BBOX_OFFSET: u32   = ${GEOMETRY_BBOX_OFFSET_WORDS}u;
+const GEOMETRY_SPHERE_OFFSET: u32 = ${GEOMETRY_SPHERE_OFFSET_WORDS}u;
+const GEOMETRY_STRIDE: u32        = ${GEOMETRY_STRIDE_WORDS}u;
+
+@compute @workgroup_size(${WORKGROUP_SIZE},1,1)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+    let binding_index = gid.x;
+    if binding_index >= binding_count {
+        return;
+    }
+
+    let binding = skinning_bindings[binding_index];
+    let g_base = binding.clone_geometry_index * GEOMETRY_STRIDE;
+
+    // Read the freshly-merged bounding box. The reduce pass wrote
+    // these atomically; by the time this dispatch runs (after the
+    // reduce pass's barrier), they're stable. atomicLoad is the
+    // correct read through an atomic-typed binding.
+    let bbox_base = g_base + GEOMETRY_BBOX_OFFSET;
+    let min_x = bitcast<f32>(atomicLoad(&geometry_metadata_atomic[bbox_base + 0u]));
+    let min_y = bitcast<f32>(atomicLoad(&geometry_metadata_atomic[bbox_base + 1u]));
+    let min_z = bitcast<f32>(atomicLoad(&geometry_metadata_atomic[bbox_base + 2u]));
+    let max_x = bitcast<f32>(atomicLoad(&geometry_metadata_atomic[bbox_base + 3u]));
+    let max_y = bitcast<f32>(atomicLoad(&geometry_metadata_atomic[bbox_base + 4u]));
+    let max_z = bitcast<f32>(atomicLoad(&geometry_metadata_atomic[bbox_base + 5u]));
+
+    let min_v = vec3<f32>(min_x, min_y, min_z);
+    let max_v = vec3<f32>(max_x, max_y, max_z);
+
+    // Conservative sphere from the AABB: center at the box midpoint,
+    // radius = half the box diagonal. Slightly larger than the
+    // minimum enclosing sphere (which would need a Miniball-style
+    // iterative solver), but cheap and tight enough for culling.
+    // Same convention as "computeBoundingSphereFromBox" on the CPU
+    // side.
+    let center = (min_v + max_v) * 0.5;
+    let radius = length(max_v - min_v) * 0.5;
+
+    let sphere_base = g_base + GEOMETRY_SPHERE_OFFSET;
+    atomicStore(&geometry_metadata_atomic[sphere_base + 0u], bitcast<u32>(center.x));
+    atomicStore(&geometry_metadata_atomic[sphere_base + 1u], bitcast<u32>(center.y));
+    atomicStore(&geometry_metadata_atomic[sphere_base + 2u], bitcast<u32>(center.z));
+    atomicStore(&geometry_metadata_atomic[sphere_base + 3u], bitcast<u32>(radius));
+}
+`);
+
+/**
+ * Compute shader that derives each active clone geometry's
+ * `bounding_sphere` from its freshly-merged `bounding_box`.
+ *
+ * One thread per active skinning binding (= one per clone geometry).
+ * Reads the 6 box cells, computes center = (min+max)/2 and radius =
+ * length(max-min)/2 — the box-derived conservative sphere — and
+ * writes the 4 sphere cells. No cross-thread contention since each
+ * binding owns its own geometry row.
+ *
+ * Must run AFTER `shader_meshlet_bounds_reduce` (which finalizes the
+ * `bounding_box` cells this pass reads) and BEFORE the mesh-instance
+ * bounds-refresh pass (which reads `bounding_sphere` to project into
+ * world space).
+ */
+export const shader_geometry_sphere_derive = ComputeShader.from({
+    label: "Skinning/GeometrySphereDerive",
+    resources,
+    body,
+});

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

@@ -1 +1 @@
-{"version":3,"file":"shader_meshlet_bounds_reduce.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/animation/skinning/bounds_refresh/shader_meshlet_bounds_reduce.js"],"names":[],"mappings":"AAUA;;;;;;;GAOG;AACH,gCAAiC;AAmKjC;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,yDAIG;8BA9M2B,kCAAkC"}
+{"version":3,"file":"shader_meshlet_bounds_reduce.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/animation/skinning/bounds_refresh/shader_meshlet_bounds_reduce.js"],"names":[],"mappings":"AAUA;;;;;;;GAOG;AACH,gCAAiC;AAsKjC;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,yDAIG;8BAjN2B,kCAAkC"}