@woosh/meep-engine 3.11.3 → 3.13.0

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

@@ -1,129 +1,128 @@
-import { atomic_u32, u32 } from "../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
-import { WebGPUArray } from "../shader/type/WebGPUArray.js";
-import { MATERIAL_METADATA_STRUCT } from "../material/MATERIAL_METADATA_STRUCT.js";
-import { chunk_write_object_property } from "../object_property/chunk_write_object_property.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 { chunk_animation_track_evaluate } from "./animation_track_evaluate.js";
-
-const GROUP_TABLE = ANIMATION_DATABASE_SPEC.get('animation_bound_track_groups');
-const CLIP_TABLE = ANIMATION_DATABASE_SPEC.get('animation_clips');
-const TRACK_TABLE = ANIMATION_DATABASE_SPEC.get('animation_tracks');
-
-/**
- * Workgroup size for the apply pass. Exported so dispatchers can pair it
- * with `animation_bound_track_groups.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;
-
-const PG_PREFIX = GROUP_TABLE.page_iterator_symbol_prefix(WORKGROUP_SIZE);
-
-// `materials` and `pose_accumulator` are referenced by name from the
-// property-write chunks rather than passed as pointers — the chunks
-// rely on these bindings being declared in the importing shader.
-//
-// `pose_accumulator` is the per-Node3D contribution scratch (one slot per
-// transforms-table row, `POSE_ACCUMULATOR_STRIDE` u32s each). Apply
-// atomic-adds weighted values into it; the downstream resolve pass
-// drains it into `transforms_table.local_*`.
-const resources = new ShaderResourceSetDescriptor();
-resources.createGroup()
-    .addStorageBuffer('animation_database', WebGPUArray.from(u32), false)
-    .addStorageBuffer('pose_accumulator', WebGPUArray.from(atomic_u32), true)
-    .addStorageBuffer('materials', WebGPUArray.from(MATERIAL_METADATA_STRUCT), true);
-
-// Strict 1:1 page-iterator dispatch: one thread per group-node slot.
-// A page is covered by GROUPS_PER_PAGE workgroups in parallel; setup
-// derives (page_index, page_group) from workgroup_id.x, the in-page
-// slot from page_group + local_id, and lanes past ELEMENTS_PER_PAGE
-// (only possible in the last page_group) are tail-masked.
-const body = CodeChunk.from(
-    //language=WGSL
-    `
-@compute @workgroup_size(${WORKGROUP_SIZE},1,1)
-fn main(
-    @builtin(workgroup_id) wg_id: vec3<u32>,
-    @builtin(local_invocation_index) local_id: u32,
-) {
-    // page_address is uniform across the workgroup → unallocated-page
-    // bail is uniform-control-flow safe.
-    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;
-    }
-
-    // Per-thread group node: load it, resolve the back-referenced clip,
-    // and apply every inline binding under that clip's effective time.
-    // The chain's next field is for the host (linking new nodes onto
-    // existing chains); the apply pass touches only the current node.
-    let group = ${PG_PREFIX}_read(&animation_database, slot_in_page);
-    let clip = ${CLIP_TABLE.marshalling_method_read}(&animation_database, group.clip);
-
-    // Playback time 0 sits at clip.time_start on the curves' clock.
-    // Curves clamp the result to their own [time_min, time_max], so a
-    // track whose authored range falls outside the clip window just
-    // holds at its endpoint over the gap.
-    let effective_time = clip.time + clip.time_start;
-
-    // Pre-multiply every contribution by this clip's weight so the
-    // accumulator can just add. Translation/scale: scalar*vec3
-    // componentwise; rotation: scalar*vec4, which is the standard
-    // weighted-quaternion blend term — the resolve pass normalizes
-    // the accumulated quat sum back to unit length.
-    let weight = clip.playback_weight;
-
-    for(var i = 0u; i < group.count; i++){
-        let binding = group.bindings[i];
-        let track = ${TRACK_TABLE.marshalling_method_read}(&animation_database, binding.track);
-
-        let value = animation_track_evaluate(effective_time, track, &animation_database) * weight;
-
-        write_object_property(binding.instance, binding.property, track.mask, value);
-    }
-}
-`, [
-        GROUP_TABLE.chunk_iterate(WORKGROUP_SIZE),
-        CLIP_TABLE.chunk_read,
-        TRACK_TABLE.chunk_read,
-        chunk_animation_track_evaluate,
-        chunk_write_object_property,
-    ]
-);
-
-/**
- * Compute shader that walks the `animation_bound_track_groups` table —
- * one thread per group-node slot via the page iterator — evaluating
- * every inline binding under its owning clip's `time + time_start` and
- * atomic-adding the (weight-multiplied) result into the pose
- * accumulator (Node3D properties) or directly into the material
- * metadata table (Material properties).
- *
- * Node3D writes land in `pose_accumulator` rather than directly in
- * `transforms_table.local_*` so multi-clip blending is just additive;
- * `shader_animation_pose_resolve` walks the accumulator next, drains
- * each dirty row into the transforms table, normalizes rotation, and
- * zeros the slot for the next frame.
- *
- * Dispatch via
- * `shader_animation_apply.dispatch({ group_count_x: animation_bound_track_groups.dispatch_group_count(WORKGROUP_SIZE), ... })` —
- * the iterator covers every allocated page in parallel and skips
- * unallocated/unoccupied slots in-shader.
- */
-export const shader_animation_apply = ComputeShader.from({
-    label: "Animation/Apply",
-    body,
-    resources,
-    group_size: [WORKGROUP_SIZE, 1, 1],
-});
+import { atomic_u32, u32 } from "../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../shader/type/WebGPUArray.js";
+import { MATERIAL_METADATA_STRUCT } from "../material/MATERIAL_METADATA_STRUCT.js";
+import { chunk_write_object_property } from "../object_property/chunk_write_object_property.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 { chunk_animation_track_evaluate } from "./animation_track_evaluate.js";
+
+const GROUP_TABLE = ANIMATION_DATABASE_SPEC.get('animation_bound_track_groups');
+const CLIP_TABLE = ANIMATION_DATABASE_SPEC.get('animation_clips');
+const TRACK_TABLE = ANIMATION_DATABASE_SPEC.get('animation_tracks');
+
+/**
+ * Workgroup size for the apply pass. Exported so dispatchers can pair it
+ * with `animation_bound_track_groups.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;
+
+const PG_PREFIX = GROUP_TABLE.page_iterator_symbol_prefix(WORKGROUP_SIZE);
+
+// `materials` and `pose_accumulator` are referenced by name from the
+// property-write chunks rather than passed as pointers — the chunks
+// rely on these bindings being declared in the importing shader.
+//
+// `pose_accumulator` is the per-Node3D contribution scratch (one slot per
+// transforms-table row, `POSE_ACCUMULATOR_STRIDE` u32s each). Apply
+// atomic-adds weighted values into it; the downstream resolve pass
+// drains it into `transforms_table.local_*`.
+const resources = new ShaderResourceSetDescriptor();
+resources.createGroup()
+    .addStorageBuffer('animation_database', WebGPUArray.from(u32), false)
+    .addStorageBuffer('pose_accumulator', WebGPUArray.from(atomic_u32), true)
+    .addStorageBuffer('materials', WebGPUArray.from(MATERIAL_METADATA_STRUCT), true);
+
+// Strict 1:1 page-iterator dispatch: one thread per group-node slot.
+// A page is covered by GROUPS_PER_PAGE workgroups in parallel; setup
+// derives (page_index, page_group) from workgroup_id.x, the in-page
+// slot from page_group + local_id, and lanes past ELEMENTS_PER_PAGE
+// (only possible in the last page_group) are tail-masked.
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+@compute @workgroup_size(${WORKGROUP_SIZE},1,1)
+fn main(
+    @builtin(workgroup_id) wg_id: vec3<u32>,
+    @builtin(local_invocation_index) local_id: u32,
+) {
+    // page_address is uniform across the workgroup → unallocated-page
+    // bail is uniform-control-flow safe.
+    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;
+    }
+
+    // Per-thread group node: load it, resolve the back-referenced clip,
+    // and apply every inline binding under that clip's effective time.
+    // The chain's next field is for the host (linking new nodes onto
+    // existing chains); the apply pass touches only the current node.
+    let group = ${PG_PREFIX}_read(&animation_database, slot_in_page);
+    let clip = ${CLIP_TABLE.marshalling_method_read}(&animation_database, group.clip);
+
+    // Playback time 0 sits at clip.time_start on the curves' clock.
+    // Curves clamp the result to their own [time_min, time_max], so a
+    // track whose authored range falls outside the clip window just
+    // holds at its endpoint over the gap.
+    let effective_time = clip.time + clip.time_start;
+
+    // Pre-multiply every contribution by this clip's weight so the
+    // accumulator can just add. Translation/scale: scalar*vec3
+    // componentwise; rotation: scalar*vec4, which is the standard
+    // weighted-quaternion blend term — the resolve pass normalizes
+    // the accumulated quat sum back to unit length.
+    let weight = clip.playback_weight;
+
+    for(var i = 0u; i < group.count; i++){
+        let binding = group.bindings[i];
+        let track = ${TRACK_TABLE.marshalling_method_read}(&animation_database, binding.track);
+
+        let value = animation_track_evaluate(effective_time, track, &animation_database) * weight;
+
+        write_object_property(binding.instance, binding.property, track.mask, value);
+    }
+}
+`, [
+        GROUP_TABLE.chunk_iterate(WORKGROUP_SIZE),
+        CLIP_TABLE.chunk_read,
+        TRACK_TABLE.chunk_read,
+        chunk_animation_track_evaluate,
+        chunk_write_object_property,
+    ]
+);
+
+/**
+ * Compute shader that walks the `animation_bound_track_groups` table —
+ * one thread per group-node slot via the page iterator — evaluating
+ * every inline binding under its owning clip's `time + time_start` and
+ * atomic-adding the (weight-multiplied) result into the pose
+ * accumulator (Node3D properties) or directly into the material
+ * metadata table (Material properties).
+ *
+ * Node3D writes land in `pose_accumulator` rather than directly in
+ * `transforms_table.local_*` so multi-clip blending is just additive;
+ * `shader_animation_pose_resolve` walks the accumulator next, drains
+ * each dirty row into the transforms table, normalizes rotation, and
+ * zeros the slot for the next frame.
+ *
+ * Dispatch via
+ * `shader_animation_apply.dispatch({ group_count_x: animation_bound_track_groups.dispatch_group_count(WORKGROUP_SIZE), ... })` —
+ * the iterator covers every allocated page in parallel and skips
+ * unallocated/unoccupied slots in-shader.
+ */
+export const shader_animation_apply = ComputeShader.from({
+    label: "Animation/Apply",
+    body,
+    resources,
+});

