@woosh/meep-engine 3.40.0 → 3.41.0

package/src/shade/renderer/animation/pose/PoseChannelIndex.js

@@ -0,0 +1,274 @@
+import { UINT32_MAP_ABSENT, Uint32Map } from "../../../../core/collection/Uint32Map.js";
+
+/**
+ * @typedef {import("../ShadeAnimationChannel.js").ShadeAnimationChannel} ShadeAnimationChannel
+ * @typedef {import("../ShadeAnimationClip.js").ShadeAnimationClip} ShadeAnimationClip
+ */
+
+/**
+ * What {@link PoseChannelIndex#group_of} answers for an entity the clip has no track for.
+ *
+ * @type {number}
+ */
+export const POSE_CHANNEL_GROUP_NONE = UINT32_MAP_ABSENT;
+
+/**
+ * The largest entity {@link Uint32Map} can hold as a key; it stores a key as `key + 1`.
+ *
+ * @type {number}
+ */
+const LARGEST_ENTITY = 0xFFFFFFFE;
+
+/**
+ * Each clip's index, built the first time a playback takes the clip and shared by every playback
+ * that takes it after — a released joint's seed takes the same clip once per joint.
+ *
+ * @type {WeakMap<ShadeAnimationClip, PoseChannelIndex>}
+ */
+const INDICES = new WeakMap();
+
+/**
+ * Per-group cursors for {@link PoseChannelIndex#holds}, grown to the largest clip seen.
+ *
+ * @type {Uint32Array}
+ */
+let CURSORS = new Uint32Array(64);
+
+/**
+ * Whether a channel names an entity — the only thing the renderer binds a channel to, so a channel
+ * naming anything else plays on nothing there either.
+ *
+ * @param {*} target
+ * @returns {boolean}
+ */
+function is_entity(target) {
+    return Number.isInteger(target) && target >= 0 && target <= LARGEST_ENTITY;
+}
+
+/**
+ * A clip's channels grouped by the entity each names, for the CPU pose twin to look one entity up
+ * in, rather than scan the whole clip for it once per level of every query.
+ *
+ * The groups are laid end to end in one array, each in the clip's own order, with a table of where
+ * each starts and a {@link Uint32Map} from entity to group: on a 70-joint clip of 210 channels it
+ * holds a few KiB, against the ~25 KiB of the clip itself, and nothing in it is handed out to be
+ * written. Read it with {@link group_of}, {@link first}, {@link end} and {@link channel}.
+ *
+ * Built once per clip ({@link of}) and checked, not rebuilt, each time a playback takes the clip
+ * again.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class PoseChannelIndex {
+    /**
+     * Entity → group.
+     *
+     * @type {Uint32Map}
+     */
+    #groups;
+
+    /**
+     * Group `g` is `#channels[#starts[g] .. #starts[g + 1])`.
+     *
+     * @type {Uint32Array}
+     */
+    #starts;
+
+    /**
+     * The clip's channels that name an entity, grouped by it, each group in the clip's order.
+     *
+     * @type {ShadeAnimationChannel[]}
+     */
+    #channels;
+
+    /**
+     * How many channels the clip held when this was built, those naming no entity included.
+     *
+     * @type {number}
+     */
+    #source_count;
+
+    /**
+     * @param {ShadeAnimationChannel[]} channels a clip's channels
+     */
+    constructor(channels) {
+        const count = channels.length;
+        const groups = new Uint32Map(8);
+        const sizes = [];
+
+        let indexed = 0;
+
+        for (let i = 0; i < count; i++) {
+            const target = channels[i].target;
+
+            if (!is_entity(target)) {
+                continue;
+            }
+
+            let group = groups.get(target);
+
+            if (group === UINT32_MAP_ABSENT) {
+                group = sizes.length;
+
+                groups.set(target, group);
+                sizes.push(0);
+            }
+
+            sizes[group]++;
+            indexed++;
+        }
+
+        const group_count = sizes.length;
+        const starts = new Uint32Array(group_count + 1);
+
+        for (let g = 0; g < group_count; g++) {
+            starts[g + 1] = starts[g] + sizes[g];
+        }
+
+        // a counting sort: each channel's slot, walking the clip in order so each group keeps it
+        const slots = new Uint32Array(indexed);
+        const cursors = starts.slice(0, group_count);
+
+        for (let i = 0; i < count; i++) {
+            const target = channels[i].target;
+
+            if (is_entity(target)) {
+                slots[cursors[groups.get(target)]++] = i;
+            }
+        }
+
+        const grouped = [];
+
+        for (let s = 0; s < indexed; s++) {
+            grouped.push(channels[slots[s]]);
+        }
+
+        this.#groups = groups;
+        this.#starts = starts;
+        this.#channels = grouped;
+        this.#source_count = count;
+    }
+
+    /**
+     * The group of channels naming `entity`, or {@link POSE_CHANNEL_GROUP_NONE} where the clip has no
+     * track for it — which is most entities for most clips.
+     *
+     * @param {number} entity
+     * @returns {number}
+     */
+    group_of(entity) {
+        return this.#groups.get(entity);
+    }
+
+    /**
+     * @param {number} group
+     * @returns {number} the position of the group's first channel
+     */
+    first(group) {
+        return this.#starts[group];
+    }
+
+    /**
+     * @param {number} group
+     * @returns {number} one past the position of the group's last channel
+     */
+    end(group) {
+        return this.#starts[group + 1];
+    }
+
+    /**
+     * @param {number} position from {@link first} up to {@link end}
+     * @returns {ShadeAnimationChannel}
+     */
+    channel(position) {
+        return this.#channels[position];
+    }
+
+    /**
+     * Whether this still describes `channels`: every channel naming an entity is where this put it
+     * — the same channel, naming the same entity, in the same order among that entity's — and there
+     * are as many as there were. A walk of the clip without allocation.
+     *
+     * @param {ShadeAnimationChannel[]} channels
+     * @returns {boolean}
+     */
+    holds(channels) {
+        const count = channels.length;
+
+        if (count !== this.#source_count) {
+            return false;
+        }
+
+        const starts = this.#starts;
+        const indexed = this.#channels;
+        const groups = this.#groups;
+        const group_count = starts.length - 1;
+
+        if (CURSORS.length < group_count) {
+            CURSORS = new Uint32Array(group_count);
+        }
+
+        const cursors = CURSORS;
+
+        cursors.fill(0, 0, group_count);
+
+        let matched = 0;
+
+        for (let i = 0; i < count; i++) {
+            const channel = channels[i];
+            const target = channel.target;
+
+            if (!is_entity(target)) {
+                continue;
+            }
+
+            const group = groups.get(target);
+
+            if (group === UINT32_MAP_ABSENT) {
+                return false;
+            }
+
+            const slot = starts[group] + cursors[group];
+
+            if (slot >= starts[group + 1] || indexed[slot] !== channel) {
+                return false;
+            }
+
+            cursors[group]++;
+            matched++;
+        }
+
+        return matched === indexed.length;
+    }
+
+    /**
+     * The clip's index, as the clip holds its channels now: the one built before when it still
+     * holds, a new one otherwise.
+     *
+     * @param {ShadeAnimationClip} clip
+     * @returns {PoseChannelIndex}
+     */
+    static of(clip) {
+        const channels = clip.channels;
+        const cached = INDICES.get(clip);
+
+        if (cached !== undefined && cached.holds(channels)) {
+            return cached;
+        }
+
+        const index = new PoseChannelIndex(channels);
+
+        INDICES.set(clip, index);
+
+        return index;
+    }
+}
+
+/**
+ * What a playback with no clip holds: no groups at all.
+ *
+ * @readonly
+ * @type {PoseChannelIndex}
+ */
+PoseChannelIndex.EMPTY = new PoseChannelIndex([]);

