The object that dispatches a "tick" event each time the engine updates, making it easy for you to add your own listener(s) to run custom logic after each update (great for game developers). Add as many listeners as you want. The basic syntax is the same for all versions (AS2, AS3, and JavaScript):

Basic example (AS2, AS3, and JavaScript):

 //add listener
 TweenMax.ticker.addEventListener("tick", myFunction);
 
 function myFunction(event) {
     //executes on every tick after the core engine updates
 }
 
 //to remove the listener later...
 TweenMax.ticker.removeEventListener("tick", myFunction);
         

Due to differences in the core languages (and to maximize efficiency), the advanced syntax is slightly different for the AS3 version compared to AS2 and JavaScript. The parameters beyond the first 2 in the addEventListener() method are outlined below:

JavaScript and AS2

addEventListener(type, callback, scope, useParam, priority)

Parameters:

1. type : String - type of listener, should always be "tick"
2. callback : Function - the function to call when the event occurs
3. scope : Object - binds the scope to a particular object (scope is basically what "this" refers to in your function). This can be very useful in JavaScript and AS2 because scope isn't generally maintained.
4. useParam : Boolean - if true, an event object will be generated and fed to the callback each time the event occurs. The event is a generic object and has two properties: type (always "tick") and target which refers to the ticker instance. The default for useParam is false because it improves performance.
5. priority : Integer - influences the order in which the listeners are called. Listeners with lower priorities are called after ones with higher priorities.

Advanced example (JavaScript and AS2):

 //add listener that requests an event object parameter, binds scope to the current scope (this), and sets priority to 1 so that it is called before any other listeners that had a priority lower than 1...
 TweenMax.ticker.addEventListener("tick", myFunction, this, true, 1);
 
 function myFunction(event) {
     //executes on every tick after the core engine updates
 }
 
 //to remove the listener later...
 TweenMax.ticker.removeEventListener("tick", myFunction);
         

AS3

