@safe-engine/pixi 8.8.2 → 8.8.3

package/dist/dragonbones/dragonBones/animation/BaseTimelineState.d.ts

@@ -0,0 +1,100 @@
+import { Armature } from "../armature/Armature";
+import { BaseObject } from "../core/BaseObject";
+import { TweenType } from "../core/DragonBones";
+import { AnimationData, TimelineData } from "../model/AnimationData";
+import { AnimationState } from "./AnimationState";
+/**
+ * @internal
+ */
+export declare abstract class TimelineState extends BaseObject {
+    dirty: boolean;
+    /**
+     * -1: start, 0: play, 1: complete;
+     */
+    playState: number;
+    currentPlayTimes: number;
+    currentTime: number;
+    target: BaseObject;
+    protected _isTween: boolean;
+    protected _valueOffset: number;
+    protected _frameValueOffset: number;
+    protected _frameOffset: number;
+    protected _frameRate: number;
+    protected _frameCount: number;
+    protected _frameIndex: number;
+    protected _frameRateR: number;
+    protected _position: number;
+    protected _duration: number;
+    protected _timeScale: number;
+    protected _timeOffset: number;
+    protected _animationData: AnimationData;
+    protected _timelineData: TimelineData | null;
+    protected _armature: Armature;
+    protected _animationState: AnimationState;
+    protected _actionTimeline: TimelineState;
+    protected _timelineArray: Array<number> | Uint16Array;
+    protected _frameArray: Array<number> | Int16Array;
+    protected _valueArray: Array<number> | Int16Array | Float32Array;
+    protected _frameIndices: Array<number>;
+    protected _onClear(): void;
+    protected abstract _onArriveAtFrame(): void;
+    protected abstract _onUpdateFrame(): void;
+    protected _setCurrentTime(passedTime: number): boolean;
+    init(armature: Armature, animationState: AnimationState, timelineData: TimelineData | null): void;
+    fadeOut(): void;
+    update(passedTime: number): void;
+    blend(_isDirty: boolean): void;
+}
+/**
+ * @internal
+ */
+export declare abstract class TweenTimelineState extends TimelineState {
+    private static _getEasingValue;
+    private static _getEasingCurveValue;
+    protected _tweenType: TweenType;
+    protected _curveCount: number;
+    protected _framePosition: number;
+    protected _frameDurationR: number;
+    protected _tweenEasing: number;
+    protected _tweenProgress: number;
+    protected _valueScale: number;
+    protected _onClear(): void;
+    protected _onArriveAtFrame(): void;
+    protected _onUpdateFrame(): void;
+}
+/**
+ * @internal
+ */
+export declare abstract class SingleValueTimelineState extends TweenTimelineState {
+    protected _current: number;
+    protected _difference: number;
+    protected _result: number;
+    protected _onClear(): void;
+    protected _onArriveAtFrame(): void;
+    protected _onUpdateFrame(): void;
+}
+/**
+ * @internal
+ */
+export declare abstract class DoubleValueTimelineState extends TweenTimelineState {
+    protected _currentA: number;
+    protected _currentB: number;
+    protected _differenceA: number;
+    protected _differenceB: number;
+    protected _resultA: number;
+    protected _resultB: number;
+    protected _onClear(): void;
+    protected _onArriveAtFrame(): void;
+    protected _onUpdateFrame(): void;
+}
+/**
+ * @internal
+ */
+export declare abstract class MutilpleValueTimelineState extends TweenTimelineState {
+    protected _valueCount: number;
+    protected readonly _rd: Array<number>;
+    protected _onClear(): void;
+    protected _onArriveAtFrame(): void;
+    protected _onUpdateFrame(): void;
+}
+//# sourceMappingURL=BaseTimelineState.d.ts.map

package/dist/dragonbones/dragonBones/animation/BaseTimelineState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BaseTimelineState.d.ts","sourceRoot":"","sources":["../../../../src/dragonbones/dragonBones/animation/BaseTimelineState.ts"],"names":[],"mappings":"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"}

package/dist/dragonbones/dragonBones/animation/BaseTimelineState.js

