Animator

Definition

• Type: Class
• Namespace: UnityEngine
• Assembly: UnityEngine.AnimationModule
• Inherits from: Behaviour

public class Animator : Behaviour

Remarks

• Use Animator.SetFloat, Animator.SetInteger, Animator.SetBool, or Animator.SetTrigger, through AnimatorControllerParameter, to trigger an AnimatorController transition.
• Use Animator.Play, Animator.PlayInFixedTime, Animator.CrossFade, or Animator.CrossFadeInFixedTime to force the AnimatorController to a specific state.
• Use Animator.SetLayerWeight to modify the weight of an AnimatorControllerLayer.

• Use _updateMode to choose how the Animator updates.
• Use _cullingMode to select what the Animator updates when none of the associated Renderers are visible.
• Use Animator.Update to evaluate the Animator immediately. This is independent of the update mode.

• Automatically calculates the displacement of the Root joint for the frame.
• Adds this displacement to the position and rotation of the GameObject with the Animator Component. For information on how to override this behavior, consult Scripting Root Motion.

• First initialization of the Animator Component when loading a Scene or instantiating a

  Prefab

  .
• Changing the AnimatorController or AnimatorOverrideController in _runtimeAnimatorController.
• Making changes to an AnimatorOverrideController set in _runtimeAnimatorController.
• Making changes to a PlayableGraph connected to the Animator.
• Manually invoking Animator.Rebind.
• Enabling the GameObject to which the Animator Component is attached.

• The AnimatorController asset is already optimized to create a known set of bindings at Edit time. The Rebind operation, triggered by changes to _runtimeAnimatorController, only needs to bind the properties of the AnimationStream with scene objects. If you need to change the AnimationClips that the Animator evaluates during runtime, then switching to a new AnimatorController asset is the strategy which will incur the smallest Rebind cost. Note that this will reset the state of the state machine to the default state(s) of the new AnimatorController.
• Prioritize prebuilt AnimatorOverrideControllers over dynamically built ones. Use an Animator Override Controller asset to change clips at runtime without resetting the state of the state machine. If you use an Animator Override Controller built at Edit time, the Rebind operation has the same cost as changing an AnimatorController. If you dynamically build an AnimatorController at Runtime, the Rebind operation iterates over each clip in the AnimatorOverrideController because the bindings are unknown.
• PlayableGraphs execute a Rebind operation after every change to the graph, and large graphs have a significant Rebind cost. There are two optimization strategies you can apply: either maintain a small graph and update it as needed, or build a large graph and avoid changes as much as possible. Performance depends on the complexity of both your clips and your graph; experiment to determine which strategy is better suited for your use case.
• If you disable a GameObject for pooling purposes, the Animator performs the Rebind operation when the GameObject is activated again. This might cancel the performance gained by pooling. It is recommended that you disable the components on a GameObject instead of disabling the GameObject itself. When you disable an Animator, it pauses evaluation but keeps the internal state intact.
• When you add a new GameObject to a hierarchy associated with an Animator Component, you must manually invoke Animator.Rebind so that the Animator recognizes and is able to write to the new GameObject. If you add many new GameObjects, it is recommended that you add the GameObjects first and invoke Animator.Rebind once instead of invoking this method multiple times.

• The Rebind operation is resource intensive and might lead to CPU spikes. Use a single AnimatorController and avoid Rebind operations as much as possible. This generally results in more stable performance.
• When you use an AnimatorController, Unity evaluates each non-synchronized state machine at every frame. This includes layers set to a weight of zero. To improve performance, avoid unused AnimatorController layers.
• The Mecanim Animation System evaluates and updates Animator Components using parallel execution which divides the workload across multiple CPU cores. When you use Animator.Update to manually evaluate an Animator Component, Mecanim does not use parallel execution. To manually control the execution and benefit from parallel evaluation, bundle together multiple Animators in a PlayableGraph and manually update the PlayableGraph. This takes advantage of parallel execution while still maintaining manual control.
• Unity's Transform System only allows a single thread to write to a Transform hierarchy (a Root GameObject and its children) at a time. If you group multiple Animators under the same root GameObject, this prevents Mecanim from taking advantage of multi-threading when parallel updating Transforms and might result in reduced performance. It is recommended that you avoid grouping Animators in hierarchies of GameObjects, unless necessary for parenting reasons.
• StateMachineBehaviour introduces multiple synchronization points with the main thread. In some cases, callbacks can prevent parallel evaluation of multiple state machines. To avoid this issue, use StateMachineBehaviour sparingly.
• To maintain determinism, the Animator writes every animated property at every frame regardless of whether the property value has changed. This can cause known performance issues when animating RectTransform components. To avoid these issues, use the Animation Component to animate RectTransform.
• Since the AnimatorController is a state machine, it continuously evaluates whether transitions must be taken. This evaluation occurs even when the AnimatorController reaches the end of the current state. This means that an idle Animator consumes CPU. For single-shot animations, and for GameObjects that are rarely animated, use the Animation Component or the Playables API.
• The Humanoid system has a performance overhead. To avoid this overhead, use Generic animations wherever possible.@@@@`

Properties

Methods

T

T

T

T

GameObject

Static Methods

Inheritance

Operators