The import settings for Humanoid animations has a toggle to flip the animation from left to right.

The Playables API exposes standard IK features which Mecanim and Animancer can utilise, but not Legacy.

Mecanim has a Target Matching system which essentially manages the application of Inverse Kinematics over time.

1. Import an AnimationClip into the Unity Editor.
2. Export it in an Asset Bundle.
3. At runtime you can load the bundle then load the animation from it.
4. • For Legacy, you can call Animation.AddClip then play it.
   • For Mecanim, you need to use an Animator Override Controller.
   • For Animancer, you can simply play it exactly the same as any other animation.

Mecanim requires that all possible animation states be defined upfront in the Unity Editor as part of an Animator Controller asset and imposes severe limitations on your ability to control things at runtime.

Legacy was primarily designed around assigning the animations you want to an array in the Inspector, but it does allow scripts to add more animations dynamically at runtime.

Legacy and Mecanim are designed around assigning animations upfront so that scripts need to use Magic Strings to refer to them by name.

Mecanim allows you to configure details like play speed and transition duration when setting up the Animator Controller and gives you live previews so you can see what everything will look like without entering Play Mode.

Legacy requires you to specify those details in your scripts.

If a parameter in an Animator Controller has the same name as a curve in any of the animations it's playing, Mecanim will automatically update that parameter every frame with the value of the curve at the current animation time. If it's blending between multiple animations with the same curve, the value of the parameter will also be blended between them.

Animancer Pro includes the full source code so that you can look through it, debug problems, and make any necessary modifications without being dependant on the author for help.

The Animancer.Lite.dll files in the Pro package are empty dummies to ensure seamless upgrades from Lite to Pro. They contain no code and are not included in builds.

Mecanim encourages you to configure parameter based transitions using the Animator window which then can't be changed at runtime. It gives you no real control over individual animation weights. It does allow you to control speed and time indirectly by creating a parameter to control them then modifying that parameter, however in the case of time this means that you need to manually update the parameter every frame to keep playing (you can't simply set the time when you want to change it and let it play normally the rest of the time).

When you command an Animator Controller (such as changing its state), it will not actually respond until the next time it gets updated and it might not even do what you want. For example, if you call Play then check which state is currently playing it will still return the previous state until the next frame and if you call Play again during the same frame it will ignore each call after the first instead of ending up in the last state you told it to play.

// Currently Playing Idle.
animator.Play("Jump");
// Still playing Idle. Will only be playing Jump next frame.
animator.Play("Attack");
// Will still play Jump next frame. Not going to play Attack at all.

The other systems will respond to commands immediately and can properly handle multiple commands in the same frame.

// Currently Playing Idle.
animancer.Play("Jump");
// Now Playing Jump.
animancer.Play("Attack");
// Now Playing Attack.

When configuring a transition in Mecanim or Animancer, you can adjust its timing independantly of the actual end of the animation to tweak the result as you see fit.

Mecanim only allows scripts to access the details of the current state or the next state being transitioned towards.

All systems support blending between animations over time, known as Cross Fading.

Imagine you want to repeatedly perform an action consisting of a single animation with a smooth transition from the end of one action to the start of the next.

Most systems only allow each state to have one set of values; it can either be near the end and fading out or near the start and fading in, but not both. Attempting to do so will cause it to either snap back to the start without a smooth transition or ignore you completely, depending on the system.

Animancer has FadeMode.FromStart which checks if the animation state is still in use and will simply create another state for the same animation if necessary. This allows the new state to fade in from the start while the previous state continues fading out. You could potentially do the same thing with the other systems, but it'sn't built in and Mecanim in particular would require significantly more effort because it doesn't allow states to be created dynamically at runtime.

Layers allow you to manage multiple animations at the same time, generally on different body parts.

Blend Trees allow you to interpolate between multiple animations based on a parameter. For example, you might blend between idle, walk, and run based on how fast you want to move so that you can have your character animate appropriately for any speed based on how far the user tilts a joystick instead of only having a few specific speeds you can move at.

Animancer's Mixer States can automatically Synchronize the normalized times of their animations so that the related parts of each one are playing at the same time to give a much more realistic blended result. For example, when blending between Walk and Run animations you would want them to both put the character's right foot down at the same time so that the resulting pose is a blend of Walk (with right foot down) and Run (with right foot down) rather than blending different parts of each animation.

Synchronization can be disabled for any or all states. For example, you might want to synchronize Walk and Run animations but not an Idle animation because its time doesn't correspond to the same cycle as the others. The Optional Synchronization section explains it in more detail.

Simply synchronizing the normalized time of a group of animations as mentioned above gives good results when the animations are similar such as with regular Walk and Run animations. But that simple approach doesn't work so well for irregular animations such as trying to synchronize a regular Walk animation with a Walk-With-Limp where the character spends more time on one foot than the other.

Blend Trees solve this using a technique called Foot Phase Synchronization which usually gives much better results than simple time synchronization. This feature is always on for Blend Trees and can't be turned off. Unfortunately, Unity doesn't expose the data necessary to perform Foot Phase Synchronization at runtime so Animancer's Mixer States aren't able to use it. Using Controller States to play an Animator Controller with a Blend Tree will allow its Foot Phase Synchronization to work normally though.

Traditional animations generally remain fixed in place and rely on other systems to move characters around such as Rigidbodies or Character Controllers. For example, a walk animation would move the character's arms and legs naturally, but the character itself would remain in place as if walking on a treadmil.

Animator Controllers can be used to manage the gameplay state of an object as part of its animation state.

Animancer isn't tied to a specific state machine implementation, but it does include a general purpose Finite State Machine system in the Animancer.FSM namespace which is entirely separate from the animation system and is flexible enough for most needs. They work well together, but you can very easily modify it or use any other system you prefer.

Mecanim provides a Graphical User Interface for configuring animation states, transitions, and other details in the Unity Editor instead of allowing those details to be controlled using scripts like the other systems. One of the main advantages of this visual interface is the ability to preview the transitions between animations in Edit Mode.

The full structure of an Animator Controller must be defined in the Unity Editor and cannot be changed at runtime

Mecanim allows Animator Controllers to be synchronised across a network using the Network Animator component (though that system is now deprecated).