@aura3d/engine 3.0.1 → 4.0.0

package/dist/animation/pose/PoseMixer.js

@@ -0,0 +1,848 @@
+import { sampleClipEvents } from "../AnimationClipEvents.js";
+import { compileClip, createTrackCursors, sampleTrackInto } from "./CompiledClip.js";
+import { lerpVec3Flat, multiplyQuatFlat, slerpQuatFlat } from "./quatFlat.js";
+import { isClipAdditive } from "./makeClipAdditive.js";
+export class PoseAction {
+    mixer;
+    clipName;
+    clip;
+    bindings;
+    cursors;
+    additive;
+    weight = 1;
+    timeScale = 1;
+    time = 0;
+    playing = false;
+    paused = false;
+    enabled = true;
+    loopMode = "repeat";
+    repetitions = Infinity;
+    clampWhenFinished = false;
+    syncGroupName = null;
+    pingPongForward = true;
+    loopCount = -1;
+    fade = null;
+    warpState = null;
+    restoreTimeScale = null;
+    effectiveWeight = 0;
+    effectiveTimeScale = 0;
+    constructor(mixer, clipName, clip, options = {}) {
+        this.mixer = mixer;
+        this.clipName = clipName;
+        this.clip = clip;
+        this.bindings = mixer.resolveBindings(clip);
+        this.cursors = createTrackCursors(clip);
+        const source = mixer.sourceClip(clipName);
+        this.additive = options.additive ?? (source !== undefined && isClipAdditive(source));
+        this.weight = options.weight ?? 1;
+        this.timeScale = options.timeScale ?? 1;
+        if (options.loopMode)
+            this.loopMode = options.loopMode;
+        if (options.repetitions !== undefined)
+            this.repetitions = options.repetitions;
+        this.clampWhenFinished = options.clampWhenFinished ?? false;
+        this.syncGroupName = options.syncGroup ?? null;
+    }
+    play() {
+        this.playing = true;
+        this.paused = false;
+        this.enabled = true;
+        this.mixer.activate(this);
+        return this;
+    }
+    stop() {
+        this.playing = false;
+        this.paused = false;
+        this.time = 0;
+        this.loopCount = -1;
+        this.pingPongForward = true;
+        this.mixer.deactivate(this);
+        return this;
+    }
+    pause() {
+        this.paused = true;
+        return this;
+    }
+    setEffectiveWeight(weight) {
+        this.weight = weight;
+        return this;
+    }
+    setEffectiveTimeScale(timeScale) {
+        this.timeScale = timeScale;
+        return this;
+    }
+    setLoop(mode, repetitions = Infinity) {
+        this.loopMode = mode;
+        this.repetitions = repetitions;
+        return this;
+    }
+    /** three r185 syncWith: copy time + timeScale and stop any warping. */
+    syncWith(other) {
+        this.time = other.time;
+        this.timeScale = other.timeScale;
+        this.stopWarping();
+        return this;
+    }
+    fadeIn(duration) {
+        return this.scheduleFade(duration, 0, 1);
+    }
+    fadeOut(duration) {
+        return this.scheduleFade(duration, 1, 0);
+    }
+    fadeTo(weight, duration) {
+        return this.scheduleFade(duration, this.weight, weight);
+    }
+    /** three r185 warp: multiplicative timescale interpolant over mixer time (values = start/base → end/base). */
+    warp(startTimeScale, endTimeScale, duration) {
+        const now = this.mixer.time;
+        const base = this.timeScale;
+        this.warpState = { startTime: now, duration, from: startTimeScale / base, to: endTimeScale / base };
+        return this;
+    }
+    stopWarping() {
+        this.warpState = null;
+        this.restoreTimeScale = null;
+        return this;
+    }
+    stopFading() {
+        this.fade = null;
+        return this;
+    }
+    /** three r185 crossFadeFrom(this=fadeIn, fadeOut, duration, warp). */
+    crossFadeFrom(fadeOutAction, duration, warp = false) {
+        fadeOutAction.fadeOut(duration);
+        this.fadeIn(duration);
+        if (warp) {
+            const fadeInDuration = this.clip.duration;
+            const fadeOutDuration = fadeOutAction.clip.duration;
+            const startEndRatio = fadeInDuration === 0 ? 1 : fadeOutDuration / fadeInDuration;
+            const endStartRatio = fadeOutDuration === 0 ? 1 : fadeInDuration / fadeOutDuration;
+            fadeOutAction.restoreTimeScale = fadeOutAction.timeScale;
+            this.restoreTimeScale = this.timeScale;
+            fadeOutAction.warp(1.0, startEndRatio, duration);
+            this.warp(endStartRatio, 1.0, duration);
+        }
+        return this;
+    }
+    crossFadeTo(fadeInAction, duration, warp = false) {
+        return fadeInAction.crossFadeFrom(this, duration, warp);
+    }
+    get normalizedPhase() {
+        return this.clip.duration > 0 ? this.time / this.clip.duration : 0;
+    }
+    scheduleFade(duration, weightNow, weightThen) {
+        const now = this.mixer.time;
+        if (duration <= 0) {
+            this.fade = null;
+            this.weight = weightThen;
+            return this;
+        }
+        this.fade = { startTime: now, duration, from: weightNow, to: weightThen };
+        return this;
+    }
+    /** Effective weight at mixer.time, per r185 `_updateWeight`. */
+    updateWeight(now) {
+        let weight = 0;
+        if (this.enabled) {
+            weight = this.weight;
+            const fade = this.fade;
+            if (fade !== null) {
+                const end = fade.startTime + fade.duration;
+                const t = Math.min(Math.max((now - fade.startTime) / fade.duration, 0), 1);
+                const interpolant = fade.from + (fade.to - fade.from) * t;
+                weight *= interpolant;
+                if (now > end) {
+                    this.fade = null;
+                    if (interpolant === 0)
+                        this.enabled = false;
+                }
+            }
+        }
+        this.effectiveWeight = weight;
+        return weight;
+    }
+    /** Effective timescale at mixer.time, per r185 `_updateTimeScale`. */
+    updateTimeScale(now) {
+        let timeScale = 0;
+        if (!this.paused) {
+            timeScale = this.timeScale;
+            const warp = this.warpState;
+            if (warp !== null) {
+                const end = warp.startTime + warp.duration;
+                const t = Math.min(Math.max((now - warp.startTime) / warp.duration, 0), 1);
+                timeScale *= warp.from + (warp.to - warp.from) * t;
+                if (now > end) {
+                    if (timeScale === 0) {
+                        this.paused = true;
+                    }
+                    else {
+                        if (this.restoreTimeScale !== null)
+                            timeScale = this.restoreTimeScale;
+                        this.timeScale = timeScale;
+                    }
+                    this.warpState = null;
+                }
+            }
+        }
+        this.effectiveTimeScale = timeScale;
+        return timeScale;
+    }
+    /** Advance clip time per r185 `_updateTime`; returns {wrapped, finished}. */
+    updateTime(deltaTime) {
+        const duration = this.clip.duration;
+        const previous = this.time;
+        let time = previous + deltaTime;
+        let wrapped = false;
+        let finished = false;
+        if (this.loopMode === "once") {
+            if (this.loopCount === -1)
+                this.loopCount = 0;
+            if (time >= duration) {
+                time = duration;
+                finished = true;
+            }
+            else if (time < 0) {
+                time = 0;
+                finished = true;
+            }
+            if (finished) {
+                if (this.clampWhenFinished)
+                    this.paused = true;
+                else
+                    this.enabled = false;
+                this.time = time;
+                return { wrapped, finished, previous };
+            }
+        }
+        else {
+            // repeat / pingpong
+            if (this.loopCount === -1) {
+                if (deltaTime >= 0) {
+                    this.loopCount = 0;
+                }
+            }
+            if (duration > 0 && (time >= duration || time < 0)) {
+                const loopDelta = Math.floor(time / duration);
+                time -= duration * loopDelta;
+                this.loopCount += Math.abs(loopDelta);
+                wrapped = true;
+                const pending = this.repetitions - this.loopCount;
+                if (pending <= 0) {
+                    if (this.clampWhenFinished)
+                        this.paused = true;
+                    else
+                        this.enabled = false;
+                    this.time = deltaTime > 0 ? duration : 0;
+                    return { wrapped, finished: true, previous };
+                }
+            }
+            if (this.loopMode === "pingpong") {
+                if ((this.loopCount & 1) === 1)
+                    this.pingPongForward = false;
+                else
+                    this.pingPongForward = true;
+                if (!this.pingPongForward)
+                    time = duration - time;
+            }
+        }
+        this.time = time;
+        return { wrapped, finished, previous };
+    }
+}
+export class PoseMixer {
+    skeleton;
+    inertializer;
+    time = 0;
+    timeScale = 1;
+    clips = new Map();
+    actions = [];
+    layers = [];
+    layerByName = new Map();
+    eventListeners = new Set();
+    latestPose = null;
+    previousPose = null;
+    inertializerElapsed = Infinity;
+    inertializerHalfLife = 0.15;
+    scratchClip = new Float32Array(4);
+    // §13 micro-budget — the accumulate paths must run in single-digit µs for a
+    // 191-joint rig, so per-(bone,channel) state lives in flat arrays + touched
+    // lists, not Maps: a Uint32Array push is ~1ns where Map.get/set ~50ns each
+    // was the whole 60 µs budget on its own.
+    accWeight;
+    addWeight;
+    addQuat;
+    addVec;
+    accTouched;
+    addTouched;
+    accTouchedCount = 0;
+    addTouchedCount = 0;
+    constructor(options) {
+        this.skeleton = options.skeleton;
+        this.inertializer = options.inertializer ?? null;
+        const slots = this.skeleton.boneCount * 3;
+        this.accWeight = new Float32Array(slots);
+        this.addWeight = new Float32Array(slots);
+        this.addQuat = new Float32Array(slots * 4);
+        this.addVec = new Float32Array(slots * 3);
+        this.accTouched = new Uint32Array(slots);
+        this.addTouched = new Uint32Array(slots);
+    }
+    resetAccumulators() {
+        for (let i = 0; i < this.accTouchedCount; i += 1)
+            this.accWeight[this.accTouched[i]] = 0;
+        for (let i = 0; i < this.addTouchedCount; i += 1)
+            this.addWeight[this.addTouched[i]] = 0;
+        this.accTouchedCount = 0;
+        this.addTouchedCount = 0;
+    }
+    setEffectiveTimeScale(timeScale) {
+        this.timeScale = timeScale;
+        return this;
+    }
+    get effectiveTimeScale() {
+        return this.timeScale;
+    }
+    /** Register a clip under a name (compiles it for flat sampling). */
+    addClip(name, clip) {
+        this.clips.set(name, { source: clip, compiled: compileClip(clip) });
+        return this;
+    }
+    /** Register a pre-compiled clip (returns undefined if unknown). */
+    addCompiledClip(name, compiled, source) {
+        this.clips.set(name, { source, compiled });
+        return this;
+    }
+    sourceClip(name) {
+        return this.clips.get(name)?.source;
+    }
+    clipAction(name, options = {}) {
+        const entry = this.clips.get(name);
+        if (!entry) {
+            throw new Error(`ANIMATION_CLIP_NOT_FOUND: clip "${name}" is not registered. Available: ${[...this.clips.keys()].join(", ")}`);
+        }
+        return new PoseAction(this, name, entry.compiled, options);
+    }
+    /** three r185 play: activate + begin (starts faded-in when `crossFade`). */
+    play(name, options = {}) {
+        const action = this.clipAction(name, options);
+        action.play();
+        return action;
+    }
+    /**
+     * Every currently-playing, enabled action across the base layer and named
+     * layers — the set `update`/`evaluate` will contribute this frame (T1.9
+     * uses it to sample non-pose tracks at each action's own clock/weight and
+     * to compute covered-bone sets for `restPoseReset: false`).
+     */
+    activeActions() {
+        const all = [];
+        for (const action of this.actions) {
+            if (action.playing && action.enabled)
+                all.push(action);
+        }
+        for (const layer of this.layers) {
+            for (const action of layer.actions) {
+                if (action.playing && action.enabled)
+                    all.push(action);
+            }
+        }
+        return all;
+    }
+    /** The active base (non-additive, base-layer) action, or null when none plays. */
+    baseAction() {
+        return this.activeBaseAction();
+    }
+    /**
+     * Same active set as {@link activeActions} annotated with the owning layer
+     * name — `""` for the base layer — for `animationState()` snapshots (C-37).
+     */
+    activeActionEntries() {
+        const all = [];
+        for (const action of this.actions) {
+            if (action.playing && action.enabled)
+                all.push({ action, layer: "" });
+        }
+        for (const layer of this.layers) {
+            for (const action of layer.actions) {
+                if (action.playing && action.enabled)
+                    all.push({ action, layer: layer.name });
+            }
+        }
+        return all;
+    }
+    /**
+     * `crossFadeTo(clip, seconds, options)` — mirrors `node.play` semantics:
+     * the current active base action fades out over `seconds` (default driven by
+     * caller), the new one fades in; `warp` warps timescales by the duration
+     * ratio; `transition: "inertialize"` captures pose offsets instead.
+     */
+    crossFadeTo(name, seconds, options = {}) {
+        const transition = options.transition ?? "crossfade";
+        const fadeIn = this.clipAction(name, {
+            syncGroup: options.syncGroup,
+            weight: options.weight,
+            additive: options.additive
+        });
+        const current = this.activeBaseAction();
+        if (transition === "inertialize" && this.inertializer !== null && this.latestPose !== null && this.previousPose !== null) {
+            const dt = this.lastDt > 0 ? this.lastDt : 1 / 60;
+            this.inertializer.transition(this.latestPose, this.previousPose, dt, options.halfLife ?? 0.15);
+            this.inertializerElapsed = 0;
+            this.inertializerHalfLife = options.halfLife ?? 0.15;
+            if (current !== null)
+                current.stop();
+            fadeIn.play();
+            return fadeIn;
+        }
+        if (current === null) {
+            fadeIn.fadeIn(seconds);
+            fadeIn.play();
+            return fadeIn;
+        }
+        fadeIn.play();
+        current.crossFadeTo(fadeIn, seconds, options.warp === true);
+        return fadeIn;
+    }
+    activeBaseAction() {
+        for (let i = this.actions.length - 1; i >= 0; i -= 1) {
+            const action = this.actions[i];
+            if (!action.additive && action.playing)
+                return action;
+        }
+        return null;
+    }
+    /** Layer API (C-19 playLayer/stopLayer groundwork). */
+    playLayer(layerName, clipName, options = {}) {
+        let layer = this.layerByName.get(layerName);
+        if (!layer) {
+            layer = { name: layerName, blendMode: options.blendMode ?? "override", mask: options.mask ?? null, weight: options.weight ?? 1, actions: [] };
+            this.layerByName.set(layerName, layer);
+            this.layers.push(layer);
+        }
+        const action = this.clipAction(clipName, options);
+        action.play();
+        layer.actions.push(action);
+        return action;
+    }
+    stopLayer(layerName, fadeSeconds = 0) {
+        const layer = this.layerByName.get(layerName);
+        if (!layer)
+            return;
+        for (const action of layer.actions) {
+            if (fadeSeconds > 0)
+                action.fadeOut(fadeSeconds);
+            else
+                action.stop();
+        }
+        if (fadeSeconds <= 0) {
+            this.layerByName.delete(layerName);
+            this.layers.splice(this.layers.indexOf(layer), 1);
+        }
+    }
+    onEvent(listener) {
+        this.eventListeners.add(listener);
+        return () => this.eventListeners.delete(listener);
+    }
+    activate(action) {
+        if (!this.actions.includes(action))
+            this.actions.push(action);
+    }
+    deactivate(action) {
+        const index = this.actions.indexOf(action);
+        if (index >= 0)
+            this.actions.splice(index, 1);
+    }
+    /** Resolve `CompiledClip` node-path targets to skeleton bone indices. */
+    resolveBindings(clip) {
+        const bindings = [];
+        for (let i = 0; i < clip.tracks.length; i += 1) {
+            const track = clip.tracks[i];
+            const parsed = parseTrackTarget(track.target);
+            if (parsed === null)
+                continue;
+            const indices = this.skeleton.jointIndicesByName.get(parsed.nodeName);
+            if (!indices || indices.length === 0)
+                continue;
+            bindings.push({ trackIndex: i, boneIndex: indices[0], channel: parsed.channel });
+        }
+        return bindings;
+    }
+    statelessBindings = new Map();
+    statelessCursors = new Map();
+    statelessBindingsFor(clip) {
+        let bindings = this.statelessBindings.get(clip);
+        if (bindings === undefined) {
+            bindings = this.resolveBindings(clip);
+            this.statelessBindings.set(clip, bindings);
+        }
+        return bindings;
+    }
+    statelessCursorsFor(clip) {
+        let cursors = this.statelessCursors.get(clip);
+        if (cursors === undefined) {
+            cursors = createTrackCursors(clip);
+            this.statelessCursors.set(clip, cursors);
+        }
+        return cursors;
+    }
+    lastDt = 0;
+    /**
+     * Advance mixer time by `dt` (× mixer timescale), update all actions'
+     * times/weights, and emit clip events between old and new action times.
+     */
+    update(dt) {
+        this.lastDt = dt;
+        this.time += dt;
+        const scaledDt = dt * this.timeScale;
+        const events = [];
+        const allActions = [...this.actions];
+        for (const layer of this.layers)
+            allActions.push(...layer.actions);
+        for (const action of allActions) {
+            if (!action.playing && !action.enabled)
+                continue;
+            const effectiveTimeScale = action.updateTimeScale(this.time);
+            const clipDelta = scaledDt * effectiveTimeScale;
+            const { previous, wrapped } = action.updateTime(clipDelta);
+            const weight = action.updateWeight(this.time);
+            if (!action.enabled && !action.playing)
+                this.deactivate(action);
+            if (!action.enabled)
+                continue;
+            const source = this.clips.get(action.clipName);
+            if (source !== undefined && source.source.events.length > 0 && weight > 0) {
+                const to = action.time;
+                const invocations = sampleClipEvents({ id: action.clipName, duration: source.compiled.duration, events: source.source.events }, {
+                    from: previous,
+                    to,
+                    duration: source.compiled.duration,
+                    loop: wrapped,
+                    direction: to >= previous ? 1 : -1,
+                    playbackTime: this.time
+                });
+                events.push(...invocations);
+            }
+        }
+        // Aura extension: sync groups keep normalized phase aligned to the leader
+        // (first activated member) — three r185 has no phase sync. Only enabled
+        // members take part: a faded-out action stays `playing` (enabled=false, as
+        // in r185) and must not keep leading the group — it would slave the
+        // incoming clip to its own (restored) rate after the crossfade.
+        const groups = new Map();
+        for (const action of allActions) {
+            if (action.syncGroupName === null || !action.playing || !action.enabled)
+                continue;
+            const group = groups.get(action.syncGroupName) ?? [];
+            group.push(action);
+            groups.set(action.syncGroupName, group);
+        }
+        for (const group of groups.values()) {
+            if (group.length < 2)
+                continue;
+            const leader = group[0];
+            const phase = leader.normalizedPhase;
+            for (let i = 1; i < group.length; i += 1) {
+                const member = group[i];
+                member.time = phase * member.clip.duration;
+            }
+        }
+        for (const invocation of events) {
+            for (const listener of this.eventListeners)
+                listener(invocation);
+        }
+        if (this.inertializer !== null && this.inertializerElapsed !== Infinity) {
+            this.inertializerElapsed += scaledDt;
+        }
+        // Sweep layers whose actions have all faded out.
+        for (let i = this.layers.length - 1; i >= 0; i -= 1) {
+            const layer = this.layers[i];
+            if (layer.actions.length > 0 && layer.actions.every((a) => !a.enabled || !a.playing)) {
+                for (const action of layer.actions)
+                    action.stop();
+                this.layers.splice(i, 1);
+                this.layerByName.delete(layer.name);
+            }
+        }
+        return events;
+    }
+    /**
+     * Evaluate the final pose into `out` (PoseBuffer with skeleton.boneCount
+     * bones). Starts from `skeleton.restPose`, applies the base layer
+     * (incremental-weighted, rest fills below Σw=1), then each layer in order.
+     */
+    evaluate(out) {
+        const n = this.skeleton.boneCount;
+        const rest = this.skeleton.restPose;
+        this.previousPose = this.latestPose;
+        // Start at rest — bones untouched by any action keep rest TRS.
+        out.positions.set(rest.positions);
+        out.rotations.set(rest.rotations);
+        out.scales.set(rest.scales);
+        this.resetAccumulators();
+        this.applyBase(out);
+        this.applyRestFill(out);
+        this.applyAdditiveAccumulators(out);
+        for (const layer of this.layers) {
+            this.applyLayer(out, layer);
+        }
+        if (this.inertializer !== null && this.inertializerElapsed !== Infinity && Number.isFinite(this.inertializerElapsed)) {
+            this.inertializer.apply(out, out, this.inertializerElapsed);
+        }
+        // §13: the latestPose/previousPose snapshots only feed the inertialize
+        // transition — skip the 4·boneCount store clone when no inertializer
+        // exists (the common path, ~1-2µs on a 191-bone rig).
+        if (this.inertializer !== null) {
+            this.latestPose = clonePoseInto(out, this.latestPose, n);
+        }
+        this.resetAccumulators();
+    }
+    /**
+     * Stateless one-shot blend (T1.7): evaluate the given clips at explicit
+     * times with explicit weights and write the result into `out`. No
+     * PoseAction is created or mutated; action/layer/inertializer state is
+     * untouched. Same accumulate + rest-fill + additive pipeline as
+     * `evaluate`, so the two paths stay within the 1e-4 parity bar.
+     */
+    evaluateSamples(samples, out) {
+        const rest = this.skeleton.restPose;
+        out.positions.set(rest.positions);
+        out.rotations.set(rest.rotations);
+        out.scales.set(rest.scales);
+        this.resetAccumulators();
+        const scratch = this.scratchClip;
+        for (const sample of samples) {
+            const entry = this.clips.get(sample.clipName);
+            if (entry === undefined) {
+                throw new Error(`ANIMATION_CLIP_NOT_FOUND: clip "${sample.clipName}" is not registered. Available: ${[...this.clips.keys()].join(", ")}`);
+            }
+            const clip = entry.compiled;
+            const weight = sample.weight ?? 1;
+            if (weight <= 0)
+                continue;
+            const additive = sample.additive ?? isClipAdditive(entry.source);
+            const bindings = this.statelessBindingsFor(clip);
+            const cursors = this.statelessCursorsFor(clip);
+            for (const binding of bindings) {
+                const boneWeight = sample.mask == null ? weight : weight * sample.mask[binding.boneIndex];
+                if (boneWeight <= 0)
+                    continue;
+                const track = clip.tracks[binding.trackIndex];
+                sampleTrackInto(track, sample.time, cursors, binding.trackIndex, scratch, 0);
+                this.accumulate(out, binding, track, scratch, boneWeight, additive);
+            }
+        }
+        this.applyRestFill(out);
+        this.applyAdditiveAccumulators(out);
+        this.resetAccumulators();
+    }
+    applyBase(out) {
+        const scratch = this.scratchClip;
+        for (const action of this.actions) {
+            const weight = action.effectiveWeight;
+            if (weight <= 0 || !action.enabled)
+                continue;
+            for (const binding of action.bindings) {
+                const track = action.clip.tracks[binding.trackIndex];
+                sampleTrackInto(track, action.time, action.cursors, binding.trackIndex, scratch, 0);
+                this.accumulate(out, binding, track, scratch, weight, action.additive);
+            }
+        }
+    }
+    applyLayer(out, layer) {
+        const scratch = this.scratchClip;
+        for (const action of layer.actions) {
+            const weight = action.effectiveWeight * layer.weight;
+            if (weight <= 0 || !action.enabled)
+                continue;
+            for (const binding of action.bindings) {
+                const maskWeight = layer.mask === null ? weight : weight * layer.mask[binding.boneIndex];
+                if (maskWeight <= 0)
+                    continue;
+                const track = action.clip.tracks[binding.trackIndex];
+                sampleTrackInto(track, action.time, action.cursors, binding.trackIndex, scratch, 0);
+                if (layer.blendMode === "additive" || action.additive) {
+                    this.accumulateAdditive(out, binding, track, scratch, maskWeight);
+                }
+                else {
+                    this.applyOverride(out, binding, track, scratch, maskWeight);
+                }
+            }
+        }
+    }
+    accuKey(boneIndex, channel) {
+        return boneIndex * 3 + (channel === "position" ? 0 : channel === "rotation" ? 1 : 2);
+    }
+    /** Base-layer incremental accumulate: `acc = mix(acc, v, w/(Σ+w))`, then rest. */
+    accumulate(out, binding, track, sample, weight, additive) {
+        const b = binding.boneIndex;
+        const key = this.accuKey(b, binding.channel);
+        if (additive) {
+            this.accumulateAdditiveAccu(binding, sample, weight);
+            return;
+        }
+        const prevWeight = this.accWeight[key];
+        if (prevWeight === 0) {
+            this.accTouched[this.accTouchedCount++] = key;
+            this.writeSample(out, b, binding.channel, sample);
+            this.accWeight[key] = weight;
+            return;
+        }
+        const cumulative = prevWeight + weight;
+        const mix = weight / cumulative;
+        this.mixInPlace(out, b, binding.channel, sample, mix);
+        this.accWeight[key] = cumulative;
+    }
+    /** r185 `accumulateAdditive`: quats chain-multiply `add = slerp(add, add·delta, w)`; vecs `add += delta·w`. */
+    accumulateAdditiveAccu(binding, delta, weight) {
+        const key = this.accuKey(binding.boneIndex, binding.channel);
+        const prev = this.addWeight[key];
+        if (prev === 0)
+            this.addTouched[this.addTouchedCount++] = key;
+        if (binding.channel === "rotation") {
+            const off = key * 4;
+            if (prev === 0) {
+                this.addQuat[off] = 0;
+                this.addQuat[off + 1] = 0;
+                this.addQuat[off + 2] = 0;
+                this.addQuat[off + 3] = 1;
+            }
+            const work = scratchMul;
+            multiplyQuatFlat(work, 0, this.addQuat, off, delta, 0);
+            slerpQuatFlat(this.addQuat, off, this.addQuat, off, work, 0, weight);
+        }
+        else {
+            const off = key * 3;
+            if (prev === 0) {
+                this.addVec[off] = 0;
+                this.addVec[off + 1] = 0;
+                this.addVec[off + 2] = 0;
+            }
+            this.addVec[off] += delta[0] * weight;
+            this.addVec[off + 1] += delta[1] * weight;
+            this.addVec[off + 2] += delta[2] * weight;
+        }
+        this.addWeight[key] = prev + weight;
+    }
+    /** r185 `apply` additive stage: `accu = slerp(accu, accu·add, 1)` / `accu += add`. */
+    applyAdditiveAccumulators(out) {
+        for (let t = 0; t < this.addTouchedCount; t += 1) {
+            const key = this.addTouched[t];
+            const boneIndex = (key / 3) | 0;
+            const channel = key % 3 === 0 ? "position" : key % 3 === 1 ? "rotation" : "scale";
+            if (channel === "rotation") {
+                multiplyQuatFlat(scratchMul, 0, out.rotations, boneIndex * 4, this.addQuat, key * 4);
+                slerpQuatFlat(out.rotations, boneIndex * 4, out.rotations, boneIndex * 4, scratchMul, 0, 1);
+            }
+            else {
+                const off = boneIndex * 3;
+                const src = key * 3;
+                const dst = channel === "position" ? out.positions : out.scales;
+                for (let k = 0; k < 3; k += 1)
+                    dst[off + k] += this.addVec[src + k];
+            }
+        }
+    }
+    /** After base accumulate: fill below-1 remainder from rest pose. Call once per channel per evaluate. */
+    applyRestFill(out) {
+        const rest = this.skeleton.restPose;
+        for (let t = 0; t < this.accTouchedCount; t += 1) {
+            const key = this.accTouched[t];
+            const weight = this.accWeight[key];
+            if (weight >= 1)
+                continue;
+            const boneIndex = Math.floor(key / 3);
+            const channel = key % 3 === 0 ? "position" : key % 3 === 1 ? "rotation" : "scale";
+            const remainder = 1 - weight;
+            if (channel === "rotation") {
+                slerpQuatFlat(out.rotations, boneIndex * 4, out.rotations, boneIndex * 4, rest.rotations, boneIndex * 4, remainder);
+            }
+            else {
+                const off = boneIndex * 3;
+                const dst = channel === "position" ? out.positions : out.scales;
+                const src = channel === "position" ? rest.positions : rest.scales;
+                lerpVec3Flat(dst, off, dst, off, src, off, remainder);
+            }
+        }
+    }
+    writeSample(out, boneIndex, channel, sample) {
+        if (channel === "rotation") {
+            const off = boneIndex * 4;
+            out.rotations[off] = sample[0];
+            out.rotations[off + 1] = sample[1];
+            out.rotations[off + 2] = sample[2];
+            out.rotations[off + 3] = sample[3];
+        }
+        else {
+            const off = boneIndex * 3;
+            const dst = channel === "position" ? out.positions : out.scales;
+            dst[off] = sample[0];
+            dst[off + 1] = sample[1];
+            dst[off + 2] = sample[2];
+        }
+    }
+    mixInPlace(out, boneIndex, channel, sample, t) {
+        const scratchB = scratchSampleB;
+        if (channel === "rotation") {
+            slerpQuatFlat(out.rotations, boneIndex * 4, out.rotations, boneIndex * 4, sample, 0, t);
+        }
+        else {
+            const off = boneIndex * 3;
+            const dst = channel === "position" ? out.positions : out.scales;
+            lerpVec3Flat(dst, off, dst, off, sample, 0, t);
+            void scratchB;
+        }
+    }
+    /**
+     * Override layer: `out[b] = slerp(out[b], layer[b], w)` — applied to whatever
+     * the base produced (which may itself be rest-blended).
+     */
+    applyOverride(out, binding, track, sample, weight) {
+        this.mixInPlace(out, binding.boneIndex, binding.channel, sample, weight);
+    }
+    /**
+     * Additive: quats `out = slerp(out, out·delta, w)`; positions and scales
+     * `out += delta·w` (r185 `_slerpAdditive`/`_lerpAdditive`).
+     */
+    accumulateAdditive(out, binding, track, delta, weight) {
+        const b = binding.boneIndex;
+        if (binding.channel === "rotation") {
+            multiplyQuatFlat(scratchMul, 0, out.rotations, b * 4, delta, 0);
+            slerpQuatFlat(out.rotations, b * 4, out.rotations, b * 4, scratchMul, 0, weight);
+        }
+        else {
+            const off = b * 3;
+            const dst = binding.channel === "position" ? out.positions : out.scales;
+            for (let k = 0; k < 3; k += 1)
+                dst[off + k] += delta[k] * weight;
+        }
+    }
+}
+const scratchMul = new Float32Array(4);
+const scratchSampleB = new Float32Array(4);
+function clonePoseInto(source, target, boneCount) {
+    const pose = target ?? { boneCount, positions: new Float32Array(boneCount * 3), rotations: new Float32Array(boneCount * 4), scales: new Float32Array(boneCount * 3) };
+    pose.positions.set(source.positions);
+    pose.rotations.set(source.rotations);
+    pose.scales.set(source.scales);
+    return pose;
+}
+const CHANNELS = {
+    translation: "position",
+    position: "position",
+    rotation: "rotation",
+    quaternion: "rotation",
+    scale: "scale"
+};
+/** Parse `<nodeName>.<path>` — mirrors glTF runtime targets (weights/material/light are out of pose scope). */
+function parseTrackTarget(target) {
+    if (target.startsWith("material:") || target.startsWith("light:"))
+        return null;
+    const separator = target.lastIndexOf(".");
+    if (separator <= 0 || separator === target.length - 1)
+        return null;
+    const channel = CHANNELS[target.slice(separator + 1)];
+    if (channel === undefined)
+        return null;
+    return { nodeName: target.slice(0, separator), channel };
+}
+//# sourceMappingURL=PoseMixer.js.map