package/src/shade/renderer/animation/pose/PosePlayback.d.ts

@@ -17,11 +17,46 @@ export class PosePlayback {
      */
     static from(clip: ShadeAnimationClip, time: number, weight: number): PosePlayback;
     /**
-     * @type {ShadeAnimationClip}
+     * Assigning a clip reads its {@link start_time} once, here: `ShadeAnimationClip.start_time`
+     * walks every channel and every curve, and the evaluator runs per node of every query — reading
+     * it there tripled the cost of a whole-skeleton pass. Assigning the clip already held reads
+     * nothing, so a producer that refreshes its playbacks per query pays for it once per clip.
+     *
+     * It reads the clip's channels here too, grouped by the entity each names
+     * ({@link channel_index}), for the same reason: the evaluator asks once per level of every
+     * query, and scanning the whole clip for the few channels of one joint made its cost grow with
+     * every clip a model has bound. The grouping is built once per clip and shared, and taking the
+     * clip again only checks that it still holds.
+     *
+     * A clip's channels are taken as settled once it plays, as the renderer takes them when it
+     * registers the clip.
+     *
+     * @param {ShadeAnimationClip|null} clip
+     */
+    set clip(clip: any);
+    /**
+     * @returns {ShadeAnimationClip|null}
+     */
+    get clip(): any;
+    /**
+     * The clip's channels grouped by the entity each names, as they were when the clip was assigned;
+     * {@link PoseChannelIndex.EMPTY} while there is no clip.
+     *
+     * @returns {PoseChannelIndex}
+     */
+    get channel_index(): PoseChannelIndex;
+    /**
+     * Where {@link time} 0 sits on the clip's curves: its earliest key. The renderer's clip record
+     * takes the same origin at registration (`time_start`), which is what has the two sample one
+     * instant — a glTF clip keeps its file's key times, and its first key need not be at zero.
+     *
+     * @returns {number}
      */
-    clip: ShadeAnimationClip;
+    get start_time(): number;
     /**
-     * Seconds into the clip. Not wrapped for you — a caller that loops decides what looping means.
+     * Seconds into the clip, from its {@link start_time} — the renderer's clip record measures its
+     * `time` the same way, and both players run their clocks over `[0, duration]`. Not wrapped for
+     * you — a caller that loops decides what looping means.
      *
      * @type {number}
      */
@@ -36,5 +71,7 @@ export class PosePlayback {
      * @type {number}
      */
     weight: number;
+    #private;
 }
+import { PoseChannelIndex } from "./PoseChannelIndex.js";
 //# sourceMappingURL=PosePlayback.d.ts.map

package/src/shade/renderer/animation/pose/PosePlayback.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PosePlayback.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/animation/pose/PosePlayback.js"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AACH;IAwBI;;;;;OAKG;IACH,4CAJW,MAAM,UACN,MAAM,GACJ,YAAY,CAcxB;IAzCD;;OAEG;IACH,yBAAY;IAEZ;;;;OAIG;IACH,MAFU,MAAM,CAEP;IAET;;;;;;;;OAQG;IACH,QAFU,MAAM,CAEL;CAqBd"}
+{"version":3,"file":"PosePlayback.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/animation/pose/PosePlayback.js"],"names":[],"mappings":"AAGA;;;;;;;;;GASG;AACH;IAiGI;;;;;OAKG;IACH,4CAJW,MAAM,UACN,MAAM,GACJ,YAAY,CAcxB;IA5FD;;;;;;;;;;;;;;;;OAgBG;IACH,oBAcC;IAtCD;;OAEG;IACH,gBAEC;IAmCD;;;;;OAKG;IACH,sCAEC;IAED;;;;;;OAMG;IACH,yBAEC;IAED;;;;;;OAMG;IACH,MAFU,MAAM,CAEP;IAET;;;;;;;;OAQG;IACH,QAFU,MAAM,CAEL;;CAqBd;iCAhIgC,uBAAuB"}

