初始化适配信息

extensions/demo/demo_egret/libs/ecs-tween/ecs-tween.d.ts

@@ -0,0 +1,319 @@
+declare module es {
+    abstract class AbstractTweenable implements ITweenable {
+        protected _isPaused: boolean;
+        protected _isCurrentlyManagedByTweenManager: boolean;
+        abstract tick(): boolean;
+        recycleSelf(): void;
+        isRunning(): boolean;
+        start(): void;
+        pause(): void;
+        resume(): void;
+        stop(bringToCompletion?: boolean): void;
+    }
+}
+declare module es {
+    class PropertyTweens {
+        static NumberPropertyTo(self: any, memberName: string, to: number, duration: number): ITween<number>;
+        static Vector2PropertyTo(self: any, memeberName: string, to: Vector2, duration: number): ITween<Vector2>;
+    }
+}
+declare module es {
+    class TransformSpringTween extends AbstractTweenable {
+        readonly targetType: TransformTargetType;
+        private _transform;
+        private _targetType;
+        private _targetValue;
+        private _velocity;
+        dampingRatio: number;
+        angularFrequency: number;
+        constructor(transform: Transform, targetType: TransformTargetType, targetValue: Vector2);
+        setTargetValue(targetValue: Vector2): void;
+        updateDampingRatioWithHalfLife(lambda: number): void;
+        tick(): boolean;
+        private setTweenedValue;
+        private getCurrentValueOfTweenedTargetType;
+    }
+}
+declare module es {
+    enum LoopType {
+        none = 0,
+        restartFromBeginning = 1,
+        pingpong = 2
+    }
+    enum TweenState {
+        running = 0,
+        paused = 1,
+        complete = 2
+    }
+    abstract class Tween<T> implements ITweenable, ITween<T> {
+        protected _target: ITweenTarget<T>;
+        protected _isFromValueOverridden: boolean;
+        protected _fromValue: T;
+        protected _toValue: T;
+        protected _easeType: EaseType;
+        protected _shouldRecycleTween: boolean;
+        protected _isRelative: boolean;
+        protected _completionHandler: (tween: ITween<T>) => void;
+        protected _loopCompleteHandler: (tween: ITween<T>) => void;
+        protected _nextTween: ITweenable;
+        protected _tweenState: TweenState;
+        private _isTimeScaleIndependent;
+        protected _delay: number;
+        protected _duration: number;
+        protected _timeScale: number;
+        protected _elapsedTime: number;
+        protected _loopType: LoopType;
+        protected _loops: number;
+        protected _delayBetweenLoops: number;
+        private _isRunningInReverse;
+        context: any;
+        setEaseType(easeType: EaseType): ITween<T>;
+        setDelay(delay: number): ITween<T>;
+        setDuration(duration: number): ITween<T>;
+        setTimeScale(timeSclae: number): ITween<T>;
+        setIsTimeScaleIndependent(): ITween<T>;
+        setCompletionHandler(completeHandler: (tween: ITween<T>) => void): ITween<T>;
+        setLoops(loopType: LoopType, loops?: number, delayBetweenLoops?: number): ITween<T>;
+        setLoopCompletionHanlder(loopCompleteHandler: (tween: ITween<T>) => void): ITween<T>;
+        setFrom(from: T): ITween<T>;
+        prepareForReuse(from: T, to: T, duration: number): ITween<T>;
+        setRecycleTween(shouldRecycleTween: boolean): ITween<T>;
+        abstract setIsRelative(): ITween<T>;
+        setContext(context: any): ITween<T>;
+        setNextTween(nextTween: ITweenable): ITween<T>;
+        tick(): boolean;
+        recycleSelf(): void;
+        isRunning(): boolean;
+        start(): void;
+        pause(): void;
+        resume(): void;
+        stop(bringToCompletion?: boolean): void;
+        jumpToElapsedTime(elapsedTime: any): void;
+        reverseTween(): void;
+        waitForCompletion(): IterableIterator<any>;
+        getTargetObject(): any;
+        private resetState;
+        initialize(target: ITweenTarget<T>, to: T, duration: number): void;
+        private handleLooping;
+        protected abstract updateValue(): any;
+    }
+}
+declare module es {
+    class NumberTween extends Tween<number> {
+        static create(): NumberTween;
+        constructor(target?: ITweenTarget<number>, to?: number, duration?: number);
+        setIsRelative(): ITween<number>;
+        protected updateValue(): void;
+        recycleSelf(): void;
+    }
+    class Vector2Tween extends Tween<Vector2> {
+        static create(): Vector2Tween;
+        constructor(target?: ITweenTarget<Vector2>, to?: Vector2, duration?: number);
+        setIsRelative(): ITween<Vector2>;
+        protected updateValue(): void;
+        recycleSelf(): void;
+    }
+    class RectangleTween extends Tween<Rectangle> {
+        static create(): RectangleTween;
+        constructor(target?: ITweenTarget<Rectangle>, to?: Rectangle, duration?: number);
+        setIsRelative(): ITween<Rectangle>;
+        protected updateValue(): void;
+        recycleSelf(): void;
+    }
+}
+declare module es {
+    enum TransformTargetType {
+        position = 0,
+        localPosition = 1,
+        scale = 2,
+        localScale = 3,
+        rotationDegrees = 4,
+        localRotationDegrees = 5
+    }
+    class TransformVector2Tween extends Vector2Tween implements ITweenTarget<Vector2> {
+        private _transform;
+        private _targetType;
+        setTweenedValue(value: Vector2): void;
+        getTweenedValue(): Vector2;
+        getTargetObject(): Transform;
+        setTargetAndType(transform: Transform, targetType: TransformTargetType): void;
+        protected updateValue(): void;
+        recycleSelf(): void;
+    }
+}
+declare module es {
+    enum EaseType {
+        linear = 0,
+        sineIn = 1,
+        sineOut = 2,
+        sineInOut = 3,
+        quadIn = 4,
+        quadOut = 5,
+        quadInOut = 6,
+        quintIn = 7,
+        quintOut = 8,
+        quintInOut = 9,
+        cubicIn = 10,
+        cubicOut = 11,
+        cubicInOut = 12,
+        quartIn = 13,
+        quartOut = 14,
+        quartInOut = 15,
+        expoIn = 16,
+        expoOut = 17,
+        expoInOut = 18,
+        circleIn = 19,
+        circleOut = 20,
+        circleInOut = 21,
+        elasticIn = 22,
+        elasticOut = 23,
+        elasticInOut = 24,
+        punch = 25,
+        backIn = 26,
+        backOut = 27,
+        backInOut = 28,
+        bounceIn = 29,
+        bounceOut = 30,
+        bounceInOut = 31
+    }
+    class EaseHelper {
+        static oppositeEaseType(easeType: EaseType): EaseType.linear | EaseType.sineIn | EaseType.sineOut | EaseType.sineInOut | EaseType.quadIn | EaseType.quadOut | EaseType.quadInOut | EaseType.quintIn | EaseType.quintOut | EaseType.quintInOut | EaseType.cubicIn | EaseType.cubicOut | EaseType.cubicInOut | EaseType.quartIn | EaseType.quartInOut | EaseType.expoIn | EaseType.expoOut | EaseType.expoInOut | EaseType.circleIn | EaseType.circleOut | EaseType.circleInOut | EaseType.elasticIn | EaseType.elasticOut | EaseType.elasticInOut | EaseType.punch | EaseType.backIn | EaseType.backOut | EaseType.backInOut | EaseType.bounceIn | EaseType.bounceOut | EaseType.bounceInOut;
+        static ease(easeType: EaseType, t: number, duration: number): number;
+    }
+}
+declare module es {
+    class TweenManager extends GlobalManager {
+        static defaultEaseType: EaseType;
+        static removeAllTweensOnLevelLoad: boolean;
+        static cacheNumberTweens: boolean;
+        static cacheVector2Tweens: boolean;
+        static cacheRectTweens: boolean;
+        private _activeTweens;
+        private _tempTweens;
+        private _isUpdating;
+        private static _instance;
+        constructor();
+        update(): void;
+        static addTween(tween: ITweenable): void;
+        static removeTween(tween: ITweenable): void;
+        static stopAllTweens(bringToCompletion?: boolean): void;
+        static allTweensWithContext(context: any): ITweenable[];
+        static stopAllTweensWithContext(context: any, bringToCompletion?: boolean): void;
+        static allTweenWithTarget(target: any): ITweenable[];
+        static stopAllTweensWithTarget(target: any, bringToCompletion?: boolean): void;
+    }
+}
+declare module es {
+    module Easing {
+        class Linear {
+            static easeNone(t: number, d: number): number;
+        }
+        class Quadratic {
+            static easeIn(t: number, d: number): number;
+            static easeOut(t: number, d: number): number;
+            static easeInOut(t: number, d: number): number;
+        }
+        class Back {
+            static easeIn(t: number, d: number): number;
+            static easeOut(t: number, d: number): number;
+            static easeInOut(t: number, d: number): number;
+        }
+        class Bounce {
+            static easeOut(t: number, d: number): number;
+            static easeIn(t: number, d: number): number;
+            static easeInOut(t: number, d: number): number;
+        }
+        class Circular {
+            static easeIn(t: number, d: number): number;
+            static easeOut(t: number, d: number): number;
+            static easeInOut(t: number, d: number): number;
+        }
+        class Cubic {
+            static easeIn(t: number, d: number): number;
+            static easeOut(t: number, d: number): number;
+            static easeInOut(t: number, d: number): number;
+        }
+        class Elastic {
+            static easeIn(t: number, d: number): number;
+            static easeOut(t: number, d: number): number;
+            static easeInOut(t: number, d: number): number;
+            static punch(t: number, d: number): number;
+        }
+        class Exponential {
+            static easeIn(t: number, d: number): number;
+            static easeOut(t: number, d: number): number;
+            static easeInOut(t: number, d: number): number;
+        }
+        class Quartic {
+            static easeIn(t: number, d: number): number;
+            static easeOut(t: number, d: number): number;
+            static easeInOut(t: number, d: number): number;
+        }
+        class Quintic {
+            static easeIn(t: number, d: number): number;
+            static easeOut(t: number, d: number): number;
+            static easeInOut(t: number, d: number): number;
+        }
+        class Sinusoidal {
+            static easeIn(t: number, d: number): number;
+            static easeOut(t: number, d: number): number;
+            static easeInOut(t: number, d: number): number;
+        }
+    }
+}
+declare module es {
+    class Lerps {
+        static lerp(from: number, to: number, t: number): number;
+        static lerpVector2(from: Vector2, to: Vector2, t: number): Vector2;
+        static lerpRectangle(from: Rectangle, to: Rectangle, t: number): Rectangle;
+        static angleLerp(from: Vector2, to: Vector2, t: number): Vector2;
+        static ease(easeType: EaseType, from: number, to: number, t: number, duration: number): number;
+        static easeVector2(easeType: EaseType, from: Vector2, to: Vector2, t: number, duration: number): Vector2;
+        static easeRectangle(easeType: EaseType, from: Rectangle, to: Rectangle, t: number, duration: number): Rectangle;
+        static easeAngle(easeType: EaseType, from: Vector2, to: Vector2, t: number, duration: number): Vector2;
+        static fastSpring(currentValue: Vector2, targetValue: Vector2, velocity: Vector2, dampingRatio: number, angularFrequency: number): Vector2;
+    }
+}
+declare module es {
+    interface ITween<T> extends ITweenControl {
+        setEaseType(easeType: EaseType): ITween<T>;
+        setDelay(delay: number): ITween<T>;
+        setDuration(duration: number): ITween<T>;
+        setTimeScale(timeScale: number): ITween<T>;
+        setIsTimeScaleIndependent(): ITween<T>;
+        setCompletionHandler(completionHandler: (tween: ITween<T>) => void): ITween<T>;
+        setLoops(loopType: LoopType, loops: number, delayBetweenLoops: number): ITween<T>;
+        setFrom(from: T): ITween<T>;
+        prepareForReuse(from: T, to: T, duration: number): ITween<T>;
+        setRecycleTween(shouldRecycleTween: boolean): ITween<T>;
+        setIsRelative(): ITween<T>;
+        setContext(context: any): ITween<T>;
+        setNextTween(nextTween: ITweenable): ITween<T>;
+    }
+}
+declare module es {
+    interface ITweenControl extends ITweenable {
+        context: any;
+        jumpToElapsedTime(elapsedTime: number): any;
+        waitForCompletion(): any;
+        getTargetObject(): any;
+    }
+}
+declare module es {
+    interface ITweenTarget<T> {
+        setTweenedValue(value: T): any;
+        getTweenedValue(): T;
+        getTargetObject(): any;
+    }
+}
+declare module es {
+    interface ITweenable {
+        tick(): boolean;
+        recycleSelf(): any;
+        isRunning(): boolean;
+        start(): any;
+        pause(): any;
+        resume(): any;
+        stop(bringToCompletion: boolean): any;
+    }
+}