A simple, powerful and easy to use animation system for Unity. Focusing on the established solutions and frameworks of projects such as TweenLite, Tweener, and other tweening systems, iTween is a battle-tested solution for streamlining production in the Unity environment.

Credits and Thanks:

Developed by Bob Berkebile (pixelplacement.com). C# port by Patrick Corkum (insquare.com). Thanks to: Bully! Entertainment, Robert Penner, The Unity development team, the Tweener team, GreenSock, my Wife, my Son, my Parents (thanks for all the testing Dad!), all of the contributors on the unify community wiki and everyone I forgot to mention who's hard work ended up integrated into this project.

2.0 TEASER!!

INSTALLATION

The easiest part; download it and plop it in! iTween is a static class (you don't HAVE to know what that means), so just copy it ANYWHERE in your project structure and it's "installed" and ready to work.

HELLO WORLD: SIMPLE

iTween has a few key methods you can call to make the magic happen. Each of these "tools" accept parameters you can use to make an animation behave exactly the way you want. Let's move an object along the x-axis from it's current position to a new coordinate of 1.7 over the span of 2 seconds:

iTween.moveTo(gameObject,{"x":1.7, "time":2});

HELLO WORLD: COMPLEX

In adddition to single simple movements, iTweens can be chained together using the "delay" property. The only limitation is your imagination and your ability to remember how much the "delay" count should be.

private var go : GameObject;
private var cam : GameObject;

function Awake(){
	go = gameObject;
	cam = camera.main.gameObject;
}

function Start(){
	iTween.rotateFrom(go,{"y":90, "time":1.5, "transition":"easeInExpo"});
	iTween.moveFrom(go,{"y":3.5, "time":1.5, "transition":"easeInExpo"});
	iTween.colorTo(go,{"r":3, "g":.5, "b":1.2, "time":.3, "delay":1.5});
	iTween.shake(cam,{"y":.3, "time":.8, "delay":1.5});
	iTween.scaleTo(go,{"y":2, "time":2, "delay":2.3});
	iTween.rotateBy(go,{"x":.5, "delay":4.3});
	iTween.moveTo(go,{"y":1.2, "delay":4.6});
	iTween.moveTo(go,{"y":0, "delay":5.8, "transition":"easeInExpo"});
	iTween.shake(cam,{"y":.3, "time":.8, "delay":6.8});
	iTween.colorTo(go,{"r":.165, "g":.498, "b":.729, "time":.5, "delay":7.6});
	iTween.scaleTo(go,{"y":1, "delay":7.6});
}

BEZIER CURVES

In addition to the linear path movement of moveTo, moveFrom, moveBy, moveToWorld, moveFromWorld, and moveByWorld you can also move objects on curved paths using moveToBezier and moveToBezierWorld. Each Vector3 you add to the bezier argument adds another "control point" for the object to curve in and out of. You can add as many points as you want to the path. Special thanks to David Bardos for this functionality and Patrick for fixing things up (as always!).

By default objects will orient themselves to the path they are traveling on but you can turn it off by setting "orientToPath" to false. In addition you can also pass in a Vector3 for a "lookAt" argument for some cool effects (think dramatic camera movements!).

If you'd like the sample shown here (which shows a pretty advanced method for getting control points into moveToBezier) grab it here! (Note: The version of iTween in this project will not be updated as new versions are released!)

For example (I assure you it only "looks" complex):

function Start(){
	iTween.moveToBezier(gameObject,{"time":3, "transition":"easeInOutQuint", "bezier":[Vector3(0,1.5,0), Vector3(0,0,1.5), Vector3(0,-1.5,3), Vector3(1.5,0,3), Vector3(1.5,0,0), Vector3(-1.5,0,0)]});
}

CALLBACK FUNCTIONS

Nearly all of the methods in iTween allow the addition of an optional "onStart", "onUpdate" and "onComplete" argument. These arguments takes a string reference to an existing function in any script attached to the currently utilized GameObject. In addition, you can optionally provide "onStartParams", "onUpdateParams" and "onCompleteParams" arguments to allow the passing of an object to the destination "onStart", "onUpdate" or "onComplete" functions. You can also specify "onStartTarget", "onUpdateTarget" and "onCompleteTarget" to allow the firing of a function on a different GameObject.

To illustrate this functionality let's create a looping animation (Note: iTween includes a native loop feature called "loopType" built in which could have been set to "pingPong" to do this in 1 line of code but this example is merely to demonstrate the flexibility of utilizing callbacks):

private var tweenTarget : GameObject;
var counter : GUIText;
var count : int =0;

function Start(){
	tweenTarget=gameObject;
	roll("right");
	counter.guiText.material.color = Color.black;
}

private function roll(direction: String): void{
	switch(direction){
		case "right":
		iTween.rotateBy(tweenTarget,{"z":-.5});
		iTween.moveTo(tweenTarget,{"x":1.7, "onComplete":"roll", "onCompleteParams":"left"});
		count+=1;
		break;
		
		case "left":
		iTween.rotateBy(tweenTarget,{"z":1});
		iTween.moveTo(tweenTarget,{"x":-1.7, "onComplete":"roll", "onCompleteParams":"right"});
		count+=1;
		break;
	}
	
	counter.text=count.ToString() + " Loops";
}

SAMPLE GAME

A very quick and simple version of "Simon" powered by iTween (and thrown together in 3 hours). Sorry for the lack of comments and for the record I HATE this style of game... it always made me nervous. (Note: The version of iTween in this project will not be updated as new versions are released!)

Download it here!(Note: This was built with regular Unity and may need some adjustment to work on iPhone Unity)

OVERRIDING DEFAULTS

Each method in iTween has an accompanying set of default arguments to help alleviate coding repetition. You can augment each method's default arguments at any time to avoid duplicating tedious typing, make global animation changes, or just feel powerful.

The available defaults names are as follows:

rotateDefaults
stabDefaults
shakeDefaults
audioDefaults
scaleDefaults
fadeDefaults
moveDefaults
moveBezierDefaults
punchPositionDefaults
punchScaleDefaults
punchRotationDefaults
colorDefaults
lookToUpdateDefaults
moveToUpdateDefaults

Let's change the default transition for "moveDefaults" which effects every "moveTo" and "moveFrom" method:

//Change a default:
iTween.moveDefaults["transition"] = "easeInOutBack";

//Leverage new default (notice we don't specify the use of a transition):
iTween.moveTo(gameObject,{"x":1.7,"time":2});

CONTINUOUSLY CALLABLE METHODS

While nearly every method in iTween is meant to be called once and then finished, there are a few methods that are designed to be called continuously from Updates or similar repetative techniques.

For example, you can easily cause a camera to smoothly follow an object by using lookToUpdate:

var target : Transform;

function Update () {
	iTween.lookToUpdate(gameObject,{"target":target.position, "lookSpeed": 3});
}

VIDEO TUTORIALS

METHODS

Click on each method name to get more information.

iTween.audioFrom(GameObject, Hashtable)

The reverse of audioTo

iTween.audioTo(GameObject, Hashtable)

Base arguments: volume:float=0, pitch:float=1, delay:float=0, time:float=1, transition:string=linear
Callback arguments: onStart:string, onStartTarget:gameobject, onStartParams:string, onUpdate:string, onUpdateTarget:string, onUpdateTarget:gameobject, onComplete:string, onCompleteParams:object, onCompleteTarget:gameobject
Fades volume and or pitch of an AudioClip to the supplied target values.

iTween.colorFrom(GameObject, Hashtable)

The reverse of colorTo

iTween.colorTo(GameObject, Hashtable)

Base arguments: time:float=1, delay:float=0, includeChildren:boolean=true, transition:string=linear, loopType:string
Callback arguments: onStart:string, onStartTarget:gameobject, onStartParams:string, onUpdate:string, onUpdateTarget:string, onUpdateTarget:gameobject, onComplete:string, onCompleteParams:object, onCompleteTarget:gameobject
Coordinate arguments can be sent as individual properties: "r":float, "g":float, "b":float or as a Color: "color":Color
Possible loopTypes are "loop" and "pingPong"
Modifies the color values of the material or guiTexture to the supplies values.

iTween.fadeFrom(GameObject, Hashtable)

The reverse of fadeTo

iTween.fadeTo(GameObject, Hashtable)

Base arguments: alpha:float=0, time:float=1, delay:float=0, includeChildren:boolean=true, transition:string=linear, loopType:string
Callback arguments: onStart:string, onStartTarget:gameobject, onStartParams:string, onUpdate:string, onUpdateTarget:string, onUpdateTarget:gameobject, onComplete:string, onCompleteParams:object, onCompleteTarget:gameobject
Possible loopTypes are "loop" and "pingPong"
Fades the GameObject to the supplied alpha
Only works if the GameObject's material calculates transparency.

iTween.lookFrom(GameObject, Hashtable)

The reverse of lookTo

iTween.lookFromWorld(GameObject, Hashtable)

Helper function for lookFrom that calls a lookFrom with "isLocal" set to false.

iTween.lookTo(GameObject, Hashtable)

Helper function for rotateTo which simplifies the task of getting an object to animate a lookAt
Arguments in addition to rotateTo's: target:vector3, transform:Transform, axis:string
Callback arguments: onStart:string, onStartTarget:gameobject, onStartParams:string, onUpdate:string, onUpdateTarget:string, onUpdateTarget:gameobject, onComplete:string, onCompleteParams:object, onCompleteTarget:gameobject
The intended look direction can be set as "target":Vector3 or as "transform":Transform
If "transform" is passed as the look direction the supplied Transform's position will be utilized and is ideal for "live" or updated targets
Adding a value of "x", "y", or "z" to an "axis" argument will restrict the look operation to that axis

iTween.lookToUpdate(GameObject, Hashtable) - REPEAT CALLABLE

Base arguments: target:vector3, lookSpeed:float=3, axis:string, isLocal:boolean=true
Adding a value of "x", "y", or "z" to an "axis" argument will restrict the look operation to that axis
Intended to be called continuously from Update methods or similar situations
Will smoothly look towards a target based on lookSpeed (a lower number means slower speed)
Ideal for smoothed camera target following, enemies that aim at a character, and anywhere you need an object to look at a moving target or point

iTween.lookToUpdateWorld(GameObject, Hashtable) - REPEAT CALLABLE

Helper function for lookToUpdate that simply calls a lookToUpdate with "isLocal" set to false.

iTween.lookToWorld(GameObject, Hashtable)

Helper function for lookTo that calls a lookTo with "isLocal" set to false.

iTween.moveAdd(GameObject, Hashtable)

Same as moveBy.

iTween.moveAddWorld(GameObject, Hashtable)

Same as moveByWorld.

iTween.moveBy(GameObject, Hashtable)

Base arguments: time:float=1, delay:float=0, transition:String=easeInOutCubic, loopType:string, isLocal:boolean=true
Callback arguments: onStart:string, onStartTarget:gameobject, onStartParams:string, onUpdate:string, onUpdateTarget:string, onUpdateTarget:gameobject, onComplete:string, onCompleteParams:object, onCompleteTarget:gameobject
Coordinate arguments can be sent as individual properties: "x":float, "y":float, "z":float or as a Vector3: "amount":vector3
Automatically sets isKinematic to true if the gameObject contains a rigidbody and it is not true (returns value on completition) to avoid physics oddities
Possible loopTypes are "loop" and "pingPong"
Moves the GameObject by the supplied coordinate(s).

iTween.moveByWorld(GameObject, Hashtable)

Helper function for moveBy that simply calls a moveBy with "isLocal" set to false.

iTween.moveFrom(GameObject, Hashtable)

The reverse of moveTo

iTween.moveFromWorld(GameObject, Hashtable)

Helper function for moveFrom that simply calls a moveFrom with "isLocal" set to false.

iTween.moveTo(GameObject, Hashtable)

Base arguments: time:float=1, delay:float=0, transition:string=easeInOutCubic, lookAt:vector3, lookAtTransform:Transform, loopType:string, isLocal:boolean=true
Callback arguments: onStart:string, onStartTarget:gameobject, onStartParams:string, onUpdate:string, onUpdateTarget:string, onUpdateTarget:gameobject, onComplete:string, onCompleteParams:object, onCompleteTarget:gameobject
Coordinate arguments can be sent as individual properties: "x":float, "y":float, "z":float or as a Vector3: "position":vector3
Possible loopTypes are "loop" and "pingPong"
Automatically sets isKinematic to true if the gameObject contains a rigidbody and it is not true (returns value on completition) to avoid physics oddities
Moves the GameObject to the supplied coordinate(s).
lookAt allows you to set a Vector3 that the object will look towards as it moves and overrides orientToPath.
lookAtTransform allows you to set a Transform that the object will look towards as it moves and overrides orientToPath.

iTween.moveToBezier(GameObject, Hashtable)

Base arguments: axis:string, bezier:array, lookAt:Vector3, lookAtTransform:Transform, orientToPath:boolean=true, lookSpeed:float=8, time:float=1, delay:float=0, transition:String=easeInOutCubic, loopType:string
Callback arguments: onStart:string, onStartTarget:gameobject, onStartParams:string, onUpdate:string, onUpdateTarget:string, onUpdateTarget:gameobject, onComplete:string, onCompleteParams:object, onCompleteTarget:gameobject
Possible loopTypes are "loop" and "pingPong"
Adding an axis argument:string with either "x", "y", or "z" will lock lookTo and orientToPath to that axis
You can change the dafault lookSpeed to augment how fast the object turns as it moves (for lookAt and orientToPath)
Automatically sets isKinematic to true if the gameObject contains a rigidbody and it is not true (returns value on completition) to avoid physics oddities
Identical to other move methods except movement paths can be curved through an array of Vector3s
"bezier" argument should be structured as an array of Vector3 (i.e. "bezier":[Vector3(),Vector3(),Vector3(),etc...])
Each new "control point" in the bezier array will set a new point to curve into.
orientToPath causes the object to look in the direction it's moving.
lookAt allows you to set a Vector3 that the object will look towards as it moves and overrides orientToPath.
lookAtTransform allows you to set a Transform that the object will look towards as it moves and overrides orientToPath.

iTween.moveToBezierWorld(GameObject, Hashtable)

Helper function for moveToBezier that simply calls a moveToBezier with "isLocal" set to false.

iTween.moveToUpdate(GameObject, Hashtable) - REPEAT CALLABLE

Base arguments: time:float=.05
Coordinate arguments can be sent as individual properties: "x":float, "y":float, "z":float or as a Vector3: "position":Vector3
Intended to be called continuously from Update methods or similar situations
Will smoothly move object to supplied values over the time provided (lower number means faster speed)
Ideal for eased mouse followers, eased camera following and anywhere you need an object to slowly arrive at a "live" and possibly changing location

iTween.moveToUpdateWorld(GameObject, Hashtable) - REPEAT CALLABLE

Helper function for moveToUpdate that simply calls a moveToUpdate with "isLocal" set to false.

iTween.moveToWorld(GameObject, Hashtable)

Helper function for moveTo that simply calls a moveTo with "isLocal" set to false.

iTween.punchPosition(GameObject, Hashtable)

Base arguments: time:float=1, delay:float=0, isLocal:boolean=true
Callback arguments: onStart:string, onStartTarget:gameobject, onStartParams:string, onUpdate:string, onUpdateTarget:string, onUpdateTarget:gameobject, onComplete:string, onCompleteParams:object, onCompleteTarget:gameobject
Coordinate arguments can be sent as individual properties: "x":float, "y":float, "z":float or as a Vector3: "amount":vector3
Applies a jolt of force on the given axis and springs the GameObject back to its original position like a punching bag.
Automatically sets isKinematic to true if the gameObject contains a rigidbody and it is not true (returns value on completition) to avoid physics oddities
Negative/positive values dictate the direction of the initial impact.
Does not utilize a transition.

iTween.punchPositionWorld(GameObject, Hashtable)

Helper function for punchPosition that simply calls a punchPosition with "isLocal" set to false.

iTween.punchRotation(GameObject, Hashtable)

Base arguments: time:float=1, delay:float=0, isLocal:boolean=true
Callback arguments: onStart:string, onStartTarget:gameobject, onStartParams:string, onUpdate:string, onUpdateTarget:string, onUpdateTarget:gameobject, onComplete:string, onCompleteParams:object, onCompleteTarget:gameobject
Coordinate arguments can be sent as individual properties: "x":float, "y":float, "z":float or as a Vector3: "amount":vector3
Applies a jolt of rotation force on the given axis based on a percentage or multiplier of 360 degrees and springs the GameObject back to its original position like a punching bag.
Negative/positive values dictate the direction of the initial impact.
Automatically sets isKinematic to true if the gameObject contains a rigidbody and it is not true (returns value on completition) to avoid physics oddities
Does not work on GUIText, GUITexture and similar display objects that do not support rotation.
Does not utilize a transition.

iTween.punchRotationWorld(GameObject, Hashtable)

Helper function for punchRotation that simply calls a punchRotation with "isLocal" set to false.

iTween.punchScale(GameObject, Hashtable)

Base arguments: time:float=1, delay:float=0
Callback arguments: onStart:string, onStartTarget:gameobject, onStartParams:string, onUpdate:string, onUpdateTarget:string, onUpdateTarget:gameobject, onComplete:string, onCompleteParams:object, onCompleteTarget:gameobject
Coordinate arguments can be sent as individual properties: "x":float, "y":float, "z":float or as a Vector3: "amount":vector3
Applies a jolt of force on the given axis and springs the GameObject back to its original scale like a jello blob.
Automatically sets isKinematic to true if the gameObject contains a rigidbody and it is not true (returns value on completition) to avoid physics oddities
Negative/positive values dictate the direction of the initial impact.
Does not utilize a transition.

iTween.rotateAdd(GameObject, Hashtable)

Same as rotateAdd but it adds to the current values instead of multiplies.

iTween.rotateBy(GameObject, Hashtable)

Base arguments: time:float=1, delay:float=0, transition:String=easeInOutCubic, loopType:string, isLocal:boolean=true
Callback arguments: onStart:string, onStartTarget:gameobject, onStartParams:string, onUpdate:string, onUpdateTarget:string, onUpdateTarget:gameobject, onComplete:string, onCompleteParams:object, onCompleteTarget:gameobject
Coordinate arguments can be sent as individual properties: "x":float, "y":float, "z":float or as a Vector3: "amount":Vector3
Possible loopTypes are "loop" and "pingPong"
Automatically sets isKinematic to true if the gameObject contains a rigidbody and it is not true (returns value on completition) to avoid physics oddities
Rotates the GameObject 360 degrees times the supplied multiplier(s).
Negative/positive values dictate direction of rotation.
Does not work on GUIText, GUITexture and similar display objects that do not support rotation.

iTween.rotateByWorld(GameObject, Hashtable)

Helper function for rotateBy that simply calls a rotateBy with "isLocal" set to false.

iTween.rotateFrom(GameObject, Hashtable)

The reverse of rotateTo

iTween.rotateTo(GameObject, Hashtable)

Base arguments: time:float=1, delay:float=0, transition:String=easeInOutCubic, loopType:string, isLocal:boolean=true
Callback arguments: onStart:string, onStartTarget:gameobject, onStartParams:string, onUpdate:string, onUpdateTarget:string, onUpdateTarget:gameobject, onComplete:string, onCompleteParams:object, onCompleteTarget:gameobject
Coordinate arguments can be sent as individual properties: "x":float, "y":float, "z":float or as a Vector3: "rotation":Vector3
Possible loopTypes are "loop" and "pingPong"
Automatically sets isKinematic to true if the gameObject contains a rigidbody and it is not true (returns value on completition) to avoid physics oddities
Rotates the GameObject to the supplied degree(s).
Rotation direction is automatically decided based on shortest travel time.
Does not work on GUIText, GUITexture and similar display objects that do not support rotation.

iTween.scaleAdd(GameObject, Hashtable)

Same as scaleBy but it adds to the current values instead of multiplies.

iTween.scaleBy(GameObject, Hashtable)

Base arguments: time:float=1, delay:float=0, loopType:string=easeInOutCubic
Callback arguments: onStart:string, onStartTarget:gameobject, onStartParams:string, onUpdate:string, onUpdateTarget:string, onUpdateTarget:gameobject, onComplete:string, onCompleteParams:object, onCompleteTarget:gameobject
Coordinate arguments can be sent as individual properties: "x":float, "y":float, "z":float or as a Vector3: "amount":Vector3
Automatically sets isKinematic to true if the gameObject contains a rigidbody and it is not true (returns value on completition) to avoid physics oddities
Scales the GameObject by the supplied multiplier(s).
Possible loopTypes are "loop" and "pingPong"

iTween.scaleFrom(GameObject, Hashtable)

The reverse of scaleTo

iTween.scaleTo(GameObject, Hashtable)

Base arguments: time:float=1, delay:float=0, loopType:string=easeInOutCubic
Callback arguments: onStart:string, onStartTarget:gameobject, onStartParams:string, onUpdate:string, onUpdateTarget:string, onUpdateTarget:gameobject, onComplete:string, onCompleteParams:object, onCompleteTarget:gameobject
Coordinate arguments can be sent as individual properties: "x":float, "y":float, "z":float or as a Vector3: "scale":Vector3
Possible loopTypes are "loop" and "pingPong"
Automatically sets isKinematic to true if the gameObject contains a rigidbody and it is not true (returns value on completition) to avoid physics oddities
Scales the GameObject to the supplied multiplier(s).

iTween.shake(GameObject, Hashtable)

Base arguments: time:float=1, delay:float=0, isLocal:boolean=true
Callback arguments: onStart:string, onStartTarget:gameobject, onStartParams:string, onUpdate:string, onUpdateTarget:string, onUpdateTarget:gameobject, onComplete:string, onCompleteParams:object, onCompleteTarget:gameobject
Coordinate arguments can be sent as individual properties: "x":float, "y":float, "z":float or as a Vector3: "amount":Vector3
Automatically sets isKinematic to true if the gameObject contains a rigidbody and it is not true (returns value on completition) to avoid physics oddities
Randomly shakes the GameObject on each supplied axis by the supplied magnitude.
Negative/positive values dictate direction of initial impact.
Application will gradually resolve and return object to its original coordinates.
Does not utilize a transition.

iTween.shakeWorld(GameObject, Hashtable)

Helper function for shake that simply calls a shake with "isLocal" set to false.

iTween.stab(GameObject, Hashtable)

Base arguments: delay:float=0, volume:float=1, pitch:float=1, clip:AudioClip, delay:float
Callback arguments: onStart:string, onStartTarget:gameobject, onStartParams:string, onComplete:string, onCompleteParams:object, onCompleteTarget:gameobject
Plays an AudioClip one time based on supplied volume and pitch.
"onComplete" functionality fires after audio has finished playing.
If an AudioSource component isn't attached to the GameObject one will be automatically added.
If no AudioClip is provided the default AudioSource's clip property will be used.

iTween.stop(GameObject)

Stops all iTweens on the supplied GameObject.

iTween.stopType(GameObject, String)

Stops all iTweens on the supplied GameObject of a particular method.
Supplied types are of the root name of the type (i.e. "move", "scale", "fade", etc...) minus the "To" or "From".

iTween.tweenCount()

Returns an int.
Returns the total number of iTweens on the supplied GameObject.

AVAILABLE EASING CURVES:

"linear"
"spring"
"bounce"
"easeInQuad"
"easeOutQuad"
"easeInOutQuad"
"easeInCubic"
"easeOutCubic"
"easeInOutCubic"
"easeInQuart"
"easeOutQuart"
"easeInOutQuart"
"easeInQuint"
"easeOutQuint"
"easeInOutQuint"
"easeInSine"
"easeOutSine"
"easeInOutSine"
"easeInExpo"
"easeOutExpo"
"easeInOutExpo"
"easeInCirc"
"easeOutCirc"
"easeInOutCirc"
"easeInBack"
"easeOutBack"
"easeInOutBack"

NEWS

JS 1.0.34

Fixed issue with alpha not being set correctly in color operations

JS 1.0.33

Fixed "null key" error from punchRotation

JS 1.0.32

Fade applications FINALLY fail gracefully on any children if includeChildren is run and the child doesn't have a renderer or is a null
Color applications FINALLY fail gracefully on any children if includeChildren is run and the child doesn't have a renderer or is a null

JS 1.0.31

Compressed code to reduce overhead and improve compile time
Corrected ALL previous "from" behaviours so that properties set immediatly and then animate after any delay
Added onUpdate, onUpdateParams, and onUpdateTarget callbacks to all methods that aren't instantanious (i.e. stab) to allow repeated function calls during the update of a tween
Color methods now effect lights as well
Move methods now accept "lookAt":Vector3 and/or "lookAtTransform":Transform to allow the camera to track a static or moving point
Move methods now take "axis":String and if a look is passed it will restrict the rotation to the supplied string
MoveToBezier now takes "lookAtTransform":Transform to allow the camera to track a moving point
Alphabetized and cleanup of the method docs

JS 1.0.30

Color applications were using fade's defaults
Fade applications now fail gracefully on any children if includeChildren is run and the child doesn't have a renderer
Color applications now fail gracefully on any children if includeChildren is run and the child doesn't have a renderer
Ripped out and rebuilt the fade routines
Ripped out and rebuilt the color routines
Fixed duration issues with shake
Fixed issues with punchPosition related to easing curve involvement
Added punchScale

JS 1.0.29

~~All delayed "froms" are now augment after the delay and not before~~
Gutted, rewrote and optimized the look methods
Added a "transform" argument to lookTo, lookFrom, lookToWorld, and lookFromWorld to allow the passing of a Transform which will target the Transform's position

JS 1.0.28

All "By" and "Add" move methods can now take "position" or "amount"
All "By" and "Add" rotate methods can now take "rotation" or "amount"
All "By" and "Add" scale methods can now take "scale" or "amount"
Every "By" and "Add" method now snapshots it's start position when it is run rather than when its initialized to avoid odd behaviours when delays ae utilized
Changed lookFrom to use startRotation not endRotation
Added moveAdd to enhance flexibility
Cleaned up and optimized all move methods to be more predictable and reliable (utilizing Translate for better local space movement)
Cleaned up and optimized all rotate methods to be more predictable and reliable (utilizing Rotete for better local space movement)
Cleaned up and optimized punchPosition and punchRotation to be more predictable and reliable (utilizing Translate for better local space movement)
Cleaned up and optimized all scale methods to be more predictable and reliable
Added lookToUpdateWorld and corrected world usage for lookToUpdate
Corrected issue with bezier move and orientToPath failing if the object was a child
Bezier move now uses lookToUpdateWorld regardless of situation (I "think" this is the correct solution)
Added moveToUpdateWorld
Added axis argument to bezier move to allow locking of look application to single axis
Bezier move lookAt now uses lookToUpdateWorld
Added lookToWorld
MoveBy and MoveAdd are now identical in operation
Added shakeWorld
Shake methods not correctly resolve magnitude to 0
Consolidated rotateToDefaults and rotateByDefaults into rotateDefault

JS 1.0.27

Added "axis":string property to restrict look operations to a single axis for lookToUpdate, lookTo, and lookFrom

JS 1.0.26

Added lookTo and lookFrom

JS 1.0.25

Fixed inconsistent line endings warning
Swapped look control method in bezier for orientToPath and lookAt over to utilize new lookToUpdate method to keep things consistent

JS 1.0.24

Re-added moveByWorld - oops, sorry Patrick!
Fixed rotational values for rotateBy and rotateAdd
Added moveToUpdate as the second continuously callable method in the iTween arsenal!

JS 1.0.23

Added lookToUpdate which is the first of a few methods of iTween that can be called continuously from Update functions and similar situations
lookToUpdate will smoothly look at something and is perfect for camera controls

JS 1.0.22

If object contains a Rigidbody it's isKinematic property will be set to true and returned to what it was at the end of the tween
Setting a tweened object's isKinematic property true helps avoid certain physics simulation issues

JS 1.0.21

Fixed minor casting issues that crept up on the iPhone side of things.

JS 1.0.20

Smoothed out orientToPath controls for bezier movements

JS 1.0.19

Fixed some slight issues with local and world space with bezier movements
moveToBezier (only using local) with orientToPath doesn't work for correct lookAt on contained objects (objects that have a parent) - ANY SUGGESTIONS?
Deleted moveByWorld since it wasn't logical (if this is in error, let me know)
moveFrom wasn't calculating correctly between local and world space - does now
Fixed pingPong loop failures throughout
Added rotateAdd
Fixed pingPong loops on bezier movements
Added loopType to scaleBy, scaleAdd, rotateBy, rotateAdd

JS 1.0.18

Added "includeChildren" property to fadeTo, fadeFrom, colorTo, and colorFrom to toggle automatic child animations
"includeChildren" is true by default and it allows you to augment every child in a GameObject with one iTween call - subtle but insanely useful
Added colorTo and colorFrom to the documentation

JS 1.0.17

To add even more flexibility I decided to add some native data types as properties as well!
Added "position":Vector3 to moveTo, moveToWorld, moveFrom, moveFromWorld
Added "amount":Vector3 to moveBy, moveByWorld
Added "color":Color to colorTo, colorFrom
Added "scale":Vector3 to scaleTo, scaleFrom
Added "amount":Vector3 to scaleBy, scaleAdd
Added "rotation":Vector3 to rotateTo, rotateFrom
Added "amount":Vector3 to rotateBy
Added "position":Vector3 to punchPosition
Added "rotation":Vector3 to punchRotation
Added "amount":Vector3 to shake

JS 1.0.16

Fixed the warnings in the editor caused by .15

JS 1.0.15

Corrected stop and stopType which now causes warnings to appear like crazy but just ignore them for now, everything works fine.

JS 1.0.14

Changed punchPosition and shake to use localPosition instead of worldPosition
Fixed shake's callback routine
Added "loopType" argument for most methods (check the documentation for which ones now have it) with the ability to set it as "loop" or "pingPong" (there's issues with the moveToBezier and moveToBezierWorld that I "may" get to)

JS 1.0.13

Added "orientToPath" and "lookAt" to moveToBezier and moveToBezierWorld - examples and tweaks to come.

JS 1.0.12

Added scaleAdd to be able to easily add to a current object's scale

JS 1.0.11

Fixed a "NullReferenceException" with scaleBy - thanks Marek!
Corrected scaleBy to use a multiplier of the current scale and not an addition.

JS 1.0.10

Added moveToBezier and moveToBezierWorld to be able to move object on curved paths! Thanks to David Bardos!!!!!!

JS 1.0.9

Added "onCompleteTarget" to be allow a different gameObject to receive the "onComplete" function call.

JS 1.0.8

Fixed a "NullReferenceException" error in moveBy
Added moveByWorld, moveToWorld and moveFromWorld for movement functionality in world space

JS 1.0.7

Changed every move command to use localPosition instead of position - Thanks David.

JS 1.0.6

Fixed the issues that the addition of "moveBy" and "scaleBy" caused on the iPhone.

C# 1.0.2

Fixed a few small issues found by Cynicalized with shake.

C# 1.0.1

Added "moveBy" and "scaleBy".
Fixed an issue with stab not firing an onComplete on time if the pitch was not 1.

March 22, 2010

iTween C# is released on the world! - Thanks Patrick!

JS 1.0.5

Added "moveBy" and "scaleBy".
Fixed an issue with stab not firing an onComplete on time if the pitch was not 1.
Switched every method over to switch/case loops to improve performance.

JS 1.0.4

Fixed a "key duplication" error in colorTo.
colorTo was using fadeDefaults not colorDefaults
rotateTo was using rotateTo defaults not rotateByDefaults

March 22, 2010

Fixed a typo on the "Hello World: Simple" example where I forgot the "i" before "iTween" - thanks Tali!

March 25, 2010

Added a "getting started" video walkthrough. (also avail on Vimeo and YouTube)

JS 1.0.3

Patrick found that audioFrom was incorrectly relying on stab's defaults rather than it's own.

JS 1.0.2

A few bugs have crept up in the iPhone side of things with type casting, fixing them now and I'll get a new version up ASAP!
iPhone issues have been corrected.

JS 1.0.1

iTween documentation is complete (a truly amazing feat considering this is my first HTML/CSS work in over 3 years!). Sure could use a CMS to update this!

March 22, 2010

iTween Javascript is released on the world!

PLANS

cameraFadeTo(color?)
cameraFadeFrom(color?)
pause
pauseType
pauseAll
resume
resumeType
resumeAll
stop - add includeChildren boolean (false by default)
stopType - add includeChildren boolean (false by default)
stopAll - kill every iTween everywhere
moveToChain
moveFromChain
moveFromBezier
propertyTo
propertyFrom
numberTo(format boolean to include commas)

CONTACT, PRAISE, BUG REPORTS, MONEY?

info(at)pixelplacement.com - I wasn't cool enough to be able to pull off an email form :(

If you find iTween useful... buy us a 6-pack!