@@ -0,0 +1,479 @@
+import { BaseObject } from "../core/BaseObject";
+/**
+ * @internal
+ */
+export class TimelineState extends BaseObject {
+    _onClear() {
+        this.dirty = false;
+        this.playState = -1;
+        this.currentPlayTimes = 0;
+        this.currentTime = -1.0;
+        this.target = null;
+        this._isTween = false;
+        this._valueOffset = 0;
+        this._frameValueOffset = 0;
+        this._frameOffset = 0;
+        this._frameRate = 0;
+        this._frameCount = 0;
+        this._frameIndex = -1;
+        this._frameRateR = 0.0;
+        this._position = 0.0;
+        this._duration = 0.0;
+        this._timeScale = 1.0;
+        this._timeOffset = 0.0;
+        this._animationData = null; //
+        this._timelineData = null; //
+        this._armature = null; //
+        this._animationState = null; //
+        this._actionTimeline = null; //
+        this._frameArray = null; //
+        this._valueArray = null; //
+        this._timelineArray = null; //
+        this._frameIndices = null; //
+    }
+    _setCurrentTime(passedTime) {
+        const prevState = this.playState;
+        const prevPlayTimes = this.currentPlayTimes;
+        const prevTime = this.currentTime;
+        if (this._actionTimeline !== null && this._frameCount <= 1) {
+            // No frame or only one frame.
+            this.playState = this._actionTimeline.playState >= 0 ? 1 : -1;
+            this.currentPlayTimes = 1;
+            this.currentTime = this._actionTimeline.currentTime;
+        }
+        else if (this._actionTimeline === null ||
+            this._timeScale !== 1.0 ||
+            this._timeOffset !== 0.0) {
+            // Action timeline or has scale and offset.
+            const playTimes = this._animationState.playTimes;
+            const totalTime = playTimes * this._duration;
+            passedTime *= this._timeScale;
+            if (this._timeOffset !== 0.0) {
+                passedTime += this._timeOffset * this._animationData.duration;
+            }
+            if (playTimes > 0 &&
+                (passedTime >= totalTime || passedTime <= -totalTime)) {
+                if (this.playState <= 0 && this._animationState._playheadState === 3) {
+                    this.playState = 1;
+                }
+                this.currentPlayTimes = playTimes;
+                if (passedTime < 0.0) {
+                    this.currentTime = 0.0;
+                }
+                else {
+                    this.currentTime =
+                        this.playState === 1 ? this._duration + 0.000001 : this._duration; // Precision problem
+                }
+            }
+            else {
+                if (this.playState !== 0 && this._animationState._playheadState === 3) {
+                    this.playState = 0;
+                }
+                if (passedTime < 0.0) {
+                    passedTime = -passedTime;
+                    this.currentPlayTimes = Math.floor(passedTime / this._duration);
+                    this.currentTime = this._duration - (passedTime % this._duration);
+                }
+                else {
+                    this.currentPlayTimes = Math.floor(passedTime / this._duration);
+                    this.currentTime = passedTime % this._duration;
+                }
+            }
+            this.currentTime += this._position;
+        }
+        else {
+            // Multi frames.
+            this.playState = this._actionTimeline.playState;
+            this.currentPlayTimes = this._actionTimeline.currentPlayTimes;
+            this.currentTime = this._actionTimeline.currentTime;
+        }
+        if (this.currentPlayTimes === prevPlayTimes &&
+            this.currentTime === prevTime) {
+            return false;
+        }
+        // Clear frame flag when timeline start or loopComplete.
+        if ((prevState < 0 && this.playState !== prevState) ||
+            (this.playState <= 0 && this.currentPlayTimes !== prevPlayTimes)) {
+            this._frameIndex = -1;
+        }
+        return true;
+    }
+    init(armature, animationState, timelineData) {
+        this._armature = armature;
+        this._animationState = animationState;
+        this._timelineData = timelineData;
+        this._actionTimeline = this._animationState._actionTimeline;
+        if (this === this._actionTimeline) {
+            this._actionTimeline = null; //
+        }
+        this._animationData = this._animationState.animationData;
+        //
+        this._frameRate = this._animationData.parent.frameRate;
+        this._frameRateR = 1.0 / this._frameRate;
+        this._position = this._animationState._position;
+        this._duration = this._animationState._duration;
+        if (this._timelineData !== null) {
+            const dragonBonesData = this._animationData.parent.parent; // May by the animation data is not belone to this armature data.
+            this._frameArray = dragonBonesData.frameArray;
+            this._timelineArray = dragonBonesData.timelineArray;
+            this._frameIndices = dragonBonesData.frameIndices;
+            //
+            this._frameCount =
+                this._timelineArray[this._timelineData.offset + 2 /* BinaryOffset.TimelineKeyFrameCount */];
+            this._frameValueOffset =
+                this._timelineArray[this._timelineData.offset + 4 /* BinaryOffset.TimelineFrameValueOffset */];
+            this._timeScale =
+                100.0 /
+                    this._timelineArray[this._timelineData.offset + 0 /* BinaryOffset.TimelineScale */];
+            this._timeOffset =
+                this._timelineArray[this._timelineData.offset + 1 /* BinaryOffset.TimelineOffset */] * 0.01;
+        }
+    }
+    fadeOut() {
+        this.dirty = false;
+    }
+    update(passedTime) {
+        if (this._setCurrentTime(passedTime)) {
+            if (this._frameCount > 1) {
+                const timelineFrameIndex = Math.floor(this.currentTime * this._frameRate); // uint
+                const frameIndex = this._frameIndices[this._timelineData.frameIndicesOffset +
+                    timelineFrameIndex];
+                if (this._frameIndex !== frameIndex) {
+                    this._frameIndex = frameIndex;
+                    this._frameOffset =
+                        this._animationData.frameOffset +
+                            this._timelineArray[this._timelineData.offset +
+                                5 /* BinaryOffset.TimelineFrameOffset */ +
+                                this._frameIndex];
+                    this._onArriveAtFrame();
+                }
+            }
+            else if (this._frameIndex < 0) {
+                this._frameIndex = 0;
+                if (this._timelineData !== null) {
+                    // May be pose timeline.
+                    this._frameOffset =
+                        this._animationData.frameOffset +
+                            this._timelineArray[this._timelineData.offset + 5 /* BinaryOffset.TimelineFrameOffset */];
+                }
+                this._onArriveAtFrame();
+            }
+            if (this._isTween || this.dirty) {
+                this._onUpdateFrame();
+            }
+        }
+    }
+    blend(_isDirty) { }
+}
+/**
+ * @internal
+ */
+export class TweenTimelineState extends TimelineState {
+    static _getEasingValue(tweenType, progress, easing) {
+        let value = progress;
+        switch (tweenType) {
+            case 3 /* TweenType.QuadIn */:
+                value = Math.pow(progress, 2.0);
+                break;
+            case 4 /* TweenType.QuadOut */:
+                value = 1.0 - Math.pow(1.0 - progress, 2.0);
+                break;
+            case 5 /* TweenType.QuadInOut */:
+                value = 0.5 * (1.0 - Math.cos(progress * Math.PI));
+                break;
+        }
+        return (value - progress) * easing + progress;
+    }
+    static _getEasingCurveValue(progress, samples, count, offset) {
+        if (progress <= 0.0) {
+            return 0.0;
+        }
+        else if (progress >= 1.0) {
+            return 1.0;
+        }
+        const isOmited = count > 0;
+        const segmentCount = count + 1; // + 2 - 1
+        const valueIndex = Math.floor(progress * segmentCount);
+        let fromValue = 0.0;
+        let toValue = 0.0;
+        if (isOmited) {
+            fromValue = valueIndex === 0 ? 0.0 : samples[offset + valueIndex - 1];
+            toValue =
+                valueIndex === segmentCount - 1
+                    ? 10000.0
+                    : samples[offset + valueIndex];
+        }
+        else {
+            fromValue = samples[offset + valueIndex - 1];
+            toValue = samples[offset + valueIndex];
+        }
+        return ((fromValue +
+            (toValue - fromValue) * (progress * segmentCount - valueIndex)) *
+            0.0001);
+    }
+    _onClear() {
+        super._onClear();
+        this._tweenType = 0 /* TweenType.None */;
+        this._curveCount = 0;
+        this._framePosition = 0.0;
+        this._frameDurationR = 0.0;
+        this._tweenEasing = 0.0;
+        this._tweenProgress = 0.0;
+        this._valueScale = 1.0;
+    }
+    _onArriveAtFrame() {
+        if (this._frameCount > 1 &&
+            (this._frameIndex !== this._frameCount - 1 ||
+                this._animationState.playTimes === 0 ||
+                this._animationState.currentPlayTimes <
+                    this._animationState.playTimes - 1)) {
+            this._tweenType =
+                this._frameArray[this._frameOffset + 1 /* BinaryOffset.FrameTweenType */];
+            this._isTween = this._tweenType !== 0 /* TweenType.None */;
+            if (this._isTween) {
+                if (this._tweenType === 2 /* TweenType.Curve */) {
+                    this._curveCount =
+                        this._frameArray[this._frameOffset +
+                            2 /* BinaryOffset.FrameTweenEasingOrCurveSampleCount */];
+                }
+                else if (this._tweenType !== 0 /* TweenType.None */ &&
+                    this._tweenType !== 1 /* TweenType.Line */) {
+                    this._tweenEasing =
+                        this._frameArray[this._frameOffset +
+                            2 /* BinaryOffset.FrameTweenEasingOrCurveSampleCount */] * 0.01;
+                }
+            }
+            else {
+                this.dirty = true;
+            }
+            this._framePosition =
+                this._frameArray[this._frameOffset] * this._frameRateR;
+            if (this._frameIndex === this._frameCount - 1) {
+                this._frameDurationR =
+                    1.0 / (this._animationData.duration - this._framePosition);
+            }
+            else {
+                const nextFrameOffset = this._animationData.frameOffset +
+                    this._timelineArray[this._timelineData.offset +
+                        5 /* BinaryOffset.TimelineFrameOffset */ +
+                        this._frameIndex +
+                        1];
+                const frameDuration = this._frameArray[nextFrameOffset] * this._frameRateR -
+                    this._framePosition;
+                if (frameDuration > 0) {
+                    this._frameDurationR = 1.0 / frameDuration;
+                }
+                else {
+                    this._frameDurationR = 0.0;
+                }
+            }
+        }
+        else {
+            this.dirty = true;
+            this._isTween = false;
+        }
+    }
+    _onUpdateFrame() {
+        if (this._isTween) {
+            this.dirty = true;
+            this._tweenProgress =
+                (this.currentTime - this._framePosition) * this._frameDurationR;
+            if (this._tweenType === 2 /* TweenType.Curve */) {
+                this._tweenProgress = TweenTimelineState._getEasingCurveValue(this._tweenProgress, this._frameArray, this._curveCount, this._frameOffset + 3 /* BinaryOffset.FrameCurveSamples */);
+            }
+            else if (this._tweenType !== 1 /* TweenType.Line */) {
+                this._tweenProgress = TweenTimelineState._getEasingValue(this._tweenType, this._tweenProgress, this._tweenEasing);
+            }
+        }
+    }
+}
+/**
+ * @internal
+ */
+export class SingleValueTimelineState extends TweenTimelineState {
+    _onClear() {
+        super._onClear();
+        this._current = 0.0;
+        this._difference = 0.0;
+        this._result = 0.0;
+    }
+    _onArriveAtFrame() {
+        super._onArriveAtFrame();
+        if (this._timelineData !== null) {
+            const valueScale = this._valueScale;
+            const valueArray = this._valueArray;
+            //
+            const valueOffset = this._valueOffset + this._frameValueOffset + this._frameIndex;
+            if (this._isTween) {
+                const nextValueOffset = this._frameIndex === this._frameCount - 1
+                    ? this._valueOffset + this._frameValueOffset
+                    : valueOffset + 1;
+                if (valueScale === 1.0) {
+                    this._current = valueArray[valueOffset];
+                    this._difference = valueArray[nextValueOffset] - this._current;
+                }
+                else {
+                    this._current = valueArray[valueOffset] * valueScale;
+                    this._difference =
+                        valueArray[nextValueOffset] * valueScale - this._current;
+                }
+            }
+            else {
+                this._result = valueArray[valueOffset] * valueScale;
+            }
+        }
+        else {
+            this._result = 0.0;
+        }
+    }
+    _onUpdateFrame() {
+        super._onUpdateFrame();
+        if (this._isTween) {
+            this._result = this._current + this._difference * this._tweenProgress;
+        }
+    }
+}
+/**
+ * @internal
+ */
+export class DoubleValueTimelineState extends TweenTimelineState {
+    _onClear() {
+        super._onClear();
+        this._currentA = 0.0;
+        this._currentB = 0.0;
+        this._differenceA = 0.0;
+        this._differenceB = 0.0;
+        this._resultA = 0.0;
+        this._resultB = 0.0;
+    }
+    _onArriveAtFrame() {
+        super._onArriveAtFrame();
+        if (this._timelineData !== null) {
+            const valueScale = this._valueScale;
+            const valueArray = this._valueArray;
+            //
+            const valueOffset = this._valueOffset + this._frameValueOffset + this._frameIndex * 2;
+            if (this._isTween) {
+                const nextValueOffset = this._frameIndex === this._frameCount - 1
+                    ? this._valueOffset + this._frameValueOffset
+                    : valueOffset + 2;
+                if (valueScale === 1.0) {
+                    this._currentA = valueArray[valueOffset];
+                    this._currentB = valueArray[valueOffset + 1];
+                    this._differenceA = valueArray[nextValueOffset] - this._currentA;
+                    this._differenceB = valueArray[nextValueOffset + 1] - this._currentB;
+                }
+                else {
+                    this._currentA = valueArray[valueOffset] * valueScale;
+                    this._currentB = valueArray[valueOffset + 1] * valueScale;
+                    this._differenceA =
+                        valueArray[nextValueOffset] * valueScale - this._currentA;
+                    this._differenceB =
+                        valueArray[nextValueOffset + 1] * valueScale - this._currentB;
+                }
+            }
+            else {
+                this._resultA = valueArray[valueOffset] * valueScale;
+                this._resultB = valueArray[valueOffset + 1] * valueScale;
+            }
+        }
+        else {
+            this._resultA = 0.0;
+            this._resultB = 0.0;
+        }
+    }
+    _onUpdateFrame() {
+        super._onUpdateFrame();
+        if (this._isTween) {
+            this._resultA = this._currentA + this._differenceA * this._tweenProgress;
+            this._resultB = this._currentB + this._differenceB * this._tweenProgress;
+        }
+    }
+}
+/**
+ * @internal
+ */
+export class MutilpleValueTimelineState extends TweenTimelineState {
+    constructor() {
+        super(...arguments);
+        this._rd = [];
+    }
+    _onClear() {
+        super._onClear();
+        this._valueCount = 0;
+        this._rd.length = 0;
+    }
+    _onArriveAtFrame() {
+        super._onArriveAtFrame();
+        const valueCount = this._valueCount;
+        const rd = this._rd;
+        if (this._timelineData !== null) {
+            const valueScale = this._valueScale;
+            const valueArray = this._valueArray;
+            //
+            const valueOffset = this._valueOffset +
+                this._frameValueOffset +
+                this._frameIndex * valueCount;
+            if (this._isTween) {
+                const nextValueOffset = this._frameIndex === this._frameCount - 1
+                    ? this._valueOffset + this._frameValueOffset
+                    : valueOffset + valueCount;
+                if (valueScale === 1.0) {
+                    for (let i = 0; i < valueCount; ++i) {
+                        rd[valueCount + i] =
+                            valueArray[nextValueOffset + i] - valueArray[valueOffset + i];
+                    }
+                }
+                else {
+                    for (let i = 0; i < valueCount; ++i) {
+                        rd[valueCount + i] =
+                            (valueArray[nextValueOffset + i] - valueArray[valueOffset + i]) *
+                                valueScale;
+                    }
+                }
+            }
+            else if (valueScale === 1.0) {
+                for (let i = 0; i < valueCount; ++i) {
+                    rd[i] = valueArray[valueOffset + i];
+                }
+            }
+            else {
+                for (let i = 0; i < valueCount; ++i) {
+                    rd[i] = valueArray[valueOffset + i] * valueScale;
+                }
+            }
+        }
+        else {
+            for (let i = 0; i < valueCount; ++i) {
+                rd[i] = 0.0;
+            }
+        }
+    }
+    _onUpdateFrame() {
+        super._onUpdateFrame();
+        if (this._isTween) {
+            const valueCount = this._valueCount;
+            const valueScale = this._valueScale;
+            const tweenProgress = this._tweenProgress;
+            const valueArray = this._valueArray;
+            const rd = this._rd;
+            //
+            const valueOffset = this._valueOffset +
+                this._frameValueOffset +
+                this._frameIndex * valueCount;
+            if (valueScale === 1.0) {
+                for (let i = 0; i < valueCount; ++i) {
+                    rd[i] =
+                        valueArray[valueOffset + i] + rd[valueCount + i] * tweenProgress;
+                }
+            }
+            else {
+                for (let i = 0; i < valueCount; ++i) {
+                    rd[i] =
+                        valueArray[valueOffset + i] * valueScale +
+                            rd[valueCount + i] * tweenProgress;
+                }
+            }
+        }
+    }
+}

