From Unify Community Wiki
Revision as of 17:20, 1 July 2008 by Adrian (Talk | contribs)

(diff) ← Older revision | Latest revision (diff) | Newer revision → (diff)
Jump to: navigation, search

Author: Adrian



Complex animations are best done using Unity's animation system and bones. But there are times when you just need to move a block or during rapid prototyping when you don't want to bother a 3d application. Unity provides some functions for those cases like Lerp, Repeat, PingPong etc. They are fine and can be very powerful using coroutines. However, inspired by TweenLite library from Flash I wanted a simpler approach that would allow me to dispatch an animation and not needing to bother futher while also making my code a bit simpler.


  • Animate any field/property that supports +/-/* mathematical operations.
  • Apply easing to animation to create more pleasing transitions.
  • Chain / delay animations.
  • Animate rigidbodies (internally using FixedUpdate and Rigidbody.MovePosition / MoveRotation)
  • Animate rotation (internally using SLerp)


Quick Introduction

Animations are created with To and From. Both methods take three arguments:

  1. The object you want to animate properties on (this for current object)
  2. The duration of the animation in seconds
  3. A Hash containing the properties to be animated as keys plus the target as value. The Hash can also contain AniMate options.

For example, to move a game object to another position: <javascript>Ani.Mate.To(gameObject.transform, 2, {"position": new Vector3(0,20,0)});</javascript> It's also possible to animate multiple properties with one call: <javascript>Ani.Mate.To(gameObject.transform, 2, {"position": new Vector3(0,20,0), "localScale": new Vector3(2,2,2)});</javascript>


AniMate is available from any script using Ani.Mate. It provides following methods:


  • To(object :Object, duration :float, properties/options :Hashtable) :WaitForSeconds(duration)
  • To(object :Object, duration :float, properties :Hashtable, options :Hashtable) :WaitForSeconds(duration)

Create an animation from the current value to the given value.

<javascript>Ani.Mate.To(transform, 3, {"position": new Vector3(10,0,0)});</javascript>


  • From(object :Object, duration :float, properties/options :Hashtable) :WaitForSeconds(duration)
  • From(object :Object, duration :float, properties :Hashtable, options :Hashtable) :WaitForSeconds(duration)

Create an animation from the given value to the current value.

<javascript>Ani.Mate.From(transform, 3, {"localScale": new Vector3(0,0,0)});</javascript>


  • Stop(object :Object, name :string)

Stop animations on an object for a given field/proeprty.

<javascript>Ani.Mate.Stop(transform, "position");</javascript>


  • StopAll(object :Object)

Stop all animations on a given object.



  • RigidbodyMover(rigidbody :Rigidbody) :callback

Method returning a callable/delegate that can be used as callback to move rigidbodies.

<javascript>Ani.Mate.To(transform, 3, {"position": new Vector3(10,0,0)}, "physics": true, "callback": Ani.Mate.RigidbodyMover(rigidbody)});</javascript>


  • RigidbodyRotator(rigidbody :Rigidbody) :callback

Method returning a callable/delegate that can be used as callback to rotate rigidbodies.

<javascript>Ani.Mate.To(transform, 3, {"rotation": Quaternion.Euler(0,0,180)}, "physics": true, "callback": Ani.Mate.RigidbodyRotator(rigidbody)});</javascript>


The hash that is given to To and From can contain some special options. Options can also be passed to those methods as seperate hash for applying the same options to multiple animations or to avoid name conflicts.


  • {"easing": SimpleEasing or ComplexEasing class}

Easing allows to apply easing to an animation. LinearEasing is the default and means that the change will be constant over the whole animation. Different easings can be chosen to make the animation start fast and the slow down on approach it's target. See Easing Classes for what different kinds of easing are available.

Easing Direction

  • {"direction: EasingType.In / EasingType.Out / EasingType.InOut}

Easing also has a direction that's either In, Out or InOut. In generally means the animation starts fast and then slows down, Out means the animation starts slow and and ends fast and InOut is the combination of both.


  • {"delay: true / false}

If you don't want an animation to start immediately, you can delay the animation with this option.


  • {"physics: true / false}

Usually animations are processed in the Update() loop. Setting physics to true will instead process the animation in the FixedUpdate() function. This is necessary if you want to animate a rigidbody that interacts with physics.


  • {"callback: callback, callable or delegate}

Setting the callback option to a function (callable, delegate or what you want to call it) will not directly apply the animated value to the object but instead pass it to the callback function. This can be used together with RigidbodyMover and RigidbodyRotator to pass the position/rotation of a rigidbody through MovePosition() and MovePosition() to improve interaction of the rigidbody with other objects.

Easing Classes

AniMate bundles following easing classes. You can roll your own by extending the SimpleEasing or ComplexEasing interfaces.


  • LinearEasing
  • QuadraticEasing
  • CubicEasing
  • QuarticEasing
  • QuinticEasing
  • SinusoidalEasing
  • ExponentialEasing
  • CircularEasing


  • SlerpEasing

You can see a demonstration of those easing functions here: [1]

Special Cases

Animating Rigidbodies

Animating Rotation

Personal tools