package/src/shade/renderer/animation/shader_animation_pose_resolve.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_animation_pose_resolve.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/animation/shader_animation_pose_resolve.js"],"names":[],"mappings":"AAWA;;;GAGG;AACH,gCAAiC;AAyIjC;;;;;;;;;;;;;;;;;;GAkBG;AACH,0DAKG;8BA3K2B,4BAA4B"}
+{"version":3,"file":"shader_animation_pose_resolve.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/animation/shader_animation_pose_resolve.js"],"names":[],"mappings":"AAWA;;;GAGG;AACH,gCAAiC;AAyIjC;;;;;;;;;;;;;;;;;;GAkBG;AACH,0DAIG;8BA1K2B,4BAA4B"}

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

@@ -1,177 +1,176 @@
-import { atomic_u32, u32 } from "../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
-import { WebGPUArray } from "../shader/type/WebGPUArray.js";
-import { chunk_scene_database_access_rw } from "../scene/chunk_scene_database_access.js";
-import { SCENE_DATABASE_SPEC } from "../scene/SCENE_DATABASE_SPEC.js";
-import { CodeChunk } from "../shader/compiler/CodeChunk.js";
-import { ComputeShader } from "../shader/ComputeShader.js";
-import { ShaderResourceSetDescriptor } from "../shader/resource/ShaderResourceSetDescriptor.js";
-import { chunk_pose_accumulator } from "./chunk_pose_accumulator.js";
-
-const TRANSFORMS_TABLE = SCENE_DATABASE_SPEC.get('transforms');
-
-/**
- * Workgroup size for the resolve pass. Exported so dispatchers can pair
- * it with `transforms.dispatch_group_count(WORKGROUP_SIZE)`.
- */
-export const WORKGROUP_SIZE = 64;
-
-const PG_PREFIX = TRANSFORMS_TABLE.page_iterator_symbol_prefix(WORKGROUP_SIZE, true);
-
-const resources = new ShaderResourceSetDescriptor();
-resources.createGroup()
-    .addStorageBuffer('scene_database', WebGPUArray.from(u32), true)
-    .addStorageBuffer('pose_accumulator', WebGPUArray.from(atomic_u32), true);
-
-const body = CodeChunk.from(
-    //language=WGSL
-    `
-@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(&scene_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;
-    }
-
-    // Absolute transforms-table row index. The accumulator is laid out
-    // one slot per row at the same index, so this is also the
-    // accumulator slot.
-    let row = ${PG_PREFIX}_slot_to_index(slot_in_page);
-
-    let slot_base = pose_accumulator_slot_base(row);
-    let dirty_word = slot_base + POSE_OFFSET_DIRTY;
-
-    // Single load of the dirty mask gates the whole resolve. If
-    // nothing was contributed to this row this frame, leave local_*
-    // alone (and the accumulator slot is already zero because the
-    // previous resolve drained it).
-    let dirty = atomicLoad(&pose_accumulator[dirty_word]);
-    if dirty == 0u {
-        return;
-    }
-
-    // ── Translation ───────────────────────────────────────────────
-    if (dirty & POSE_DIRTY_T_MASK) != 0u {
-        let t_base = slot_base + POSE_OFFSET_TRANSLATION;
-        // Per-axis: only overwrite the channels that actually had a
-        // contribution. Read the current local_translation through
-        // the rw helper and patch the dirty channels in-place — the
-        // sibling-axis race that the old direct writer already
-        // tolerated still applies (two threads writing different
-        // axes of the same node), but we now have at most one resolve
-        // thread per row, so it never triggers here.
-        var t = scene_read_node_rw(&scene_database, row).local_translation;
-        if (dirty & POSE_DIRTY_TX) != 0u {
-            t.x = bitcast<f32>(atomicLoad(&pose_accumulator[t_base + 0u]));
-            atomicStore(&pose_accumulator[t_base + 0u], 0u);
-        }
-        if (dirty & POSE_DIRTY_TY) != 0u {
-            t.y = bitcast<f32>(atomicLoad(&pose_accumulator[t_base + 1u]));
-            atomicStore(&pose_accumulator[t_base + 1u], 0u);
-        }
-        if (dirty & POSE_DIRTY_TZ) != 0u {
-            t.z = bitcast<f32>(atomicLoad(&pose_accumulator[t_base + 2u]));
-            atomicStore(&pose_accumulator[t_base + 2u], 0u);
-        }
-        scene_write_node_local_translation(&scene_database, row, t);
-    }
-
-    // ── Rotation ──────────────────────────────────────────────────
-    if (dirty & POSE_DIRTY_R) != 0u {
-        let r_base = slot_base + POSE_OFFSET_ROTATION;
-        let r = vec4<f32>(
-            bitcast<f32>(atomicLoad(&pose_accumulator[r_base + 0u])),
-            bitcast<f32>(atomicLoad(&pose_accumulator[r_base + 1u])),
-            bitcast<f32>(atomicLoad(&pose_accumulator[r_base + 2u])),
-            bitcast<f32>(atomicLoad(&pose_accumulator[r_base + 3u])),
-        );
-        atomicStore(&pose_accumulator[r_base + 0u], 0u);
-        atomicStore(&pose_accumulator[r_base + 1u], 0u);
-        atomicStore(&pose_accumulator[r_base + 2u], 0u);
-        atomicStore(&pose_accumulator[r_base + 3u], 0u);
-        // A sum of length zero carries no orientation to recover: every
-        // clip that writes this rotation is playing at weight zero, and
-        // the apply pass contributes to a bound clip whatever its
-        // weight. \`normalize\` answers NaN there, and one NaN local
-        // rotation reaches every skin matrix naming the joint, so the
-        // meshes it drives stop rasterising altogether — a rig loses a
-        // limb because a clip nobody is playing happens to be the only
-        // one that rotates it. Leaving the row alone is the rest pose,
-        // which is the answer the CPU twin gives (\`pose_evaluate_local\`)
-        // and the value the row still holds.
-        //
-        // Otherwise: the weighted-quaternion sum (\`w_i * q_i\`) is the
-        // standard nlerp blend numerator; normalise here, once, after
-        // every contributor has been folded in. The apply pass
-        // canonicalised signs at GLTF load so we don't hit the antipode
-        // case for imported clips.
-        if length(r) > 0.0 {
-            scene_write_node_local_rotation(&scene_database, row, normalize(r));
-        }
-    }
-
-    // ── Scale ─────────────────────────────────────────────────────
-    if (dirty & POSE_DIRTY_S_MASK) != 0u {
-        let s_base = slot_base + POSE_OFFSET_SCALE;
-        var s = scene_read_node_rw(&scene_database, row).local_scale;
-        if (dirty & POSE_DIRTY_SX) != 0u {
-            s.x = bitcast<f32>(atomicLoad(&pose_accumulator[s_base + 0u]));
-            atomicStore(&pose_accumulator[s_base + 0u], 0u);
-        }
-        if (dirty & POSE_DIRTY_SY) != 0u {
-            s.y = bitcast<f32>(atomicLoad(&pose_accumulator[s_base + 1u]));
-            atomicStore(&pose_accumulator[s_base + 1u], 0u);
-        }
-        if (dirty & POSE_DIRTY_SZ) != 0u {
-            s.z = bitcast<f32>(atomicLoad(&pose_accumulator[s_base + 2u]));
-            atomicStore(&pose_accumulator[s_base + 2u], 0u);
-        }
-        scene_write_node_local_scale(&scene_database, row, s);
-    }
-
-    // Clear the dirty mask itself last, so an interrupted resolve
-    // (theoretical — these passes don't yield) would still leave the
-    // dirty bits intact to be redone.
-    atomicStore(&pose_accumulator[dirty_word], 0u);
-}
-`, [
-        TRANSFORMS_TABLE.chunk_iterate(WORKGROUP_SIZE, true),
-        chunk_scene_database_access_rw,
-        chunk_pose_accumulator,
-    ]);
-
-/**
- * Compute shader that drains the pose accumulator into
- * `transforms_table.local_{translation,rotation,scale}`.
- *
- * Walks the transforms table via the read+write page iterator — one
- * thread per slot. For each occupied row whose accumulator slot has
- * any dirty bits set, reads the contributed components (atomic
- * loads, bitcast back to f32), writes them through the per-field
- * scene helpers, normalises rotation, and zeros the slot for next
- * frame.
- *
- * The accumulator buffer must be sized to at least
- * `transforms.dispatch_page_count * elements_per_page` rows —
- * {@link GPUAnimationManager#ensure_pose_accumulator_capacity}
- * handles that.
- *
- * Dispatch via
- * `shader_animation_pose_resolve.dispatch({ group_count_x: transforms.dispatch_group_count(WORKGROUP_SIZE), ... })`.
- */
-export const shader_animation_pose_resolve = ComputeShader.from({
-    label: "Animation/PoseResolve",
-    body,
-    resources,
-    group_size: [WORKGROUP_SIZE, 1, 1],
-});
+import { atomic_u32, u32 } from "../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../shader/type/WebGPUArray.js";
+import { chunk_scene_database_access_rw } from "../scene/chunk_scene_database_access.js";
+import { SCENE_DATABASE_SPEC } from "../scene/SCENE_DATABASE_SPEC.js";
+import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../shader/resource/ShaderResourceSetDescriptor.js";
+import { chunk_pose_accumulator } from "./chunk_pose_accumulator.js";
+
+const TRANSFORMS_TABLE = SCENE_DATABASE_SPEC.get('transforms');
+
+/**
+ * Workgroup size for the resolve pass. Exported so dispatchers can pair
+ * it with `transforms.dispatch_group_count(WORKGROUP_SIZE)`.
+ */
+export const WORKGROUP_SIZE = 64;
+
+const PG_PREFIX = TRANSFORMS_TABLE.page_iterator_symbol_prefix(WORKGROUP_SIZE, true);
+
+const resources = new ShaderResourceSetDescriptor();
+resources.createGroup()
+    .addStorageBuffer('scene_database', WebGPUArray.from(u32), true)
+    .addStorageBuffer('pose_accumulator', WebGPUArray.from(atomic_u32), true);
+
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+@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(&scene_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;
+    }
+
+    // Absolute transforms-table row index. The accumulator is laid out
+    // one slot per row at the same index, so this is also the
+    // accumulator slot.
+    let row = ${PG_PREFIX}_slot_to_index(slot_in_page);
+
+    let slot_base = pose_accumulator_slot_base(row);
+    let dirty_word = slot_base + POSE_OFFSET_DIRTY;
+
+    // Single load of the dirty mask gates the whole resolve. If
+    // nothing was contributed to this row this frame, leave local_*
+    // alone (and the accumulator slot is already zero because the
+    // previous resolve drained it).
+    let dirty = atomicLoad(&pose_accumulator[dirty_word]);
+    if dirty == 0u {
+        return;
+    }
+
+    // ── Translation ───────────────────────────────────────────────
+    if (dirty & POSE_DIRTY_T_MASK) != 0u {
+        let t_base = slot_base + POSE_OFFSET_TRANSLATION;
+        // Per-axis: only overwrite the channels that actually had a
+        // contribution. Read the current local_translation through
+        // the rw helper and patch the dirty channels in-place — the
+        // sibling-axis race that the old direct writer already
+        // tolerated still applies (two threads writing different
+        // axes of the same node), but we now have at most one resolve
+        // thread per row, so it never triggers here.
+        var t = scene_read_node_rw(&scene_database, row).local_translation;
+        if (dirty & POSE_DIRTY_TX) != 0u {
+            t.x = bitcast<f32>(atomicLoad(&pose_accumulator[t_base + 0u]));
+            atomicStore(&pose_accumulator[t_base + 0u], 0u);
+        }
+        if (dirty & POSE_DIRTY_TY) != 0u {
+            t.y = bitcast<f32>(atomicLoad(&pose_accumulator[t_base + 1u]));
+            atomicStore(&pose_accumulator[t_base + 1u], 0u);
+        }
+        if (dirty & POSE_DIRTY_TZ) != 0u {
+            t.z = bitcast<f32>(atomicLoad(&pose_accumulator[t_base + 2u]));
+            atomicStore(&pose_accumulator[t_base + 2u], 0u);
+        }
+        scene_write_node_local_translation(&scene_database, row, t);
+    }
+
+    // ── Rotation ──────────────────────────────────────────────────
+    if (dirty & POSE_DIRTY_R) != 0u {
+        let r_base = slot_base + POSE_OFFSET_ROTATION;
+        let r = vec4<f32>(
+            bitcast<f32>(atomicLoad(&pose_accumulator[r_base + 0u])),
+            bitcast<f32>(atomicLoad(&pose_accumulator[r_base + 1u])),
+            bitcast<f32>(atomicLoad(&pose_accumulator[r_base + 2u])),
+            bitcast<f32>(atomicLoad(&pose_accumulator[r_base + 3u])),
+        );
+        atomicStore(&pose_accumulator[r_base + 0u], 0u);
+        atomicStore(&pose_accumulator[r_base + 1u], 0u);
+        atomicStore(&pose_accumulator[r_base + 2u], 0u);
+        atomicStore(&pose_accumulator[r_base + 3u], 0u);
+        // A sum of length zero carries no orientation to recover: every
+        // clip that writes this rotation is playing at weight zero, and
+        // the apply pass contributes to a bound clip whatever its
+        // weight. \`normalize\` answers NaN there, and one NaN local
+        // rotation reaches every skin matrix naming the joint, so the
+        // meshes it drives stop rasterising altogether — a rig loses a
+        // limb because a clip nobody is playing happens to be the only
+        // one that rotates it. Leaving the row alone is the rest pose,
+        // which is the answer the CPU twin gives (\`pose_evaluate_local\`)
+        // and the value the row still holds.
+        //
+        // Otherwise: the weighted-quaternion sum (\`w_i * q_i\`) is the
+        // standard nlerp blend numerator; normalise here, once, after
+        // every contributor has been folded in. The apply pass
+        // canonicalised signs at GLTF load so we don't hit the antipode
+        // case for imported clips.
+        if length(r) > 0.0 {
+            scene_write_node_local_rotation(&scene_database, row, normalize(r));
+        }
+    }
+
+    // ── Scale ─────────────────────────────────────────────────────
+    if (dirty & POSE_DIRTY_S_MASK) != 0u {
+        let s_base = slot_base + POSE_OFFSET_SCALE;
+        var s = scene_read_node_rw(&scene_database, row).local_scale;
+        if (dirty & POSE_DIRTY_SX) != 0u {
+            s.x = bitcast<f32>(atomicLoad(&pose_accumulator[s_base + 0u]));
+            atomicStore(&pose_accumulator[s_base + 0u], 0u);
+        }
+        if (dirty & POSE_DIRTY_SY) != 0u {
+            s.y = bitcast<f32>(atomicLoad(&pose_accumulator[s_base + 1u]));
+            atomicStore(&pose_accumulator[s_base + 1u], 0u);
+        }
+        if (dirty & POSE_DIRTY_SZ) != 0u {
+            s.z = bitcast<f32>(atomicLoad(&pose_accumulator[s_base + 2u]));
+            atomicStore(&pose_accumulator[s_base + 2u], 0u);
+        }
+        scene_write_node_local_scale(&scene_database, row, s);
+    }
+
+    // Clear the dirty mask itself last, so an interrupted resolve
+    // (theoretical — these passes don't yield) would still leave the
+    // dirty bits intact to be redone.
+    atomicStore(&pose_accumulator[dirty_word], 0u);
+}
+`, [
+        TRANSFORMS_TABLE.chunk_iterate(WORKGROUP_SIZE, true),
+        chunk_scene_database_access_rw,
+        chunk_pose_accumulator,
+    ]);
+
+/**
+ * Compute shader that drains the pose accumulator into
+ * `transforms_table.local_{translation,rotation,scale}`.
+ *
+ * Walks the transforms table via the read+write page iterator — one
+ * thread per slot. For each occupied row whose accumulator slot has
+ * any dirty bits set, reads the contributed components (atomic
+ * loads, bitcast back to f32), writes them through the per-field
+ * scene helpers, normalises rotation, and zeros the slot for next
+ * frame.
+ *
+ * The accumulator buffer must be sized to at least
+ * `transforms.dispatch_page_count * elements_per_page` rows —
+ * {@link GPUAnimationManager#ensure_pose_accumulator_capacity}
+ * handles that.
+ *
+ * Dispatch via
+ * `shader_animation_pose_resolve.dispatch({ group_count_x: transforms.dispatch_group_count(WORKGROUP_SIZE), ... })`.
+ */
+export const shader_animation_pose_resolve = ComputeShader.from({
+    label: "Animation/PoseResolve",
+    body,
+    resources,
+});

package/src/shade/renderer/animation/shader_animation_tick.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_animation_tick.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/animation/shader_animation_tick.js"],"names":[],"mappings":"AAUA;;;;;GAKG;AACH,gCAAiC;AAuFjC;;;;;;;;;;;;;;;;GAgBG;AACH,kDAKG;8BA1H2B,4BAA4B"}
+{"version":3,"file":"shader_animation_tick.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/animation/shader_animation_tick.js"],"names":[],"mappings":"AAUA;;;;;GAKG;AACH,gCAAiC;AA0FjC;;;;;;;;;;;;;;;;GAgBG;AACH,kDAIG;8BA5H2B,4BAA4B"}

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

@@ -25,8 +25,11 @@ const PG_PREFIX = CLIP_TABLE.page_iterator_symbol_prefix(WORKGROUP_SIZE, true);
 // `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()
-    .addUniform('dt', f32)
     .addStorageBuffer('animation_database', WebGPUArray.from(u32), true);
 
 const body = CodeChunk.from(
@@ -122,5 +125,4 @@ export const shader_animation_tick = ComputeShader.from({
     label: "Animation/Tick",
     body,
     resources,
-    group_size: [WORKGROUP_SIZE, 1, 1],
 });