package/dist/dragonbones/dragonBones/animation/IAnimatable.d.ts

@@ -0,0 +1,38 @@
+/**
+     * - Play animation interface. (Both Armature and Wordclock implement the interface)
+     * Any instance that implements the interface can be added to the Worldclock instance and advance time by Worldclock instance uniformly.
+     * @see dragonBones.WorldClock
+     * @see dragonBones.Armature
+     * @version DragonBones 3.0
+     * @language en_US
+     */
+import { WorldClock } from "./WorldClock";
+/**
+ * - Play animation interface. (Both Armature and WordClock implement this interface)
+ * Any instance that implements this interface can be added to the WorldClock instance and have its time updated uniformly by the WorldClock instance.
+ * @see dragonBones.WorldClock
+ * @see dragonBones.Armature
+ * @version DragonBones 3.0
+ * @language en_US
+ */
+export interface IAnimatable {
+    /**
+     * - Advance time.
+     * @param passedTime - Passed time. (In seconds)
+     * @version DragonBones 3.0
+     * @language en_US
+     */
+    advanceTime(passedTime: number): void;
+    /**
+     * - The Wordclock instance to which the current belongs.
+     * @example
+     * <pre>
+     *     armature.clock = factory.clock; // Add armature to clock.
+     *     armature.clock = null; // Remove armature from clock.
+     * </pre>
+     * @version DragonBones 5.0
+     * @language en_US
+     */
+    clock: WorldClock | null;
+}
+//# sourceMappingURL=IAnimatable.d.ts.map

package/dist/dragonbones/dragonBones/animation/IAnimatable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IAnimatable.d.ts","sourceRoot":"","sources":["../../../../src/dragonbones/dragonBones/animation/IAnimatable.ts"],"names":[],"mappings":"AAAA;;;;;;;OAOO;AAEP,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAEtC;;;;;;;GAOG;AACH,MAAM,WAAW,WAAW;IACxB;;;;;OAKG;IACH,WAAW,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IACtC;;;;;;;;;OASG;IACH,KAAK,EAAE,UAAU,GAAG,IAAI,CAAC;CAC5B"}

package/dist/dragonbones/dragonBones/animation/IAnimatable.js

@@ -0,0 +1,9 @@
+/**
+     * - Play animation interface. (Both Armature and Wordclock implement the interface)
+     * Any instance that implements the interface can be added to the Worldclock instance and advance time by Worldclock instance uniformly.
+     * @see dragonBones.WorldClock
+     * @see dragonBones.Armature
+     * @version DragonBones 3.0
+     * @language en_US
+     */
+export {};