The AS3 version uses the standard EventDispatcher.addEventListener() syntax which basically allows you to define a priority and whether or not to use weak references (see Adobe's docs for details).

Advanced example [AS3 only]:

 import flash.events.Event;
 
 //add listener with weak reference (standard syntax - notice the 5th parameter is true)
 TweenMax.ticker.addEventListener("tick", myFunction, false, 0, true);
 
 function myFunction(event:Event):void {
     //executes on every tick after the core engine updates
 }
 
 //to remove the listener later...
 TweenMax.ticker.removeEventListener("tick", myFunction);
         

Constructor

Provides a simple way to call a function after a set amount of time (or frames). You can optionally pass any number of parameters to the function too.

JavaScript and AS2 note: - Due to the way JavaScript and AS2 don't maintain scope (what "this" refers to, or the context) in function calls, it can be useful to define the scope specifically. Therefore, the JavaScript and AS2 versions accept a 4th parameter to [optionally] define the scope, but it is omitted in AS3:

TweenMax.delayedCall(delay, callback, params, scope, useFrames) [JavaScript and AS2 only]

//calls myFunction after 1 second and passes 2 parameters:
TweenMax.delayedCall(1, myFunction, ["param1", 2]);
         
function myFunction(param1, param2) {
    //do stuff
}

Parameters

Static method for creating a TweenMax instance that tweens backwards - you define the BEGINNING values and the current values are used as the destination values which is great for doing things like animating objects onto the screen because you can set them up initially the way you want them to look at the end of the tween and then animate in from elsewhere.

NOTE: By default, immediateRender is true in from() tweens, meaning that they immediately render their starting state regardless of any delay that is specified. You can override this behavior by passing immediateRender:false in the vars parameter so that it will wait to render until the tween actually begins (often the desired behavior when inserting into TimelineLite or TimelineMax instances). To illustrate the default behavior, the following code will immediately set the alpha of mc to 0 and then wait 2 seconds before tweening the alpha back to 1 over the course of 1.5 seconds:

TweenMax.from(mc, 1.5, {alpha:0, delay:2});

Since the target parameter can also be an array of objects, the following code will tween the alpha property of mc1, mc2, and mc3 from a value of 0 simultaneously:

TweenMax.from([mc1, mc2, mc3], 1.5, {alpha:0});

Even though 3 objects are animating, there is still only one tween that is created. In order to stagger or offset the start times of each object animating, please see the staggerFrom() method (TimelineLite has one too).

For simple sequencing, you can use the delay special property (like TweenMax.from(mc, 1, {alpha:0, delay:0.5})), but it is highly recommended that you consider using TimelineLite (or TimelineMax) for all but the simplest sequencing tasks. It has an identical from() method that allows you to append tweens one-after-the-other and then control the entire sequence as a whole. You can even have the tweens overlap as much as you want.

Parameters

See also

Static method for creating a TweenMax instance that allows you to define both the starting and ending values (as opposed to to() and from() tweens which are based on the target's current values at one end or the other).

NOTE: Only put starting values in the fromVars parameter - all special properties for the tween (like onComplete, onUpdate, delay, etc.) belong in the toVars parameter.

Since the target parameter can also be an array of objects, the following code will tween the x property of mc1, mc2, and mc3 from 0 to 100 simultaneously:

TweenMax.fromTo([mc1, mc2, mc3], 1, {x:0}, {x:100});

Even though 3 objects are animating, there is still only one tween created. In order to stagger or offset the start times of each object animating, please see the staggerFromTo() method (TimelineLite has one too).

For simple sequencing, you can use the delay special property (like TweenMax.fromTo(mc, 1, {x:0}, {x:100, delay:0.5})), but it is highly recommended that you consider using TimelineLite (or TimelineMax) for all but the simplest sequencing tasks. It has an identical fromTo() method that allows you to append tweens one-after-the-other and then control the entire sequence as a whole. You can even have the tweens overlap as much as you want.

Parameters

See also

Returns an array containing all tweens (and optionally timelines too, excluding the root timelines). If your goal is to affect all of the tweens/timelines/delayedCalls (like to pause() them or reverse() or alter their timeScale), you might want to consider using the static TimelineLite.exportRoot() method instead because it provides a single instance that you can use to control everything.

Parameters

See also

Returns an array containing all the tweens of a particular target (or group of targets) that have not been released for garbage collection yet which typically happens within a few seconds after the tween completes. For example, TweenMax.getTweensOf(myObject) returns an array of all tweens of myObject, even tweens that haven't begun yet. TweenMax.getTweensOf([myObject1, myObject2]); will return a condensed array of the tweens of myObject1 plus all the tweens of myObject2 combined into one array with duplicates removed.

Since the method only finds tweens that haven't been released for garbage collection, if you create a tween and then let it finish and then a while later try to find it with getTweensOf(), it may not be found because it was released by the engine for garbage collection. Remember, one of the best parts of GSAP is that it saves you from the headache of managing gc. Otherwise, you'd need to manually dispose each tween you create, making things much more cumbersome.

         TweenMax.to(myObject1, 1, {x:100});
         TweenMax.to(myObject2, 1, {x:100});
         TweenMax.to([myObject1, myObject2], 1, {alpha:0});
         
         var a1 = TweenMax.getTweensOf(myObject1); //finds 2 tweens
         var a2 = TweenMax.getTweensOf([myObject1, myObject2]); //finds 3 tweens
         

Parameters

Clears any initialization data (like starting/ending values in tweens) which can be useful if, for example, you want to restart a tween without reverting to any previously recorded starting values. When you invalidate() an animation, it will be re-initialized the next time it renders and its vars object will be re-parsed. The timing of the animation (duration, startTime, delay) will not be affected.

Another example would be if you have a TweenMax(mc, 1, {x:100, y:100}) that ran when mc.x and mc.y were initially at 0, but now mc.x and mc.y are 200 and you want them tween to 100 again, you could simply invalidate() the tween and restart() it. Without invalidating first, restarting it would cause the values jump back to 0 immediately (where they started when the tween originally began). When you invalidate a TimelineLite/TimelineMax, it automatically invalidates all of its children.

Reports whether or not a particular object is actively tweening. If a tween is paused, is completed, or hasn't started yet, it isn't considered active.

Parameters

Kills all tweens and/or delayedCalls/callbacks, and/or timelines, optionally forcing them to completion first. The various parameters provide a way to specify exactly which types you want to kill

//kill everything
TweenMax.killAll();

//kill only tweens, but not delayedCalls or timelines
TweenMax.killAll(false, true, false, false);

//kill only delayedCalls
TweenMax.killAll(false, false, true, false);

Parameters

Kills all tweens of the children of a particular DOM element, optionally forcing them to completion first. For example, if you have the following HTML:

<div id="d1">
    <div id="d2">
        <img src="photo.jpg" id="image" />
    </div>
</div>
<div id="d3"></div>

TweenMax.to( document.getElementById("d2"), 1, {css:{left:100}});
TweenMax.to( document.getElementById("image"), 1, {css:{left:100}});
TweenMax.to( document.getElementById("d3"), 1, {css:{left:100}});

//only kills the first 2 tweens because those targets are child elements of the "d1" DOM element. 
TweenMax.killChildTweensOf( document.getElementById("d1") ); 

Parameters

Immediately kills all of the delayedCalls to a particular function. If, for example, you want to kill all delayedCalls to myFunction, you'd do this:

TweenMax.killDelayedCallsTo(myFunction);

Since a delayedCall is just a tween that uses the function/callback as both its target and its onComplete, TweenMax.killTweensOf(myFunction) produces exactly the same result as TweenMax.killDelayedCallsTo(myFunction).

This method affects all delayedCalls that were created using TweenLite.delayedCall() or TweenMax.delayedCall() or the call() or addCallback() methods of TimelineLite or TimelineMax. Basically, any tween whose target is the function you supply will be killed.

Parameters

Kills all the tweens (or specific tweening properties) of a particular object or the delayedCalls to a particular function. If, for example, you want to kill all tweens of myObject, you'd do this:

TweenMax.killTweensOf(myObject);

To kill only particular tweening properties of the object, use the second parameter. For example, if you only want to kill all the tweens of myObject.alpha and myObject.x, you'd do this:

TweenMax.killTweensOf(myObject, {alpha:true, x:true});

To kill all the delayedCalls (like ones created using TweenMax.delayedCall(5, myFunction);), you can simply call TweenMax.killTweensOf(myFunction); because delayedCalls are simply tweens that have their target and onComplete set to the same function (as well as a delay of course).

killTweensOf() affects tweens that haven't begun yet too. If, for example, a tween of myObject has a delay of 5 seconds and TweenLite.killTweensOf(mc) is called 2 seconds after the tween was created, it will still be killed even though it hasn't started yet.

Parameters

[deprecated] Pauses all tweens and/or delayedCalls/callbacks and/or timelines. This literally changes the paused state of all affected tweens/delayedCalls/timelines, but a more flexible way to globally control things is to use the TimelineLite.exportRoot() method which essentially wraps all of the tweens/timelines/delayedCalls on the root timeline into a TimelineLite instance so that you can pause(), resume(), or even reverse() or alter the timeScale without affecting animations that you create after the export. This also avoids having to alter the paused state of every individual tween/delayedCall/timeline - controlling the TimelineLite that contains the exported animations delivers the same effect visually, but does so in a more elegant and flexible way.

Parameters

See also

Gets or sets the tween's progress which is a value between 0 and 1 indicating the position of the virtual playhead (excluding repeats) where 0 is at the beginning, 0.5 is halfway complete, and 1 is complete. If the tween has a non-zero repeat defined, progress and totalProgress will be different because progress doesn't include any repeats or repeatDelays whereas totalProgress does. For example, if a TweenMax instance is set to repeat once, at the end of the first cycle totalProgress would only be 0.5 whereas progress would be 1. If you watched both properties over the course of the entire animation, you'd see progress go from 0 to 1 twice (once for each cycle) in the same time it takes the totalProgress to go from 0 to 1 once.

This method serves as both a getter and setter. Omitting the parameter returns the current value (getter), whereas defining the parameter sets the value (setter) and returns the instance itself for easier chaining, like myTween.progress(0.5).play();

var progress = myTween.progress(); //gets current progress
myTween.progress( 0.25 ); //sets progress to one quarter finished

Parameters

See also

Gets or sets the number of times that the tween should repeat after its first iteration. For example, if repeat is 1, the tween will play a total of twice (the initial play plus 1 repeat). To repeat indefinitely, use -1. repeat should always be an integer.

To cause the repeats to alternate between forward and backward, set yoyo to true. To add a time gap between repeats, use repeatDelay. You can set the initial repeat value via the vars parameter, like:

TweenMax.to(mc, 1, {x:100, repeat:2});

This method serves as both a getter and setter. Omitting the parameter returns the current value (getter), whereas defining the parameter sets the value (setter) and returns the instance itself for easier chaining, like myTween.repeat(2).yoyo(true).play();

var repeat = myTween.repeat(); //gets current repeat value
myTween.repeat(2); //sets repeat to 2

Parameters

See also

Gets or sets the amount of time in seconds (or frames for frames-based tweens) between repeats. For example, if repeat is 2 and repeatDelay is 1, the tween will play initially, then wait for 1 second before it repeats, then play again, then wait 1 second again before doing its final repeat. You can set the initial repeatDelay value via the vars parameter, like:

TweenMax.to(mc, 1, {x:100, repeat:2, repeatDelay:1});

This method serves as both a getter and setter. Omitting the parameter returns the current value (getter), whereas defining the parameter sets the value (setter) and returns the instance itself for easier chaining, like myTween.repeat(2).yoyo(true).repeatDelay(0.5).play();

var repeatDelay = myTween.repeatDelay(); //gets current repeatDelay value
myTween.repeatDelay(2); //sets repeatDelay to 2

Parameters

See also

[deprecated] Resumes all paused tweens and/or delayedCalls/callbacks and/or timelines. This literally changes the paused state of all affected tweens/delayedCalls/timelines, but a more flexible way to globally control things is to use the TimelineLite.exportRoot() method which essentially wraps all of the tweens/timelines/delayedCalls on the root timeline into a TimelineLite instance so that you can pause(), resume(), or even reverse() or alter the timeScale without affecting animations that you create after the export. This also avoids having to alter the paused state of every individual tween/delayedCall/timeline - controlling the TimelineLite that contains the exported animations delivers the same effect visually, but does so in a more elegant and flexible way.

Parameters

See also

Immediately sets properties of the target accordingly - essentially a zero-duration to() tween with a more intuitive name. So the following lines produce identical results:

TweenMax.set(myObject, {x:100, y:50, alpha:0});
TweenMax.to(myObject, 0, {x:100, y:50, alpha:0});

And of course you can use an array to set the properties of multiple targets at the same time, like:

TweenMax.set([obj1, obj2, obj3], {x:100, y:50, alpha:0});
         

Parameters

Tweens an array of targets from a common set of destination values (using the current values as the destination), but staggers their start times by a specified amount of time, creating an evenly-spaced sequence with a surprisingly small amount of code. For example, let's say you have an array containing references to a bunch of text fields that you'd like to drop into place while fading in, all in a staggered fashion with 0.2 seconds between each tween's start time:

var textFields = [tf1, tf2, tf3, tf4, tf5];
TweenMax.staggerFrom(textFields, 1, {y:"+150"}, 0.2);

staggerFrom() simply loops through the targets array and creates a from() tween for each object and then returns an array containing all of the resulting tweens (one for each object).

If you can afford the slight increase in file size, it is usually better to use TimelineLite's staggerFrom() method because it wraps the tweens in a TimelineLite instead of an array which makes controlling the group as a whole much easier. That way you could pause(), resume(), reverse(), restart() or change the timeScale of everything at once.

Note that if you define an onComplete (or any callback for that matter) in the vars parameter, it will be called for each tween rather than the whole sequence. This can be very useful, but if you want to call a function after the entire sequence of tweens has completed, use the onCompleteAll parameter (the 5th parameter).

By default, immediateRender is true in from() tweens, meaning that they immediately render their starting state regardless of any delay that is specified. You can override this behavior by passing immediateRender:false in the vars parameter so that it will wait to render until the tween actually begins.

JavaScript and AS2 note: - Due to the way JavaScript and AS2 don't maintain scope (what "this" refers to, or the context) in function calls, it can be useful to define the scope specifically. Therefore, in the JavaScript and AS2 versions accept a 7th parameter for onCompleteAllScope, but that parameter is omitted in the AS3 version.

Parameters

See also

Tweens an array of targets from and to a common set of values, but staggers their start times by a specified amount of time, creating an evenly-spaced sequence with a surprisingly small amount of code. For example, let's say you have an array containing references to a bunch of text fields that you'd like to fade from alpha:1 to alpha:0 in a staggered fashion with 0.2 seconds between each tween's start time:

var textFields = [tf1, tf2, tf3, tf4, tf5];
TweenMax.staggerFromTo(textFields, 1, {alpha:1}, {alpha:0}, 0.2);

staggerFromTo() simply loops through the targets array and creates a fromTo() tween for each object and then returns an array containing all of the resulting tweens (one for each object).

If you can afford the slight increase in file size, it is usually better to use TimelineLite's staggerFromTo() method because it wraps the tweens in a TimelineLite instead of an array which makes controlling the group as a whole much easier. That way you could pause(), resume(), reverse(), restart() or change the timeScale of everything at once.

Note that if you define an onComplete (or any callback for that matter) in the vars parameter, it will be called for each tween rather than the whole sequence. This can be very useful, but if you want to call a function after the entire sequence of tweens has completed, use the onCompleteAll parameter (the 6th parameter).

JavaScript and AS2 note: - Due to the way JavaScript and AS2 don't maintain scope (what "this" refers to, or the context) in function calls, it can be useful to define the scope specifically. Therefore, in the JavaScript and AS2 versions accept an 8th parameter for onCompleteAllScope, but that parameter is omitted in the AS3 version.

Parameters

See also

Tweens an array of targets to a common set of destination values, but staggers their start times by a specified amount of time, creating an evenly-spaced sequence with a surprisingly small amount of code. For example, let's say you have an array containing references to a bunch of text fields that you'd like to fall away and fade out in a staggered fashion with 0.2 seconds between each tween's start time:

var textFields = [tf1, tf2, tf3, tf4, tf5];
TweenMax.staggerTo(textFields, 1, {y:"+150", ease:CubicIn.ease}, 0.2);

staggerTo() simply loops through the targets array and creates a to() tween for each object and then returns an array containing all of the resulting tweens (one for each object).

If you can afford the slight increase in file size, it is usually better to use TimelineLite's staggerTo() method because it wraps the tweens in a TimelineLite instead of an array which makes controlling the group as a whole much easier. That way you could pause(), resume(), reverse(), restart() or change the timeScale of everything at once.

Note that if you define an onComplete (or any callback for that matter) in the vars parameter, it will be called for each tween rather than the whole sequence. This can be very useful, but if you want to call a function after the entire sequence of tweens has completed, use the onCompleteAll parameter (the 5th parameter).

JavaScript and AS2 note: - Due to the way JavaScript and AS2 don't maintain scope (what "this" refers to, or the context) in function calls, it can be useful to define the scope specifically. Therefore, in the JavaScript and AS2 versions accept a 7th parameter for onCompleteAllScope, but that parameter is omitted in the AS3 version.

Parameters

See also

Gets or sets the local position of the playhead (essentially the current time), not including any repeats or repeatDelays. If the tween has a non-zero repeat, its time goes back to zero upon repeating even though the totalTime continues forward linearly (or if yoyo is true, the time alternates between moving forward and backward). time never exceeds the duration whereas the totalTime reflects the overall time including any repeats and repeatDelays.

For example, if a TweenMax instance has a duration of 2 and a repeat of 3, totalTime will go from 0 to 8 during the course of the tween (plays once then repeats 3 times, making 4 total cycles) whereas time would go from 0 to 2 a total of 4 times.

This method serves as both a getter and setter. Omitting the parameter returns the current value (getter), whereas defining the parameter sets the value (setter) and returns the instance itself for easier chaining.

var currentTime = myTween.time(); //gets current time
myTween.time(2); //sets time, jumping to new value just like seek().

Parameters

See also

Static method for creating a TweenMax instance that animates to the specified destination values (from the current values). This static method can be more intuitive for some developers and shields them from potential garbage collection issues that could arise when assigning a tween instance to a persistent variable. The following lines of code produce identical results:

TweenMax.to(mc, 1, {x:100});
var myTween = new TweenMax(mc, 1, {x:100});
var myTween = TweenMax.to(mc, 1, {x:100});

Each line above will tween the "x" property of the mc object to a value of 100 over the coarse of 1 second. They each use a slightly different syntax, all of which are valid. If you don't need to store a reference of the tween, just use the static TweenMax.to( ) call.

Since the target parameter can also be an array of objects, the following code will tween the x property of mc1, mc2, and mc3 to a value of 100 simultaneously:

TweenMax.to([mc1, mc2, mc3], 1, {x:100});

Even though 3 objects are animating, there is still only one tween created. In order to stagger or offset the start times of each object animating, please see the staggerTo() method (TimelineLite has one too).

For simple sequencing, you can use the delay special property (like TweenMax.to(mc, 1, {x:100, delay:0.5})), but it is highly recommended that you consider using TimelineLite (or TimelineMax) for all but the simplest sequencing tasks. It has an identical to() method that allows you to append tweens one-after-the-other and then control the entire sequence as a whole. You can even have the tweens overlap as much as you want.

Parameters

See also

Gets or sets the total duration of the tween in seconds (or frames for frames-based tweens) including any repeats or repeatDelays. duration, by contrast, does NOT include repeats and repeatDelays. For example, if the tween has a duration of 10, a repeat of 1 and a repeatDelay of 2, the totalDuration would be 22.

This method serves as both a getter and setter. Omitting the parameter returns the current value (getter), whereas defining the parameter sets the value (setter) and returns the instance itself for easier chaining.

var total = myTween.totalDuration(); //gets total duration
myTween.totalDuration(10); //sets the total duration

Parameters

See also

Gets or sets the tween's totalProgress which is a value between 0 and 1 indicating the position of the virtual playhead (including repeats) where 0 is at the beginning, 0.5 is halfway complete, and 1 is complete. If the tween has a non-zero repeat defined, progress and totalProgress will be different because progress doesn't include any repeats or repeatDelays whereas totalProgress does. For example, if a TweenMax instance is set to repeat once, at the end of the first cycle totalProgress would only be 0.5 whereas progress would be 1. If you watched both properties over the course of the entire animation, you'd see progress go from 0 to 1 twice (once for each cycle) in the same time it takes the totalProgress to go from 0 to 1 once.

This method serves as both a getter and setter. Omitting the parameter returns the current value (getter), whereas defining the parameter sets the value (setter) and returns the instance itself for easier chaining, like myTween.totalProgress(0.5).play();

var progress = myTween.totalProgress(); //gets total progress
myTween.totalProgress( 0.25 ); //sets total progress to one quarter finished

Parameters

See also

Updates tweening values on the fly so that they appear to seamlessly change course even if the tween is in-progress. Think of it like dynamically updating the vars object that was passed in to the tween when it was originally created. You do NOT need to redefine all of the vars properties/values - only the ones that you want to update. You can even define new properties that you didn't define in the original vars object.

If the resetDuration parameter is true and the tween has already started (or finished), updateTo() will restart the tween. Otherwise, the tween's timing will be honored. And if resetDuration is false and the tween is in-progress, the starting values of each property will be adjusted so that the tween appears to seamlessly redirect to the new destination values. This is typically not advisable if you plan to reverse the tween later on or jump to a previous point because the starting values would have been adjusted.

updateTo() is only meant for non-plugin values. It's much more complicated to dynamically update values that are being handled inside plugins - that is not what this method is intended to do.

Note: If you plan to constantly update values, please look into using the DynamicPropsPlugin.

//create the tween
var tween:TweenMax = new TweenMax(mc, 2, {x:100, y:200, alpha:0.5});

//then later, update the destination x and y values, restarting the tween
tween.updateTo({x:300, y:0}, true);

//or to update the values mid-tween without restarting, do this:
tween.updateTo({x:300, y:0}, false);

Parameters

Gets or sets the tween's yoyo state, where true causes the tween to go back and forth, alternating backward and forward on each repeat. yoyo works in conjunction with repeat, where repeat controls how many times the tween repeats, and yoyo controls whether or not each repeat alternates direction. So in order to make a tween yoyo, you must set its repeat to a non-zero value. Yoyo-ing, has no affect on the tween's "reversed" property. For example, if repeat is 2 and yoyo is false, it will look like: start - 1 - 2 - 3 - 1 - 2 - 3 - 1 - 2 - 3 - end. But if yoyo is true, it will look like: start - 1 - 2 - 3 - 3 - 2 - 1 - 1 - 2 - 3 - end.

You can set the yoyo property initially by passing yoyo:true in the vars parameter, like: TweenMax.to(mc, 1, {x:100, repeat:1, yoyo:true});

This method serves as both a getter and setter. Omitting the parameter returns the current value (getter), whereas defining the parameter sets the value (setter) and returns the instance itself for easier chaining, like myAnimation.yoyo(true).repeat(3).timeScale(2).play(0.5);

var yoyo = myAnimation.yoyo(); //gets current yoyo state
myAnimation.yoyo( true ); //sets yoyo to true

Parameters

See also