package/src/shade/renderer/animation/pose/PosePlayback.js

@@ -1,4 +1,5 @@
 import { assert } from "../../../../core/assert.js";
+import { PoseChannelIndex } from "./PoseChannelIndex.js";
 
 /**
  * One clip contributing to a pose: which clip, where in it, and how much of it.
@@ -12,12 +13,85 @@ import { assert } from "../../../../core/assert.js";
  */
 export class PosePlayback {
     /**
-     * @type {ShadeAnimationClip}
+     * @type {ShadeAnimationClip|null}
      */
-    clip = null;
+    #clip = null;
 
     /**
-     * Seconds into the clip. Not wrapped for you — a caller that loops decides what looping means.
+     * @type {number}
+     */
+    #start_time = 0;
+
+    /**
+     * @type {PoseChannelIndex}
+     */
+    #channel_index = PoseChannelIndex.EMPTY;
+
+    /**
+     * @returns {ShadeAnimationClip|null}
+     */
+    get clip() {
+        return this.#clip;
+    }
+
+    /**
+     * Assigning a clip reads its {@link start_time} once, here: `ShadeAnimationClip.start_time`
+     * walks every channel and every curve, and the evaluator runs per node of every query — reading
+     * it there tripled the cost of a whole-skeleton pass. Assigning the clip already held reads
+     * nothing, so a producer that refreshes its playbacks per query pays for it once per clip.
+     *
+     * It reads the clip's channels here too, grouped by the entity each names
+     * ({@link channel_index}), for the same reason: the evaluator asks once per level of every
+     * query, and scanning the whole clip for the few channels of one joint made its cost grow with
+     * every clip a model has bound. The grouping is built once per clip and shared, and taking the
+     * clip again only checks that it still holds.
+     *
+     * A clip's channels are taken as settled once it plays, as the renderer takes them when it
+     * registers the clip.
+     *
+     * @param {ShadeAnimationClip|null} clip
+     */
+    set clip(clip) {
+        if (clip === this.#clip) {
+            return;
+        }
+
+        this.#clip = clip;
+
+        if (clip === null) {
+            this.#start_time = 0;
+            this.#channel_index = PoseChannelIndex.EMPTY;
+        } else {
+            this.#start_time = clip.start_time;
+            this.#channel_index = PoseChannelIndex.of(clip);
+        }
+    }
+
+    /**
+     * The clip's channels grouped by the entity each names, as they were when the clip was assigned;
+     * {@link PoseChannelIndex.EMPTY} while there is no clip.
+     *
+     * @returns {PoseChannelIndex}
+     */
+    get channel_index() {
+        return this.#channel_index;
+    }
+
+    /**
+     * Where {@link time} 0 sits on the clip's curves: its earliest key. The renderer's clip record
+     * takes the same origin at registration (`time_start`), which is what has the two sample one
+     * instant — a glTF clip keeps its file's key times, and its first key need not be at zero.
+     *
+     * @returns {number}
+     */
+    get start_time() {
+        return this.#start_time;
+    }
+
+    /**
+     * Seconds into the clip, from its {@link start_time} — the renderer's clip record measures its
+     * `time` the same way, and both players run their clocks over `[0, duration]`. Not wrapped for
+     * you — a caller that loops decides what looping means.
      *
      * @type {number}
      */

package/src/shade/renderer/animation/pose/pose_evaluate_local.d.ts

@@ -6,26 +6,44 @@
  * into a per-row slot (`POSE_ACCUMULATOR_LAYOUT`) and then drains it
  * (`shader_animation_pose_resolve`); the rules reproduced here are that drain's, exactly:
  *
+ * - **A clip is sampled at its start plus its time** — {@link PosePlayback.start_time}, its earliest
+ *   key, is the apply pass's `clip.time_start`.
  * - **A channel that contributed replaces its axis; one that did not leaves the rest pose alone.**
  *   Translation and scale track this per axis, because a channel may animate only one of them.
  * - **Rotation is a weighted sum, normalised once at the end** — nlerp, not slerp, and normalising
  *   is what turns the sum back into a rotation. It is tracked with a single dirty bit because all
  *   four components always move together.
  * - **Weights are not normalised.** See {@link PosePlayback.weight}.
+ * - **A clip at weight zero still writes**: the accumulator takes a bound clip's contribution
+ *   whatever its weight, so the axes it keys resolve to the sum of what was added. It adds its value
+ *   times zero, which leaves any finite sum where it was, so here its curves are not sampled — only
+ *   its axes are marked. The two part only where a silent clip's curve would sample to something
+ *   that is not a finite number — an infinite key, or keys whose interpolation overflows — which
+ *   the GPU multiplies by zero for no number at all, and which adds nothing here.
  *
  * Where the two disagree, the GPU is right by definition — it is what is on screen — and this is
  * the thing to fix. `pose_evaluator_lockstep.spec.js` fails when the WGSL moves, so that the pair
  * cannot drift silently.
  *
+ * A call costs a lookup per playback and the curves of the channels that name `target` in the
+ * audible ones — not a scan of every clip: each playback holds its clip's channels grouped by
+ * entity ({@link PosePlayback#channel_index}), read once when it took the clip. A model with many
+ * clips bound and few playing pays little more than one with only the few.
+ *
  * `rest` supplies the rest pose: the node's or the entity's authored local offset. That is sound
  * because the CPU never writes a GPU-authoritative row, so what the authored offset holds is what
- * the row started from, and undirty axes on the GPU hold the same value for the same reason.
+ * the row started from, and undirty axes on the GPU hold the same value for the same reason. A CPU
+ * writer's hold is how the offset may move under a bound clip, and its end hands the offset the
+ * holder left to the row (`GPUSceneRows#mark_handover`) and to every binding as its rest
+ * (`GPUAnimationManager#unmute`), so the same holds after it. Anything else writing a driven
+ * joint's offset breaks this, and the twin then answers a rest the GPU does not have.
  *
  * @param {Transform64} result written with the evaluated local TRS; its matrix is left stale
- * @param {Node3D|number} target what the channels name — a node, or an entity
+ * @param {number} target the entity the channels name
  * @param {Transform64} rest the target's authored local pose
  * @param {PosePlayback[]} playbacks
  * @returns {Transform64} `result`
  */
-export function pose_evaluate_local(result: Transform64, target: Node3D | number, rest: Transform64, playbacks: PosePlayback[]): Transform64;
+export function pose_evaluate_local(result: Transform64, target: number, rest: Transform64, playbacks: PosePlayback[]): Transform64;
+export type ShadeAnimationChannel = import("../ShadeAnimationChannel.js").ShadeAnimationChannel;
 //# sourceMappingURL=pose_evaluate_local.d.ts.map

package/src/shade/renderer/animation/pose/pose_evaluate_local.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pose_evaluate_local.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/animation/pose/pose_evaluate_local.js"],"names":[],"mappings":"AAmBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,iEALW,SAAO,MAAM,gCAEb,cAAc,eAqIxB"}
+{"version":3,"file":"pose_evaluate_local.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/animation/pose/pose_evaluate_local.js"],"names":[],"mappings":"AAqDA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,iEALW,MAAM,gCAEN,cAAc,eAsJxB;oCAjPY,OAAO,6BAA6B,EAAE,qBAAqB"}

package/src/shade/renderer/animation/pose/pose_evaluate_local.js

@@ -1,5 +1,10 @@
 import { assert } from "../../../../core/assert.js";
 import { Node3DProperty } from "../../object_property/Node3DProperty.js";
+import { POSE_CHANNEL_GROUP_NONE } from "./PoseChannelIndex.js";
+
+/**
+ * @typedef {import("../ShadeAnimationChannel.js").ShadeAnimationChannel} ShadeAnimationChannel
+ */
 
 /**
  * Per-axis accumulators, reused across calls. The evaluator is a query on a gameplay path and can
@@ -17,6 +22,35 @@ const DIRTY_SX = 16;
 const DIRTY_SY = 32;
 const DIRTY_SZ = 64;
 
+/**
+ * What a channel writes, as dirty bits: each translation or scale axis it has a curve for, and the
+ * rotation whole — what the accumulator marks for it at any weight.
+ *
+ * @param {ShadeAnimationChannel} channel
+ * @returns {number}
+ */
+function channel_dirty_bits(channel) {
+    const curves = channel.curves;
+
+    switch (channel.property) {
+        case Node3DProperty.Translation:
+            return (curves.x !== undefined ? DIRTY_TX : 0)
+                | (curves.y !== undefined ? DIRTY_TY : 0)
+                | (curves.z !== undefined ? DIRTY_TZ : 0);
+
+        case Node3DProperty.Rotation:
+            return DIRTY_R;
+
+        case Node3DProperty.Scale:
+            return (curves.x !== undefined ? DIRTY_SX : 0)
+                | (curves.y !== undefined ? DIRTY_SY : 0)
+                | (curves.z !== undefined ? DIRTY_SZ : 0);
+
+        default:
+            return 0;
+    }
+}
+
 /**
  * Evaluate one node's local pose from a set of playing clips, into `result`.
  *
@@ -25,23 +59,40 @@ const DIRTY_SZ = 64;
  * into a per-row slot (`POSE_ACCUMULATOR_LAYOUT`) and then drains it
  * (`shader_animation_pose_resolve`); the rules reproduced here are that drain's, exactly:
  *
+ * - **A clip is sampled at its start plus its time** — {@link PosePlayback.start_time}, its earliest
+ *   key, is the apply pass's `clip.time_start`.
  * - **A channel that contributed replaces its axis; one that did not leaves the rest pose alone.**
  *   Translation and scale track this per axis, because a channel may animate only one of them.
  * - **Rotation is a weighted sum, normalised once at the end** — nlerp, not slerp, and normalising
  *   is what turns the sum back into a rotation. It is tracked with a single dirty bit because all
  *   four components always move together.
  * - **Weights are not normalised.** See {@link PosePlayback.weight}.
+ * - **A clip at weight zero still writes**: the accumulator takes a bound clip's contribution
+ *   whatever its weight, so the axes it keys resolve to the sum of what was added. It adds its value
+ *   times zero, which leaves any finite sum where it was, so here its curves are not sampled — only
+ *   its axes are marked. The two part only where a silent clip's curve would sample to something
+ *   that is not a finite number — an infinite key, or keys whose interpolation overflows — which
+ *   the GPU multiplies by zero for no number at all, and which adds nothing here.
  *
  * Where the two disagree, the GPU is right by definition — it is what is on screen — and this is
  * the thing to fix. `pose_evaluator_lockstep.spec.js` fails when the WGSL moves, so that the pair
  * cannot drift silently.
  *
+ * A call costs a lookup per playback and the curves of the channels that name `target` in the
+ * audible ones — not a scan of every clip: each playback holds its clip's channels grouped by
+ * entity ({@link PosePlayback#channel_index}), read once when it took the clip. A model with many
+ * clips bound and few playing pays little more than one with only the few.
+ *
  * `rest` supplies the rest pose: the node's or the entity's authored local offset. That is sound
  * because the CPU never writes a GPU-authoritative row, so what the authored offset holds is what
- * the row started from, and undirty axes on the GPU hold the same value for the same reason.
+ * the row started from, and undirty axes on the GPU hold the same value for the same reason. A CPU
+ * writer's hold is how the offset may move under a bound clip, and its end hands the offset the
+ * holder left to the row (`GPUSceneRows#mark_handover`) and to every binding as its rest
+ * (`GPUAnimationManager#unmute`), so the same holds after it. Anything else writing a driven
+ * joint's offset breaks this, and the twin then answers a rest the GPU does not have.
  *
  * @param {Transform64} result written with the evaluated local TRS; its matrix is left stale
- * @param {Node3D|number} target what the channels name — a node, or an entity
+ * @param {number} target the entity the channels name
  * @param {Transform64} rest the target's authored local pose
  * @param {PosePlayback[]} playbacks
  * @returns {Transform64} `result`
@@ -69,17 +120,33 @@ export function pose_evaluate_local(result, target, rest, playbacks) {
 
     for (let p = 0; p < playbacks.length; p++) {
         const playback = playbacks[p];
-        const weight = playback.weight;
-        const time = playback.time;
-        const channels = playback.clip.channels;
+        const index = playback.channel_index;
+        // only the channels that name this target, which most clips have none of
+        const group = index.group_of(target);
+
+        if (group === POSE_CHANNEL_GROUP_NONE) {
+            continue;
+        }
 
-        for (let c = 0; c < channels.length; c++) {
-            const channel = channels[c];
+        const first = index.first(group);
+        const end = index.end(group);
 
-            if (channel.target !== target) {
-                continue;
+        const weight = playback.weight;
+
+        if (weight === 0) {
+            // it writes, and adds nothing to what it writes: mark its axes, sample nothing
+            for (let c = first; c < end; c++) {
+                dirty |= channel_dirty_bits(index.channel(c));
             }
 
+            continue;
+        }
+
+        // the apply pass's `clip.time + clip.time_start`
+        const time = playback.start_time + playback.time;
+
+        for (let c = first; c < end; c++) {
+            const channel = index.channel(c);
             const curves = channel.curves;
 
             switch (channel.property) {
@@ -160,8 +227,9 @@ export function pose_evaluate_local(result, target, rest, playbacks) {
         // A quaternion sum of length zero has no orientation in it to recover. The ordinary way in
         // is a joint whose rotation only clips at weight zero write — the accumulator takes a bound
         // clip's contribution whatever its weight — and the other is contributions that cancelled
-        // exactly. The GPU leaves the row alone there, which is the rest pose because nothing has
-        // written a rotation to it; this says the same thing from the node.
+        // exactly. The answer is the rest pose: the GPU writes the rest rotation every
+        // contribution carried from its binding, which was taken from this same rest when the clip
+        // bound the target.
         const length = Math.sqrt(x * x + y * y + z * z + w * w);
 
         if (length > 0) {

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

@@ -86,7 +86,7 @@ fn main(
 
     let value = animation_track_evaluate(effective_time, track, &animation_database) * weight;
 
-    write_object_property(binding.instance, binding.property, track.mask, value, weight);
+    write_object_property(binding.instance, binding.property, track.mask, value, weight, binding.rest_rotation);
 }
 `, [
         BINDING_TABLE.chunk_iterate(WORKGROUP_SIZE),

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

@@ -11,8 +11,9 @@ export const WORKGROUP_SIZE: 64;
  * 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.
+ * scene helpers, normalises rotation — or, for a rotation summing to
+ * nothing, writes the rest rotation the contributions carried — and
+ * zeros the sums and the dirty mask for next frame.
  *
  * The accumulator buffer must be sized to at least
  * `transforms.dispatch_page_count * elements_per_page` rows —

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,0DAIG;8BA1K2B,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;AAmJjC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,0DAIG;8BArL2B,4BAA4B"}