starling-framework

import EventDispatcher from "../events/EventDispatcher"; import IAnimatable from "./IAnimatable"; declare namespace starling.animation { /** * A Tween animates numeric properties of objects. It uses different transition functions * * to give the animations various styles. * * * * The primary use of this class is to do standard animations like movement, fading, * * rotation, etc. But there are no limits on what to animate; as long as the property you want * * to animate is numeric (<code>int, uint, Number</code>), the tween can handle it. For a list * * of available Transition types, look at the "Transitions" class. * * * * Here is an example of a tween that moves an object to the right, rotates it, and * * fades it out: * * * * <listing> * * var tween:Tween = new Tween(object, 2.0, Transitions.EASE_IN_OUT); * * tween.animate("x", object.x + 50); * * tween.animate("rotation", deg2rad(45)); * * tween.fadeTo(0); // equivalent to 'animate("alpha", 0)' * * Starling.juggler.add(tween);</listing> * * * * Note that the object is added to a juggler at the end of this sample. That's because a * * tween will only be executed if its "advanceTime" method is executed regularly - the * * juggler will do that for you, and will remove the tween when it is finished. * * * * @see Juggler * * @see Transitions * */ export class Tween extends EventDispatcher implements IAnimatable { /** * Creates a tween with a target, duration (in seconds) and a transition function. * * @param target the object that you want to animate * * @param time the duration of the Tween (in seconds) * * @param transition can be either a String (e.g. one of the constants defined in the * * Transitions class) or a function. Look up the 'Transitions' class for a * * documentation about the required function signature. */ constructor(target: any, time: number, transition?: any); /** * Resets the tween to its default values. Useful for pooling tweens. */ reset(target: any, time: number, transition?: any): Tween; /** * Animates the property of the target to a certain value. You can call this method * * multiple times on one tween. * * * * Some property types are handled in a special way: * * <ul> * * <li>If the property contains the string <code>color</code> or <code>Color</code>, * * it will be treated as an unsigned integer with a color value * * (e.g. <code>0xff0000</code> for red). Each color channel will be animated * * individually.</li> * * <li>The same happens if you append the string <code>#rgb</code> to the name.</li> * * <li>If you append <code>#rad</code>, the property is treated as an angle in radians, * * making sure it always uses the shortest possible arc for the rotation.</li> * * <li>The string <code>#deg</code> does the same for angles in degrees.</li> * * </ul> * */ animate(property: string, endValue: number): void; /** * Animates the 'scaleX' and 'scaleY' properties of an object simultaneously. */ scaleTo(factor: number): void; /** * Animates the 'x' and 'y' properties of an object simultaneously. */ moveTo(x: number, y: number): void; /** * Animates the 'alpha' property of an object to a certain target value. */ fadeTo(alpha: number): void; /** * Animates the 'rotation' property of an object to a certain target value, using the * * smallest possible arc. 'type' may be either 'rad' or 'deg', depending on the unit of * * measurement. */ rotateTo(angle: number, type?: string): void; /** * @inheritDoc */ advanceTime(time: number): void; /** * The end value a certain property is animated to. Throws an ArgumentError if the * * property is not being animated. */ getEndValue(property: string): number; /** * Indicates if a property with the given name is being animated by this tween. */ animatesProperty(property: string): boolean; /** * Indicates if the tween is finished. */ get isComplete(): boolean; /** * The target object that is animated. */ get target(): any; /** * The transition method used for the animation. @see Transitions */ get transition(): string; set transition(value: string) /** * The actual transition function used for the animation. */ get transitionFunc(): (arg0: number) => number; set transitionFunc(value: (arg0: number) => number) /** * The total time the tween will take per repetition (in seconds). */ get totalTime(): number; /** * The time that has passed since the tween was created (in seconds). */ get currentTime(): number; /** * The current progress between 0 and 1, as calculated by the transition function. */ get progress(): number; /** * The delay before the tween is started (in seconds). @default 0 */ get delay(): number; set delay(value: number) /** * The number of times the tween will be executed. * * Set to '0' to tween indefinitely. @default 1 */ get repeatCount(): number; set repeatCount(value: number) /** * The amount of time to wait between repeat cycles (in seconds). @default 0 */ get repeatDelay(): number; set repeatDelay(value: number) /** * Indicates if the tween should be reversed when it is repeating. If enabled, * * every second repetition will be reversed. @default false */ get reverse(): boolean; set reverse(value: boolean) /** * Indicates if the numeric values should be cast to Integers. @default false */ get roundToInt(): boolean; set roundToInt(value: boolean) /** * A function that will be called when the tween starts (after a possible delay). */ get onStart(): Function; set onStart(value: Function) /** * A function that will be called each time the tween is advanced. */ get onUpdate(): Function; set onUpdate(value: Function) /** * A function that will be called each time the tween finishes one repetition * * (except the last, which will trigger 'onComplete'). */ get onRepeat(): Function; set onRepeat(value: Function) /** * A function that will be called when the tween is complete. */ get onComplete(): Function; set onComplete(value: Function) /** * The arguments that will be passed to the 'onStart' function. */ get onStartArgs(): Array<any>; set onStartArgs(value: Array<any>) /** * The arguments that will be passed to the 'onUpdate' function. */ get onUpdateArgs(): Array<any>; set onUpdateArgs(value: Array<any>) /** * The arguments that will be passed to the 'onRepeat' function. */ get onRepeatArgs(): Array<any>; set onRepeatArgs(value: Array<any>) /** * The arguments that will be passed to the 'onComplete' function. */ get onCompleteArgs(): Array<any>; set onCompleteArgs(value: Array<any>) /** * Another tween that will be started (i.e. added to the same juggler) as soon as * * this tween is completed. */ get nextTween(): Tween; set nextTween(value: Tween) } } export default starling.animation.Tween;