@esotericsoftware/spine-core 4.1.25 → 4.1.28

package/dist/AnimationState.js

@@ -0,0 +1,1096 @@
+/******************************************************************************
+ * Spine Runtimes License Agreement
+ * Last updated September 24, 2021. Replaces all prior versions.
+ *
+ * Copyright (c) 2013-2021, Esoteric Software LLC
+ *
+ * Integration of the Spine Runtimes into software or otherwise creating
+ * derivative works of the Spine Runtimes is permitted under the terms and
+ * conditions of Section 2 of the Spine Editor License Agreement:
+ * http://esotericsoftware.com/spine-editor-license
+ *
+ * Otherwise, it is permitted to integrate the Spine Runtimes into software
+ * or otherwise create derivative works of the Spine Runtimes (collectively,
+ * "Products"), provided that each user of the Products must obtain their own
+ * Spine Editor license and redistribution of the Products in any form must
+ * include this license and copyright notice.
+ *
+ * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
+ * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *****************************************************************************/
+import { Animation, MixBlend, AttachmentTimeline, MixDirection, RotateTimeline, DrawOrderTimeline, Timeline, EventTimeline } from "./Animation";
+import { StringSet, Pool, Utils, MathUtils } from "./Utils";
+/** Applies animations over time, queues animations for later playback, mixes (crossfading) between animations, and applies
+ * multiple animations on top of each other (layering).
+ *
+ * See [Applying Animations](http://esotericsoftware.com/spine-applying-animations/) in the Spine Runtimes Guide. */
+export class AnimationState {
+    static emptyAnimation() {
+        return AnimationState._emptyAnimation;
+    }
+    constructor(data) {
+        /** The list of tracks that currently have animations, which may contain null entries. */
+        this.tracks = new Array();
+        /** Multiplier for the delta time when the animation state is updated, causing time for all animations and mixes to play slower
+         * or faster. Defaults to 1.
+         *
+         * See TrackEntry {@link TrackEntry#timeScale} for affecting a single animation. */
+        this.timeScale = 1;
+        this.unkeyedState = 0;
+        this.events = new Array();
+        this.listeners = new Array();
+        this.queue = new EventQueue(this);
+        this.propertyIDs = new StringSet();
+        this.animationsChanged = false;
+        this.trackEntryPool = new Pool(() => new TrackEntry());
+        this.data = data;
+    }
+    /** Increments each track entry {@link TrackEntry#trackTime()}, setting queued animations as current if needed. */
+    update(delta) {
+        delta *= this.timeScale;
+        let tracks = this.tracks;
+        for (let i = 0, n = tracks.length; i < n; i++) {
+            let current = tracks[i];
+            if (!current)
+                continue;
+            current.animationLast = current.nextAnimationLast;
+            current.trackLast = current.nextTrackLast;
+            let currentDelta = delta * current.timeScale;
+            if (current.delay > 0) {
+                current.delay -= currentDelta;
+                if (current.delay > 0)
+                    continue;
+                currentDelta = -current.delay;
+                current.delay = 0;
+            }
+            let next = current.next;
+            if (next) {
+                // When the next entry's delay is passed, change to the next entry, preserving leftover time.
+                let nextTime = current.trackLast - next.delay;
+                if (nextTime >= 0) {
+                    next.delay = 0;
+                    next.trackTime += current.timeScale == 0 ? 0 : (nextTime / current.timeScale + delta) * next.timeScale;
+                    current.trackTime += currentDelta;
+                    this.setCurrent(i, next, true);
+                    while (next.mixingFrom) {
+                        next.mixTime += delta;
+                        next = next.mixingFrom;
+                    }
+                    continue;
+                }
+            }
+            else if (current.trackLast >= current.trackEnd && !current.mixingFrom) {
+                tracks[i] = null;
+                this.queue.end(current);
+                this.clearNext(current);
+                continue;
+            }
+            if (current.mixingFrom && this.updateMixingFrom(current, delta)) {
+                // End mixing from entries once all have completed.
+                let from = current.mixingFrom;
+                current.mixingFrom = null;
+                if (from)
+                    from.mixingTo = null;
+                while (from) {
+                    this.queue.end(from);
+                    from = from.mixingFrom;
+                }
+            }
+            current.trackTime += currentDelta;
+        }
+        this.queue.drain();
+    }
+    /** Returns true when all mixing from entries are complete. */
+    updateMixingFrom(to, delta) {
+        let from = to.mixingFrom;
+        if (!from)
+            return true;
+        let finished = this.updateMixingFrom(from, delta);
+        from.animationLast = from.nextAnimationLast;
+        from.trackLast = from.nextTrackLast;
+        // Require mixTime > 0 to ensure the mixing from entry was applied at least once.
+        if (to.mixTime > 0 && to.mixTime >= to.mixDuration) {
+            // Require totalAlpha == 0 to ensure mixing is complete, unless mixDuration == 0 (the transition is a single frame).
+            if (from.totalAlpha == 0 || to.mixDuration == 0) {
+                to.mixingFrom = from.mixingFrom;
+                if (from.mixingFrom)
+                    from.mixingFrom.mixingTo = to;
+                to.interruptAlpha = from.interruptAlpha;
+                this.queue.end(from);
+            }
+            return finished;
+        }
+        from.trackTime += delta * from.timeScale;
+        to.mixTime += delta;
+        return false;
+    }
+    /** Poses the skeleton using the track entry animations. There are no side effects other than invoking listeners, so the
+     * animation state can be applied to multiple skeletons to pose them identically.
+     * @returns True if any animations were applied. */
+    apply(skeleton) {
+        if (!skeleton)
+            throw new Error("skeleton cannot be null.");
+        if (this.animationsChanged)
+            this._animationsChanged();
+        let events = this.events;
+        let tracks = this.tracks;
+        let applied = false;
+        for (let i = 0, n = tracks.length; i < n; i++) {
+            let current = tracks[i];
+            if (!current || current.delay > 0)
+                continue;
+            applied = true;
+            let blend = i == 0 ? MixBlend.first : current.mixBlend;
+            // Apply mixing from entries first.
+            let mix = current.alpha;
+            if (current.mixingFrom)
+                mix *= this.applyMixingFrom(current, skeleton, blend);
+            else if (current.trackTime >= current.trackEnd && !current.next)
+                mix = 0;
+            // Apply current entry.
+            let animationLast = current.animationLast, animationTime = current.getAnimationTime(), applyTime = animationTime;
+            let applyEvents = events;
+            if (current.reverse) {
+                applyTime = current.animation.duration - applyTime;
+                applyEvents = null;
+            }
+            let timelines = current.animation.timelines;
+            let timelineCount = timelines.length;
+            if ((i == 0 && mix == 1) || blend == MixBlend.add) {
+                for (let ii = 0; ii < timelineCount; ii++) {
+                    // Fixes issue #302 on IOS9 where mix, blend sometimes became undefined and caused assets
+                    // to sometimes stop rendering when using color correction, as their RGBA values become NaN.
+                    // (https://github.com/pixijs/pixi-spine/issues/302)
+                    Utils.webkit602BugfixHelper(mix, blend);
+                    var timeline = timelines[ii];
+                    if (timeline instanceof AttachmentTimeline)
+                        this.applyAttachmentTimeline(timeline, skeleton, applyTime, blend, true);
+                    else
+                        timeline.apply(skeleton, animationLast, applyTime, applyEvents, mix, blend, MixDirection.mixIn);
+                }
+            }
+            else {
+                let timelineMode = current.timelineMode;
+                let shortestRotation = current.shortestRotation;
+                let firstFrame = !shortestRotation && current.timelinesRotation.length != timelineCount << 1;
+                if (firstFrame)
+                    current.timelinesRotation.length = timelineCount << 1;
+                for (let ii = 0; ii < timelineCount; ii++) {
+                    let timeline = timelines[ii];
+                    let timelineBlend = timelineMode[ii] == SUBSEQUENT ? blend : MixBlend.setup;
+                    if (!shortestRotation && timeline instanceof RotateTimeline) {
+                        this.applyRotateTimeline(timeline, skeleton, applyTime, mix, timelineBlend, current.timelinesRotation, ii << 1, firstFrame);
+                    }
+                    else if (timeline instanceof AttachmentTimeline) {
+                        this.applyAttachmentTimeline(timeline, skeleton, applyTime, blend, true);
+                    }
+                    else {
+                        // This fixes the WebKit 602 specific issue described at http://esotericsoftware.com/forum/iOS-10-disappearing-graphics-10109
+                        Utils.webkit602BugfixHelper(mix, blend);
+                        timeline.apply(skeleton, animationLast, applyTime, applyEvents, mix, timelineBlend, MixDirection.mixIn);
+                    }
+                }
+            }
+            this.queueEvents(current, animationTime);
+            events.length = 0;
+            current.nextAnimationLast = animationTime;
+            current.nextTrackLast = current.trackTime;
+        }
+        // Set slots attachments to the setup pose, if needed. This occurs if an animation that is mixing out sets attachments so
+        // subsequent timelines see any deform, but the subsequent timelines don't set an attachment (eg they are also mixing out or
+        // the time is before the first key).
+        var setupState = this.unkeyedState + SETUP;
+        var slots = skeleton.slots;
+        for (var i = 0, n = skeleton.slots.length; i < n; i++) {
+            var slot = slots[i];
+            if (slot.attachmentState == setupState) {
+                var attachmentName = slot.data.attachmentName;
+                slot.setAttachment(!attachmentName ? null : skeleton.getAttachment(slot.data.index, attachmentName));
+            }
+        }
+        this.unkeyedState += 2; // Increasing after each use avoids the need to reset attachmentState for every slot.
+        this.queue.drain();
+        return applied;
+    }
+    applyMixingFrom(to, skeleton, blend) {
+        let from = to.mixingFrom;
+        if (from.mixingFrom)
+            this.applyMixingFrom(from, skeleton, blend);
+        let mix = 0;
+        if (to.mixDuration == 0) { // Single frame mix to undo mixingFrom changes.
+            mix = 1;
+            if (blend == MixBlend.first)
+                blend = MixBlend.setup;
+        }
+        else {
+            mix = to.mixTime / to.mixDuration;
+            if (mix > 1)
+                mix = 1;
+            if (blend != MixBlend.first)
+                blend = from.mixBlend;
+        }
+        let attachments = mix < from.attachmentThreshold, drawOrder = mix < from.drawOrderThreshold;
+        let timelines = from.animation.timelines;
+        let timelineCount = timelines.length;
+        let alphaHold = from.alpha * to.interruptAlpha, alphaMix = alphaHold * (1 - mix);
+        let animationLast = from.animationLast, animationTime = from.getAnimationTime(), applyTime = animationTime;
+        let events = null;
+        if (from.reverse)
+            applyTime = from.animation.duration - applyTime;
+        else if (mix < from.eventThreshold)
+            events = this.events;
+        if (blend == MixBlend.add) {
+            for (let i = 0; i < timelineCount; i++)
+                timelines[i].apply(skeleton, animationLast, applyTime, events, alphaMix, blend, MixDirection.mixOut);
+        }
+        else {
+            let timelineMode = from.timelineMode;
+            let timelineHoldMix = from.timelineHoldMix;
+            let shortestRotation = from.shortestRotation;
+            let firstFrame = !shortestRotation && from.timelinesRotation.length != timelineCount << 1;
+            if (firstFrame)
+                from.timelinesRotation.length = timelineCount << 1;
+            from.totalAlpha = 0;
+            for (let i = 0; i < timelineCount; i++) {
+                let timeline = timelines[i];
+                let direction = MixDirection.mixOut;
+                let timelineBlend;
+                let alpha = 0;
+                switch (timelineMode[i]) {
+                    case SUBSEQUENT:
+                        if (!drawOrder && timeline instanceof DrawOrderTimeline)
+                            continue;
+                        timelineBlend = blend;
+                        alpha = alphaMix;
+                        break;
+                    case FIRST:
+                        timelineBlend = MixBlend.setup;
+                        alpha = alphaMix;
+                        break;
+                    case HOLD_SUBSEQUENT:
+                        timelineBlend = blend;
+                        alpha = alphaHold;
+                        break;
+                    case HOLD_FIRST:
+                        timelineBlend = MixBlend.setup;
+                        alpha = alphaHold;
+                        break;
+                    default:
+                        timelineBlend = MixBlend.setup;
+                        let holdMix = timelineHoldMix[i];
+                        alpha = alphaHold * Math.max(0, 1 - holdMix.mixTime / holdMix.mixDuration);
+                        break;
+                }
+                from.totalAlpha += alpha;
+                if (!shortestRotation && timeline instanceof RotateTimeline)
+                    this.applyRotateTimeline(timeline, skeleton, applyTime, alpha, timelineBlend, from.timelinesRotation, i << 1, firstFrame);
+                else if (timeline instanceof AttachmentTimeline)
+                    this.applyAttachmentTimeline(timeline, skeleton, applyTime, timelineBlend, attachments);
+                else {
+                    // This fixes the WebKit 602 specific issue described at http://esotericsoftware.com/forum/iOS-10-disappearing-graphics-10109
+                    Utils.webkit602BugfixHelper(alpha, blend);
+                    if (drawOrder && timeline instanceof DrawOrderTimeline && timelineBlend == MixBlend.setup)
+                        direction = MixDirection.mixIn;
+                    timeline.apply(skeleton, animationLast, applyTime, events, alpha, timelineBlend, direction);
+                }
+            }
+        }
+        if (to.mixDuration > 0)
+            this.queueEvents(from, animationTime);
+        this.events.length = 0;
+        from.nextAnimationLast = animationTime;
+        from.nextTrackLast = from.trackTime;
+        return mix;
+    }
+    applyAttachmentTimeline(timeline, skeleton, time, blend, attachments) {
+        var slot = skeleton.slots[timeline.slotIndex];
+        if (!slot.bone.active)
+            return;
+        if (time < timeline.frames[0]) { // Time is before first frame.
+            if (blend == MixBlend.setup || blend == MixBlend.first)
+                this.setAttachment(skeleton, slot, slot.data.attachmentName, attachments);
+        }
+        else
+            this.setAttachment(skeleton, slot, timeline.attachmentNames[Timeline.search1(timeline.frames, time)], attachments);
+        // If an attachment wasn't set (ie before the first frame or attachments is false), set the setup attachment later.
+        if (slot.attachmentState <= this.unkeyedState)
+            slot.attachmentState = this.unkeyedState + SETUP;
+    }
+    setAttachment(skeleton, slot, attachmentName, attachments) {
+        slot.setAttachment(!attachmentName ? null : skeleton.getAttachment(slot.data.index, attachmentName));
+        if (attachments)
+            slot.attachmentState = this.unkeyedState + CURRENT;
+    }
+    applyRotateTimeline(timeline, skeleton, time, alpha, blend, timelinesRotation, i, firstFrame) {
+        if (firstFrame)
+            timelinesRotation[i] = 0;
+        if (alpha == 1) {
+            timeline.apply(skeleton, 0, time, null, 1, blend, MixDirection.mixIn);
+            return;
+        }
+        let bone = skeleton.bones[timeline.boneIndex];
+        if (!bone.active)
+            return;
+        let frames = timeline.frames;
+        let r1 = 0, r2 = 0;
+        if (time < frames[0]) {
+            switch (blend) {
+                case MixBlend.setup:
+                    bone.rotation = bone.data.rotation;
+                default:
+                    return;
+                case MixBlend.first:
+                    r1 = bone.rotation;
+                    r2 = bone.data.rotation;
+            }
+        }
+        else {
+            r1 = blend == MixBlend.setup ? bone.data.rotation : bone.rotation;
+            r2 = bone.data.rotation + timeline.getCurveValue(time);
+        }
+        // Mix between rotations using the direction of the shortest route on the first frame while detecting crosses.
+        let total = 0, diff = r2 - r1;
+        diff -= (16384 - ((16384.499999999996 - diff / 360) | 0)) * 360;
+        if (diff == 0) {
+            total = timelinesRotation[i];
+        }
+        else {
+            let lastTotal = 0, lastDiff = 0;
+            if (firstFrame) {
+                lastTotal = 0;
+                lastDiff = diff;
+            }
+            else {
+                lastTotal = timelinesRotation[i]; // Angle and direction of mix, including loops.
+                lastDiff = timelinesRotation[i + 1]; // Difference between bones.
+            }
+            let current = diff > 0, dir = lastTotal >= 0;
+            // Detect cross at 0 (not 180).
+            if (MathUtils.signum(lastDiff) != MathUtils.signum(diff) && Math.abs(lastDiff) <= 90) {
+                // A cross after a 360 rotation is a loop.
+                if (Math.abs(lastTotal) > 180)
+                    lastTotal += 360 * MathUtils.signum(lastTotal);
+                dir = current;
+            }
+            total = diff + lastTotal - lastTotal % 360; // Store loops as part of lastTotal.
+            if (dir != current)
+                total += 360 * MathUtils.signum(lastTotal);
+            timelinesRotation[i] = total;
+        }
+        timelinesRotation[i + 1] = diff;
+        bone.rotation = r1 + total * alpha;
+    }
+    queueEvents(entry, animationTime) {
+        let animationStart = entry.animationStart, animationEnd = entry.animationEnd;
+        let duration = animationEnd - animationStart;
+        let trackLastWrapped = entry.trackLast % duration;
+        // Queue events before complete.
+        let events = this.events;
+        let i = 0, n = events.length;
+        for (; i < n; i++) {
+            let event = events[i];
+            if (event.time < trackLastWrapped)
+                break;
+            if (event.time > animationEnd)
+                continue; // Discard events outside animation start/end.
+            this.queue.event(entry, event);
+        }
+        // Queue complete if completed a loop iteration or the animation.
+        let complete = false;
+        if (entry.loop)
+            complete = duration == 0 || trackLastWrapped > entry.trackTime % duration;
+        else
+            complete = animationTime >= animationEnd && entry.animationLast < animationEnd;
+        if (complete)
+            this.queue.complete(entry);
+        // Queue events after complete.
+        for (; i < n; i++) {
+            let event = events[i];
+            if (event.time < animationStart)
+                continue; // Discard events outside animation start/end.
+            this.queue.event(entry, event);
+        }
+    }
+    /** Removes all animations from all tracks, leaving skeletons in their current pose.
+     *
+     * It may be desired to use {@link AnimationState#setEmptyAnimation()} to mix the skeletons back to the setup pose,
+     * rather than leaving them in their current pose. */
+    clearTracks() {
+        let oldDrainDisabled = this.queue.drainDisabled;
+        this.queue.drainDisabled = true;
+        for (let i = 0, n = this.tracks.length; i < n; i++)
+            this.clearTrack(i);
+        this.tracks.length = 0;
+        this.queue.drainDisabled = oldDrainDisabled;
+        this.queue.drain();
+    }
+    /** Removes all animations from the track, leaving skeletons in their current pose.
+     *
+     * It may be desired to use {@link AnimationState#setEmptyAnimation()} to mix the skeletons back to the setup pose,
+     * rather than leaving them in their current pose. */
+    clearTrack(trackIndex) {
+        if (trackIndex >= this.tracks.length)
+            return;
+        let current = this.tracks[trackIndex];
+        if (!current)
+            return;
+        this.queue.end(current);
+        this.clearNext(current);
+        let entry = current;
+        while (true) {
+            let from = entry.mixingFrom;
+            if (!from)
+                break;
+            this.queue.end(from);
+            entry.mixingFrom = null;
+            entry.mixingTo = null;
+            entry = from;
+        }
+        this.tracks[current.trackIndex] = null;
+        this.queue.drain();
+    }
+    setCurrent(index, current, interrupt) {
+        let from = this.expandToIndex(index);
+        this.tracks[index] = current;
+        current.previous = null;
+        if (from) {
+            if (interrupt)
+                this.queue.interrupt(from);
+            current.mixingFrom = from;
+            from.mixingTo = current;
+            current.mixTime = 0;
+            // Store the interrupted mix percentage.
+            if (from.mixingFrom && from.mixDuration > 0)
+                current.interruptAlpha *= Math.min(1, from.mixTime / from.mixDuration);
+            from.timelinesRotation.length = 0; // Reset rotation for mixing out, in case entry was mixed in.
+        }
+        this.queue.start(current);
+    }
+    /** Sets an animation by name.
+      *
+      * See {@link #setAnimationWith()}. */
+    setAnimation(trackIndex, animationName, loop = false) {
+        let animation = this.data.skeletonData.findAnimation(animationName);
+        if (!animation)
+            throw new Error("Animation not found: " + animationName);
+        return this.setAnimationWith(trackIndex, animation, loop);
+    }
+    /** Sets the current animation for a track, discarding any queued animations. If the formerly current track entry was never
+     * applied to a skeleton, it is replaced (not mixed from).
+     * @param loop If true, the animation will repeat. If false it will not, instead its last frame is applied if played beyond its
+     *           duration. In either case {@link TrackEntry#trackEnd} determines when the track is cleared.
+     * @returns A track entry to allow further customization of animation playback. References to the track entry must not be kept
+     *         after the {@link AnimationStateListener#dispose()} event occurs. */
+    setAnimationWith(trackIndex, animation, loop = false) {
+        if (!animation)
+            throw new Error("animation cannot be null.");
+        let interrupt = true;
+        let current = this.expandToIndex(trackIndex);
+        if (current) {
+            if (current.nextTrackLast == -1) {
+                // Don't mix from an entry that was never applied.
+                this.tracks[trackIndex] = current.mixingFrom;
+                this.queue.interrupt(current);
+                this.queue.end(current);
+                this.clearNext(current);
+                current = current.mixingFrom;
+                interrupt = false;
+            }
+            else
+                this.clearNext(current);
+        }
+        let entry = this.trackEntry(trackIndex, animation, loop, current);
+        this.setCurrent(trackIndex, entry, interrupt);
+        this.queue.drain();
+        return entry;
+    }
+    /** Queues an animation by name.
+     *
+     * See {@link #addAnimationWith()}. */
+    addAnimation(trackIndex, animationName, loop = false, delay = 0) {
+        let animation = this.data.skeletonData.findAnimation(animationName);
+        if (!animation)
+            throw new Error("Animation not found: " + animationName);
+        return this.addAnimationWith(trackIndex, animation, loop, delay);
+    }
+    /** Adds an animation to be played after the current or last queued animation for a track. If the track is empty, it is
+     * equivalent to calling {@link #setAnimationWith()}.
+     * @param delay If > 0, sets {@link TrackEntry#delay}. If <= 0, the delay set is the duration of the previous track entry
+     *           minus any mix duration (from the {@link AnimationStateData}) plus the specified `delay` (ie the mix
+     *           ends at (`delay` = 0) or before (`delay` < 0) the previous track entry duration). If the
+     *           previous entry is looping, its next loop completion is used instead of its duration.
+     * @returns A track entry to allow further customization of animation playback. References to the track entry must not be kept
+     *         after the {@link AnimationStateListener#dispose()} event occurs. */
+    addAnimationWith(trackIndex, animation, loop = false, delay = 0) {
+        if (!animation)
+            throw new Error("animation cannot be null.");
+        let last = this.expandToIndex(trackIndex);
+        if (last) {
+            while (last.next)
+                last = last.next;
+        }
+        let entry = this.trackEntry(trackIndex, animation, loop, last);
+        if (!last) {
+            this.setCurrent(trackIndex, entry, true);
+            this.queue.drain();
+        }
+        else {
+            last.next = entry;
+            entry.previous = last;
+            if (delay <= 0)
+                delay += last.getTrackComplete() - entry.mixDuration;
+        }
+        entry.delay = delay;
+        return entry;
+    }
+    /** Sets an empty animation for a track, discarding any queued animations, and sets the track entry's
+     * {@link TrackEntry#mixduration}. An empty animation has no timelines and serves as a placeholder for mixing in or out.
+     *
+     * Mixing out is done by setting an empty animation with a mix duration using either {@link #setEmptyAnimation()},
+     * {@link #setEmptyAnimations()}, or {@link #addEmptyAnimation()}. Mixing to an empty animation causes
+     * the previous animation to be applied less and less over the mix duration. Properties keyed in the previous animation
+     * transition to the value from lower tracks or to the setup pose value if no lower tracks key the property. A mix duration of
+     * 0 still mixes out over one frame.
+     *
+     * Mixing in is done by first setting an empty animation, then adding an animation using
+     * {@link #addAnimation()} and on the returned track entry, set the
+     * {@link TrackEntry#setMixDuration()}. Mixing from an empty animation causes the new animation to be applied more and
+     * more over the mix duration. Properties keyed in the new animation transition from the value from lower tracks or from the
+     * setup pose value if no lower tracks key the property to the value keyed in the new animation. */
+    setEmptyAnimation(trackIndex, mixDuration = 0) {
+        let entry = this.setAnimationWith(trackIndex, AnimationState.emptyAnimation(), false);
+        entry.mixDuration = mixDuration;
+        entry.trackEnd = mixDuration;
+        return entry;
+    }
+    /** Adds an empty animation to be played after the current or last queued animation for a track, and sets the track entry's
+     * {@link TrackEntry#mixDuration}. If the track is empty, it is equivalent to calling
+     * {@link #setEmptyAnimation()}.
+     *
+     * See {@link #setEmptyAnimation()}.
+     * @param delay If > 0, sets {@link TrackEntry#delay}. If <= 0, the delay set is the duration of the previous track entry
+     *           minus any mix duration plus the specified `delay` (ie the mix ends at (`delay` = 0) or
+     *           before (`delay` < 0) the previous track entry duration). If the previous entry is looping, its next
+     *           loop completion is used instead of its duration.
+     * @return A track entry to allow further customization of animation playback. References to the track entry must not be kept
+     *         after the {@link AnimationStateListener#dispose()} event occurs. */
+    addEmptyAnimation(trackIndex, mixDuration = 0, delay = 0) {
+        let entry = this.addAnimationWith(trackIndex, AnimationState.emptyAnimation(), false, delay);
+        if (delay <= 0)
+            entry.delay += entry.mixDuration - mixDuration;
+        entry.mixDuration = mixDuration;
+        entry.trackEnd = mixDuration;
+        return entry;
+    }
+    /** Sets an empty animation for every track, discarding any queued animations, and mixes to it over the specified mix
+      * duration. */
+    setEmptyAnimations(mixDuration = 0) {
+        let oldDrainDisabled = this.queue.drainDisabled;
+        this.queue.drainDisabled = true;
+        for (let i = 0, n = this.tracks.length; i < n; i++) {
+            let current = this.tracks[i];
+            if (current)
+                this.setEmptyAnimation(current.trackIndex, mixDuration);
+        }
+        this.queue.drainDisabled = oldDrainDisabled;
+        this.queue.drain();
+    }
+    expandToIndex(index) {
+        if (index < this.tracks.length)
+            return this.tracks[index];
+        Utils.ensureArrayCapacity(this.tracks, index + 1, null);
+        this.tracks.length = index + 1;
+        return null;
+    }
+    /** @param last May be null. */
+    trackEntry(trackIndex, animation, loop, last) {
+        let entry = this.trackEntryPool.obtain();
+        entry.reset();
+        entry.trackIndex = trackIndex;
+        entry.animation = animation;
+        entry.loop = loop;
+        entry.holdPrevious = false;
+        entry.reverse = false;
+        entry.shortestRotation = false;
+        entry.eventThreshold = 0;
+        entry.attachmentThreshold = 0;
+        entry.drawOrderThreshold = 0;
+        entry.animationStart = 0;
+        entry.animationEnd = animation.duration;
+        entry.animationLast = -1;
+        entry.nextAnimationLast = -1;
+        entry.delay = 0;
+        entry.trackTime = 0;
+        entry.trackLast = -1;
+        entry.nextTrackLast = -1;
+        entry.trackEnd = Number.MAX_VALUE;
+        entry.timeScale = 1;
+        entry.alpha = 1;
+        entry.mixTime = 0;
+        entry.mixDuration = !last ? 0 : this.data.getMix(last.animation, animation);
+        entry.interruptAlpha = 1;
+        entry.totalAlpha = 0;
+        entry.mixBlend = MixBlend.replace;
+        return entry;
+    }
+    /** Removes the {@link TrackEntry#getNext() next entry} and all entries after it for the specified entry. */
+    clearNext(entry) {
+        let next = entry.next;
+        while (next) {
+            this.queue.dispose(next);
+            next = next.next;
+        }
+        entry.next = null;
+    }
+    _animationsChanged() {
+        this.animationsChanged = false;
+        this.propertyIDs.clear();
+        let tracks = this.tracks;
+        for (let i = 0, n = tracks.length; i < n; i++) {
+            let entry = tracks[i];
+            if (!entry)
+                continue;
+            while (entry.mixingFrom)
+                entry = entry.mixingFrom;
+            do {
+                if (!entry.mixingTo || entry.mixBlend != MixBlend.add)
+                    this.computeHold(entry);
+                entry = entry.mixingTo;
+            } while (entry);
+        }
+    }
+    computeHold(entry) {
+        let to = entry.mixingTo;
+        let timelines = entry.animation.timelines;
+        let timelinesCount = entry.animation.timelines.length;
+        let timelineMode = entry.timelineMode;
+        timelineMode.length = timelinesCount;
+        let timelineHoldMix = entry.timelineHoldMix;
+        timelineHoldMix.length = 0;
+        let propertyIDs = this.propertyIDs;
+        if (to && to.holdPrevious) {
+            for (let i = 0; i < timelinesCount; i++)
+                timelineMode[i] = propertyIDs.addAll(timelines[i].getPropertyIds()) ? HOLD_FIRST : HOLD_SUBSEQUENT;
+            return;
+        }
+        outer: for (let i = 0; i < timelinesCount; i++) {
+            let timeline = timelines[i];
+            let ids = timeline.getPropertyIds();
+            if (!propertyIDs.addAll(ids))
+                timelineMode[i] = SUBSEQUENT;
+            else if (!to || timeline instanceof AttachmentTimeline || timeline instanceof DrawOrderTimeline
+                || timeline instanceof EventTimeline || !to.animation.hasTimeline(ids)) {
+                timelineMode[i] = FIRST;
+            }
+            else {
+                for (let next = to.mixingTo; next; next = next.mixingTo) {
+                    if (next.animation.hasTimeline(ids))
+                        continue;
+                    if (entry.mixDuration > 0) {
+                        timelineMode[i] = HOLD_MIX;
+                        timelineHoldMix[i] = next;
+                        continue outer;
+                    }
+                    break;
+                }
+                timelineMode[i] = HOLD_FIRST;
+            }
+        }
+    }
+    /** Returns the track entry for the animation currently playing on the track, or null if no animation is currently playing. */
+    getCurrent(trackIndex) {
+        if (trackIndex >= this.tracks.length)
+            return null;
+        return this.tracks[trackIndex];
+    }
+    /** Adds a listener to receive events for all track entries. */
+    addListener(listener) {
+        if (!listener)
+            throw new Error("listener cannot be null.");
+        this.listeners.push(listener);
+    }
+    /** Removes the listener added with {@link #addListener()}. */
+    removeListener(listener) {
+        let index = this.listeners.indexOf(listener);
+        if (index >= 0)
+            this.listeners.splice(index, 1);
+    }
+    /** Removes all listeners added with {@link #addListener()}. */
+    clearListeners() {
+        this.listeners.length = 0;
+    }
+    /** Discards all listener notifications that have not yet been delivered. This can be useful to call from an
+     * {@link AnimationStateListener} when it is known that further notifications that may have been already queued for delivery
+     * are not wanted because new animations are being set. */
+    clearListenerNotifications() {
+        this.queue.clear();
+    }
+}
+AnimationState._emptyAnimation = new Animation("<empty>", [], 0);
+/** Stores settings and other state for the playback of an animation on an {@link AnimationState} track.
+ *
+ * References to a track entry must not be kept after the {@link AnimationStateListener#dispose()} event occurs. */
+export class TrackEntry {
+    constructor() {
+        /** The animation to apply for this track entry. */
+        this.animation = null;
+        this.previous = null;
+        /** The animation queued to start after this animation, or null. `next` makes up a linked list. */
+        this.next = null;
+        /** The track entry for the previous animation when mixing from the previous animation to this animation, or null if no
+         * mixing is currently occuring. When mixing from multiple animations, `mixingFrom` makes up a linked list. */
+        this.mixingFrom = null;
+        /** The track entry for the next animation when mixing from this animation to the next animation, or null if no mixing is
+         * currently occuring. When mixing to multiple animations, `mixingTo` makes up a linked list. */
+        this.mixingTo = null;
+        /** The listener for events generated by this track entry, or null.
+         *
+         * A track entry returned from {@link AnimationState#setAnimation()} is already the current animation
+         * for the track, so the track entry listener {@link AnimationStateListener#start()} will not be called. */
+        this.listener = null;
+        /** The index of the track where this track entry is either current or queued.
+         *
+         * See {@link AnimationState#getCurrent()}. */
+        this.trackIndex = 0;
+        /** If true, the animation will repeat. If false it will not, instead its last frame is applied if played beyond its
+         * duration. */
+        this.loop = false;
+        /** If true, when mixing from the previous animation to this animation, the previous animation is applied as normal instead
+         * of being mixed out.
+         *
+         * When mixing between animations that key the same property, if a lower track also keys that property then the value will
+         * briefly dip toward the lower track value during the mix. This happens because the first animation mixes from 100% to 0%
+         * while the second animation mixes from 0% to 100%. Setting `holdPrevious` to true applies the first animation
+         * at 100% during the mix so the lower track value is overwritten. Such dipping does not occur on the lowest track which
+         * keys the property, only when a higher track also keys the property.
+         *
+         * Snapping will occur if `holdPrevious` is true and this animation does not key all the same properties as the
+         * previous animation. */
+        this.holdPrevious = false;
+        this.reverse = false;
+        this.shortestRotation = false;
+        /** When the mix percentage ({@link #mixTime} / {@link #mixDuration}) is less than the
+         * `eventThreshold`, event timelines are applied while this animation is being mixed out. Defaults to 0, so event
+         * timelines are not applied while this animation is being mixed out. */
+        this.eventThreshold = 0;
+        /** When the mix percentage ({@link #mixtime} / {@link #mixDuration}) is less than the
+         * `attachmentThreshold`, attachment timelines are applied while this animation is being mixed out. Defaults to
+         * 0, so attachment timelines are not applied while this animation is being mixed out. */
+        this.attachmentThreshold = 0;
+        /** When the mix percentage ({@link #mixTime} / {@link #mixDuration}) is less than the
+         * `drawOrderThreshold`, draw order timelines are applied while this animation is being mixed out. Defaults to 0,
+         * so draw order timelines are not applied while this animation is being mixed out. */
+        this.drawOrderThreshold = 0;
+        /** Seconds when this animation starts, both initially and after looping. Defaults to 0.
+         *
+         * When changing the `animationStart` time, it often makes sense to set {@link #animationLast} to the same
+         * value to prevent timeline keys before the start time from triggering. */
+        this.animationStart = 0;
+        /** Seconds for the last frame of this animation. Non-looping animations won't play past this time. Looping animations will
+         * loop back to {@link #animationStart} at this time. Defaults to the animation {@link Animation#duration}. */
+        this.animationEnd = 0;
+        /** The time in seconds this animation was last applied. Some timelines use this for one-time triggers. Eg, when this
+         * animation is applied, event timelines will fire all events between the `animationLast` time (exclusive) and
+         * `animationTime` (inclusive). Defaults to -1 to ensure triggers on frame 0 happen the first time this animation
+         * is applied. */
+        this.animationLast = 0;
+        this.nextAnimationLast = 0;
+        /** Seconds to postpone playing the animation. When this track entry is the current track entry, `delay`
+         * postpones incrementing the {@link #trackTime}. When this track entry is queued, `delay` is the time from
+         * the start of the previous animation to when this track entry will become the current track entry (ie when the previous
+         * track entry {@link TrackEntry#trackTime} >= this track entry's `delay`).
+         *
+         * {@link #timeScale} affects the delay. */
+        this.delay = 0;
+        /** Current time in seconds this track entry has been the current track entry. The track time determines
+         * {@link #animationTime}. The track time can be set to start the animation at a time other than 0, without affecting
+         * looping. */
+        this.trackTime = 0;
+        this.trackLast = 0;
+        this.nextTrackLast = 0;
+        /** The track time in seconds when this animation will be removed from the track. Defaults to the highest possible float
+         * value, meaning the animation will be applied until a new animation is set or the track is cleared. If the track end time
+         * is reached, no other animations are queued for playback, and mixing from any previous animations is complete, then the
+         * properties keyed by the animation are set to the setup pose and the track is cleared.
+         *
+         * It may be desired to use {@link AnimationState#addEmptyAnimation()} rather than have the animation
+         * abruptly cease being applied. */
+        this.trackEnd = 0;
+        /** Multiplier for the delta time when this track entry is updated, causing time for this animation to pass slower or
+         * faster. Defaults to 1.
+         *
+         * {@link #mixTime} is not affected by track entry time scale, so {@link #mixDuration} may need to be adjusted to
+         * match the animation speed.
+         *
+         * When using {@link AnimationState#addAnimation()} with a `delay` <= 0, note the
+         * {@link #delay} is set using the mix duration from the {@link AnimationStateData}, assuming time scale to be 1. If
+         * the time scale is not 1, the delay may need to be adjusted.
+         *
+         * See AnimationState {@link AnimationState#timeScale} for affecting all animations. */
+        this.timeScale = 0;
+        /** Values < 1 mix this animation with the skeleton's current pose (usually the pose resulting from lower tracks). Defaults
+         * to 1, which overwrites the skeleton's current pose with this animation.
+         *
+         * Typically track 0 is used to completely pose the skeleton, then alpha is used on higher tracks. It doesn't make sense to
+         * use alpha on track 0 if the skeleton pose is from the last frame render. */
+        this.alpha = 0;
+        /** Seconds from 0 to the {@link #getMixDuration()} when mixing from the previous animation to this animation. May be
+         * slightly more than `mixDuration` when the mix is complete. */
+        this.mixTime = 0;
+        /** Seconds for mixing from the previous animation to this animation. Defaults to the value provided by AnimationStateData
+         * {@link AnimationStateData#getMix()} based on the animation before this animation (if any).
+         *
+         * A mix duration of 0 still mixes out over one frame to provide the track entry being mixed out a chance to revert the
+         * properties it was animating.
+         *
+         * The `mixDuration` can be set manually rather than use the value from
+         * {@link AnimationStateData#getMix()}. In that case, the `mixDuration` can be set for a new
+         * track entry only before {@link AnimationState#update(float)} is first called.
+         *
+         * When using {@link AnimationState#addAnimation()} with a `delay` <= 0, note the
+         * {@link #delay} is set using the mix duration from the {@link AnimationStateData}, not a mix duration set
+         * afterward. */
+        this.mixDuration = 0;
+        this.interruptAlpha = 0;
+        this.totalAlpha = 0;
+        /** Controls how properties keyed in the animation are mixed with lower tracks. Defaults to {@link MixBlend#replace}, which
+         * replaces the values from the lower tracks with the animation values. {@link MixBlend#add} adds the animation values to
+         * the values from the lower tracks.
+         *
+         * The `mixBlend` can be set for a new track entry only before {@link AnimationState#apply()} is first
+         * called. */
+        this.mixBlend = MixBlend.replace;
+        this.timelineMode = new Array();
+        this.timelineHoldMix = new Array();
+        this.timelinesRotation = new Array();
+    }
+    reset() {
+        this.next = null;
+        this.previous = null;
+        this.mixingFrom = null;
+        this.mixingTo = null;
+        this.animation = null;
+        this.listener = null;
+        this.timelineMode.length = 0;
+        this.timelineHoldMix.length = 0;
+        this.timelinesRotation.length = 0;
+    }
+    /** Uses {@link #trackTime} to compute the `animationTime`, which is between {@link #animationStart}
+     * and {@link #animationEnd}. When the `trackTime` is 0, the `animationTime` is equal to the
+     * `animationStart` time. */
+    getAnimationTime() {
+        if (this.loop) {
+            let duration = this.animationEnd - this.animationStart;
+            if (duration == 0)
+                return this.animationStart;
+            return (this.trackTime % duration) + this.animationStart;
+        }
+        return Math.min(this.trackTime + this.animationStart, this.animationEnd);
+    }
+    setAnimationLast(animationLast) {
+        this.animationLast = animationLast;
+        this.nextAnimationLast = animationLast;
+    }
+    /** Returns true if at least one loop has been completed.
+     *
+     * See {@link AnimationStateListener#complete()}. */
+    isComplete() {
+        return this.trackTime >= this.animationEnd - this.animationStart;
+    }
+    /** Resets the rotation directions for mixing this entry's rotate timelines. This can be useful to avoid bones rotating the
+     * long way around when using {@link #alpha} and starting animations on other tracks.
+     *
+     * Mixing with {@link MixBlend#replace} involves finding a rotation between two others, which has two possible solutions:
+     * the short way or the long way around. The two rotations likely change over time, so which direction is the short or long
+     * way also changes. If the short way was always chosen, bones would flip to the other side when that direction became the
+     * long way. TrackEntry chooses the short way the first time it is applied and remembers that direction. */
+    resetRotationDirections() {
+        this.timelinesRotation.length = 0;
+    }
+    getTrackComplete() {
+        let duration = this.animationEnd - this.animationStart;
+        if (duration != 0) {
+            if (this.loop)
+                return duration * (1 + ((this.trackTime / duration) | 0)); // Completion of next loop.
+            if (this.trackTime < duration)
+                return duration; // Before duration.
+        }
+        return this.trackTime; // Next update.
+    }
+}
+export class EventQueue {
+    constructor(animState) {
+        this.objects = [];
+        this.drainDisabled = false;
+        this.animState = animState;
+    }
+    start(entry) {
+        this.objects.push(EventType.start);
+        this.objects.push(entry);
+        this.animState.animationsChanged = true;
+    }
+    interrupt(entry) {
+        this.objects.push(EventType.interrupt);
+        this.objects.push(entry);
+    }
+    end(entry) {
+        this.objects.push(EventType.end);
+        this.objects.push(entry);
+        this.animState.animationsChanged = true;
+    }
+    dispose(entry) {
+        this.objects.push(EventType.dispose);
+        this.objects.push(entry);
+    }
+    complete(entry) {
+        this.objects.push(EventType.complete);
+        this.objects.push(entry);
+    }
+    event(entry, event) {
+        this.objects.push(EventType.event);
+        this.objects.push(entry);
+        this.objects.push(event);
+    }
+    drain() {
+        if (this.drainDisabled)
+            return;
+        this.drainDisabled = true;
+        let objects = this.objects;
+        let listeners = this.animState.listeners;
+        for (let i = 0; i < objects.length; i += 2) {
+            let type = objects[i];
+            let entry = objects[i + 1];
+            switch (type) {
+                case EventType.start:
+                    if (entry.listener && entry.listener.start)
+                        entry.listener.start(entry);
+                    for (let ii = 0; ii < listeners.length; ii++) {
+                        let listener = listeners[ii];
+                        if (listener.start)
+                            listener.start(entry);
+                    }
+                    break;
+                case EventType.interrupt:
+                    if (entry.listener && entry.listener.interrupt)
+                        entry.listener.interrupt(entry);
+                    for (let ii = 0; ii < listeners.length; ii++) {
+                        let listener = listeners[ii];
+                        if (listener.interrupt)
+                            listener.interrupt(entry);
+                    }
+                    break;
+                case EventType.end:
+                    if (entry.listener && entry.listener.end)
+                        entry.listener.end(entry);
+                    for (let ii = 0; ii < listeners.length; ii++) {
+                        let listener = listeners[ii];
+                        if (listener.end)
+                            listener.end(entry);
+                    }
+                // Fall through.
+                case EventType.dispose:
+                    if (entry.listener && entry.listener.dispose)
+                        entry.listener.dispose(entry);
+                    for (let ii = 0; ii < listeners.length; ii++) {
+                        let listener = listeners[ii];
+                        if (listener.dispose)
+                            listener.dispose(entry);
+                    }
+                    this.animState.trackEntryPool.free(entry);
+                    break;
+                case EventType.complete:
+                    if (entry.listener && entry.listener.complete)
+                        entry.listener.complete(entry);
+                    for (let ii = 0; ii < listeners.length; ii++) {
+                        let listener = listeners[ii];
+                        if (listener.complete)
+                            listener.complete(entry);
+                    }
+                    break;
+                case EventType.event:
+                    let event = objects[i++ + 2];
+                    if (entry.listener && entry.listener.event)
+                        entry.listener.event(entry, event);
+                    for (let ii = 0; ii < listeners.length; ii++) {
+                        let listener = listeners[ii];
+                        if (listener.event)
+                            listener.event(entry, event);
+                    }
+                    break;
+            }
+        }
+        this.clear();
+        this.drainDisabled = false;
+    }
+    clear() {
+        this.objects.length = 0;
+    }
+}
+export var EventType;
+(function (EventType) {
+    EventType[EventType["start"] = 0] = "start";
+    EventType[EventType["interrupt"] = 1] = "interrupt";
+    EventType[EventType["end"] = 2] = "end";
+    EventType[EventType["dispose"] = 3] = "dispose";
+    EventType[EventType["complete"] = 4] = "complete";
+    EventType[EventType["event"] = 5] = "event";
+})(EventType || (EventType = {}));
+export class AnimationStateAdapter {
+    start(entry) {
+    }
+    interrupt(entry) {
+    }
+    end(entry) {
+    }
+    dispose(entry) {
+    }
+    complete(entry) {
+    }
+    event(entry, event) {
+    }
+}
+/** 1. A previously applied timeline has set this property.
+ *
+ * Result: Mix from the current pose to the timeline pose. */
+export const SUBSEQUENT = 0;
+/** 1. This is the first timeline to set this property.
+ * 2. The next track entry applied after this one does not have a timeline to set this property.
+ *
+ * Result: Mix from the setup pose to the timeline pose. */
+export const FIRST = 1;
+/** 1) A previously applied timeline has set this property.<br>
+ * 2) The next track entry to be applied does have a timeline to set this property.<br>
+ * 3) The next track entry after that one does not have a timeline to set this property.<br>
+ * Result: Mix from the current pose to the timeline pose, but do not mix out. This avoids "dipping" when crossfading
+ * animations that key the same property. A subsequent timeline will set this property using a mix. */
+export const HOLD_SUBSEQUENT = 2;
+/** 1) This is the first timeline to set this property.<br>
+ * 2) The next track entry to be applied does have a timeline to set this property.<br>
+ * 3) The next track entry after that one does not have a timeline to set this property.<br>
+ * Result: Mix from the setup pose to the timeline pose, but do not mix out. This avoids "dipping" when crossfading animations
+ * that key the same property. A subsequent timeline will set this property using a mix. */
+export const HOLD_FIRST = 3;
+/** 1. This is the first timeline to set this property.
+ * 2. The next track entry to be applied does have a timeline to set this property.
+ * 3. The next track entry after that one does have a timeline to set this property.
+ * 4. timelineHoldMix stores the first subsequent track entry that does not have a timeline to set this property.
+ *
+ * Result: The same as HOLD except the mix percentage from the timelineHoldMix track entry is used. This handles when more than
+ * 2 track entries in a row have a timeline that sets the same property.
+ *
+ * Eg, A -> B -> C -> D where A, B, and C have a timeline setting same property, but D does not. When A is applied, to avoid
+ * "dipping" A is not mixed out, however D (the first entry that doesn't set the property) mixing in is used to mix out A
+ * (which affects B and C). Without using D to mix out, A would be applied fully until mixing completes, then snap into
+ * place. */
+export const HOLD_MIX = 4;
+export const SETUP = 1;
+export const CURRENT = 2;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"AnimationState.js","sourceRoot":"","sources":["../src/AnimationState.ts"],"names":[],"mappings":"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"}