AnimationMixer
Inherited by: AnimationPlayer, AnimationTree
Base class for AnimationPlayer and AnimationTree.
Description
Section titled “Description”Base class for AnimationPlayer and AnimationTree to manage animation lists. It also has general properties and methods for playback and blending.
After instantiating the playback information data within the extended class, the blending is processed by the AnimationMixer.
Properties
Section titled “Properties”Methods
Section titled “Methods”| Returns | Method |
|---|---|
| Variant | _post_process_key_value(animation, track, value, object_id, object_sub_idx) |
| Error | add_animation_library(name, library) |
| void | advance(delta) |
| void | capture(name, duration, trans_type, ease_type) |
| void | clear_caches() |
| StringName | find_animation(animation) |
| StringName | find_animation_library(animation) |
| Animation | get_animation(name) |
| AnimationLibrary | get_animation_library(name) |
[]StringName | get_animation_library_list() |
[]String | get_animation_list() |
| Vector3 | get_root_motion_position() |
| Vector3 | get_root_motion_position_accumulator() |
| Quaternion | get_root_motion_rotation() |
| Quaternion | get_root_motion_rotation_accumulator() |
| Vector3 | get_root_motion_scale() |
| Vector3 | get_root_motion_scale_accumulator() |
| bool | has_animation(name) |
| bool | has_animation_library(name) |
| void | remove_animation_library(name) |
| void | rename_animation_library(name, newname) |
Signals
Section titled “Signals”animation_finished
Section titled “animation_finished”animation_finished(anim_name: StringName)Notifies when an animation finished playing.
Note: This signal is not emitted if an animation is looping.
animation_libraries_updated
Section titled “animation_libraries_updated”animation_libraries_updated()Notifies when the animation libraries have changed.
animation_list_changed
Section titled “animation_list_changed”animation_list_changed()Notifies when an animation list is changed.
animation_started
Section titled “animation_started”animation_started(anim_name: StringName)Notifies when an animation starts playing.
Note: This signal is not emitted if an animation is looping.
caches_cleared
Section titled “caches_cleared”caches_cleared()Notifies when the caches have been cleared, either automatically, or manually via clear_caches().
mixer_applied
Section titled “mixer_applied”mixer_applied()Notifies when the blending result related have been applied to the target objects.
mixer_updated
Section titled “mixer_updated”mixer_updated()Notifies when the property related process have been updated.
Enumerations and constants
Section titled “Enumerations and constants”enum AnimationCallbackModeProcess
Section titled “enum AnimationCallbackModeProcess”- ANIMATION_CALLBACK_MODE_PROCESS_PHYSICS =
0— Process animation during physics frames (seeActor.NOTIFICATION_INTERNAL_PHYSICS_PROCESS). This is especially useful when animating physics bodies.
- ANIMATION_CALLBACK_MODE_PROCESS_IDLE =
1— Process animation during process frames (seeActor.NOTIFICATION_INTERNAL_PROCESS).
- ANIMATION_CALLBACK_MODE_PROCESS_MANUAL =
2— Do not process animation. Useadvance()to process the animation manually.
enum AnimationCallbackModeMethod
Section titled “enum AnimationCallbackModeMethod”- ANIMATION_CALLBACK_MODE_METHOD_DEFERRED =
0— Batch method calls during the animation process, then do the calls after events are processed. This avoids bugs involving deleting actors or modifying the AnimationPlayer while playing.
- ANIMATION_CALLBACK_MODE_METHOD_IMMEDIATE =
1— Make method calls immediately when reached in the animation.
enum AnimationCallbackModeDiscrete
Section titled “enum AnimationCallbackModeDiscrete”- ANIMATION_CALLBACK_MODE_DISCRETE_DOMINANT =
0— AnAnimation.UPDATE_DISCRETEtrack value takes precedence when blendingAnimation.UPDATE_CONTINUOUSorAnimation.UPDATE_CAPTUREtrack values andAnimation.UPDATE_DISCRETEtrack values.
- ANIMATION_CALLBACK_MODE_DISCRETE_RECESSIVE =
1— AnAnimation.UPDATE_CONTINUOUSorAnimation.UPDATE_CAPTUREtrack value takes precedence when blending theAnimation.UPDATE_CONTINUOUSorAnimation.UPDATE_CAPTUREtrack values and theAnimation.UPDATE_DISCRETEtrack values. This is the default behavior for AnimationPlayer.
- ANIMATION_CALLBACK_MODE_DISCRETE_FORCE_CONTINUOUS =
2— Always treat theAnimation.UPDATE_DISCRETEtrack value asAnimation.UPDATE_CONTINUOUSwithAnimation.INTERPOLATION_NEAREST. This is the default behavior for AnimationTree. If a value track has un-interpolatable type key values, it is internally converted to useANIMATION_CALLBACK_MODE_DISCRETE_RECESSIVEwithAnimation.UPDATE_DISCRETE. Un-interpolatable type list: -@GlobalScope.TYPE_NIL-@GlobalScope.TYPE_NODE_PATH-@GlobalScope.TYPE_RID-@GlobalScope.TYPE_OBJECT-@GlobalScope.TYPE_CALLABLE-@GlobalScope.TYPE_SIGNAL-@GlobalScope.TYPE_DICTIONARY-@GlobalScope.TYPE_PACKED_BYTE_ARRAY@GlobalScope.TYPE_BOOLand@GlobalScope.TYPE_INTare treated as@GlobalScope.TYPE_FLOATduring blending and rounded when the result is retrieved. It is same for arrays and vectors with them such as@GlobalScope.TYPE_PACKED_INT32_ARRAYor@GlobalScope.TYPE_VECTOR2I, they are treated as@GlobalScope.TYPE_PACKED_FLOAT32_ARRAYor@GlobalScope.TYPE_VECTOR2. Also note that for arrays, the size is also interpolated.@GlobalScope.TYPE_STRINGand@GlobalScope.TYPE_STRING_NAMEare interpolated between character codes and lengths, but note that there is a difference in algorithm between interpolation between keys and interpolation by blending.
Property descriptions
Section titled “Property descriptions”active
Section titled “active”bool active = true
Setter/getter: set_active(), is_active()
If true, the AnimationMixer will be processing.
audio_max_polyphony
Section titled “audio_max_polyphony”int audio_max_polyphony = 32
Setter/getter: set_audio_max_polyphony(), get_audio_max_polyphony()
The number of possible simultaneous sounds for each of the assigned AudioStreamPlayers.
For example, if this value is 32 and the animation has two audio tracks, the two AudioStreamPlayers assigned can play simultaneously up to 32 voices each.
callback_mode_discrete
Section titled “callback_mode_discrete”AnimationMixer.AnimationCallbackModeDiscrete callback_mode_discrete = 1
Setter/getter: set_callback_mode_discrete(), get_callback_mode_discrete()
Ordinarily, tracks can be set to Animation.UPDATE_DISCRETE to update infrequently, usually when using nearest interpolation.
However, when blending with Animation.UPDATE_CONTINUOUS several results are considered. The callback_mode_discrete specify it explicitly. See also AnimationCallbackModeDiscrete.
To make the blended results look good, it is recommended to set this to ANIMATION_CALLBACK_MODE_DISCRETE_FORCE_CONTINUOUS to update every frame during blending. Other values exist for compatibility and they are fine if there is no blending, but not so, may produce artifacts.
callback_mode_method
Section titled “callback_mode_method”AnimationMixer.AnimationCallbackModeMethod callback_mode_method = 0
Setter/getter: set_callback_mode_method(), get_callback_mode_method()
The call mode used for “Call Method” tracks.
callback_mode_process
Section titled “callback_mode_process”AnimationMixer.AnimationCallbackModeProcess callback_mode_process = 1
Setter/getter: set_callback_mode_process(), get_callback_mode_process()
The process notification in which to update animations.
deterministic
Section titled “deterministic”bool deterministic = false
Setter/getter: set_deterministic(), is_deterministic()
If true, the blending uses the deterministic algorithm. The total weight is not normalized and the result is accumulated with an initial value (0 or a "RESET" animation if present).
This means that if the total amount of blending is 0.0, the result is equal to the "RESET" animation.
If the number of tracks between the blended animations is different, the animation with the missing track is treated as if it had the initial value.
If false, The blend does not use the deterministic algorithm. The total weight is normalized and always 1.0. If the number of tracks between the blended animations is different, nothing is done about the animation that is missing a track.
Note: In AnimationTree, the blending with AnimationNodeAdd2, AnimationNodeAdd3, AnimationNodeSub2 or the weight greater than 1.0 may produce unexpected results.
For example, if AnimationNodeAdd2 blends two actors with the amount 1.0, then total weight is 2.0 but it will be normalized to make the total amount 1.0 and the result will be equal to AnimationNodeBlend2 with the amount 0.5.
reset_on_save
Section titled “reset_on_save”bool reset_on_save = true
Setter/getter: set_reset_on_save_enabled(), is_reset_on_save_enabled()
This is used by the editor. If set to true, the scene will be saved with the effects of the reset animation (the animation with the key "RESET") applied as if it had been seeked to time 0, with the editor keeping the values that the scene had before saving.
This makes it more convenient to preview and edit animations in the editor, as changes to the scene will not be saved as long as they are set in the reset animation.
root_motion_local
Section titled “root_motion_local”bool root_motion_local = false
Setter/getter: set_root_motion_local(), is_root_motion_local()
If true, get_root_motion_position() value is extracted as a local translation value before blending. In other words, it is treated like the translation is done after the rotation.
root_motion_track
Section titled “root_motion_track”NodePath root_motion_track = NodePath("")
Setter/getter: set_root_motion_track(), get_root_motion_track()
The path to the Animation track used for root motion. Paths must be valid scene-tree paths to an actor, and must be specified starting from the parent actor of the actor that will reproduce the animation. The root_motion_track uses the same format as Animation.track_set_path(), but note that a bone must be specified.
If the track has type Animation.TYPE_POSITION_3D, Animation.TYPE_ROTATION_3D, or Animation.TYPE_SCALE_3D the transformation will be canceled visually, and the animation will appear to stay in place. See also get_root_motion_position(), get_root_motion_rotation(), get_root_motion_scale(), and RootMotionView.
root_node
Section titled “root_node”NodePath root_node = NodePath("..")
Setter/getter: set_root_node(), get_root_node()
The actor which node path references will travel from.
Method descriptions
Section titled “Method descriptions”_post_process_key_value
Section titled “_post_process_key_value”Variant _post_process_key_value(animation: Animation, track: int, value: Variant, object_id: int, object_sub_idx: int) virtual const
A virtual function for processing after getting a key during playback.
add_animation_library
Section titled “add_animation_library”Error add_animation_library(name: StringName, library: AnimationLibrary)
Adds library to the animation player, under the key name.
AnimationMixer has a global library by default with an empty string as key. For adding an animation to the global library:
use actor::AnimationPlayer as mixer : AnimationPlayer
fn add_to_global_library(animation_resource: Animation) { global_library : AnimationLibrary = mixer.get_animation_library("") global_library.add_animation("animation_name", animation_resource)}advance
Section titled “advance”void advance(delta: float)
Manually advance the animations by the specified time (in seconds).
capture
Section titled “capture”void capture(name: StringName, duration: float, trans_type: Tween.TransitionType = 0, ease_type: Tween.EaseType = 0)
If the animation track specified by name has an option Animation.UPDATE_CAPTURE, stores current values of the objects indicated by the track path as a cache. If there is already a captured cache, the old cache is discarded.
After this it will interpolate with current animation blending result during the playback process for the time specified by duration, working like a crossfade.
You can specify trans_type as the curve for the interpolation. For better results, it may be appropriate to specify Tween.TRANS_LINEAR for cases where the first key of the track begins with a non-zero value or where the key value does not change, and Tween.TRANS_QUAD for cases where the key value changes linearly.
clear_caches
Section titled “clear_caches”void clear_caches()
AnimationMixer caches animated actors. It may not notice if an actor disappears; clear_caches() forces it to update the cache again.
find_animation
Section titled “find_animation”StringName find_animation(animation: Animation) const
Returns the key of animation or an empty StringName if not found.
find_animation_library
Section titled “find_animation_library”StringName find_animation_library(animation: Animation) const
Returns the key for the AnimationLibrary that contains animation or an empty StringName if not found.
get_animation
Section titled “get_animation”Animation get_animation(name: StringName) const
Returns the Animation with the key name. If the animation does not exist, null is returned and an error is logged.
get_animation_library
Section titled “get_animation_library”AnimationLibrary get_animation_library(name: StringName) const
Returns the first AnimationLibrary with key name or null if not found.
To get the AnimationMixer’s global animation library, use get_animation_library("").
get_animation_library_list
Section titled “get_animation_library_list”[]StringName get_animation_library_list() const
Returns the list of stored library keys.
get_animation_list
Section titled “get_animation_list”[]String get_animation_list() const
Returns the list of stored animation keys.
get_root_motion_position
Section titled “get_root_motion_position”Vector3 get_root_motion_position() const
Retrieve the motion delta of position with the root_motion_track as a Vector3 that can be used elsewhere.
If root_motion_track is not a path to a track of type Animation.TYPE_POSITION_3D, returns Vector3(0, 0, 0).
See also root_motion_track and RootMotionView.
The most basic example is applying position to CharacterBody3D:
use actor::Player as root : CharacterBody3Duse actor::AnimationTree as animation_tree : AnimationTree
@onready state_machine : AnimationNodeStateMachinePlayback = animation_tree.get("parameters/playback") as AnimationNodeStateMachinePlaybackmut current_rotation : Quaternion = Quaternion.IDENTITY
fn _process(delta: float) { if Input.is_action_just_pressed("animate") { current_rotation = root.get_quaternion() state_machine.travel("Animate") } velocity : Vector3 = current_rotation * animation_tree.get_root_motion_position() / delta root.set_velocity(velocity) root.move_and_slide()}By using this in combination with get_root_motion_rotation_accumulator(), you can apply the root motion position more correctly to account for the rotation of the actor.
use actor::Player as root : CharacterBody3Duse actor::AnimationTree as animation_tree : AnimationTree
@onready state_machine : AnimationNodeStateMachinePlayback = animation_tree.get("parameters/playback") as AnimationNodeStateMachinePlayback
fn _process(delta: float) { if Input.is_action_just_pressed("animate") { state_machine.travel("Animate") } root.set_quaternion(root.get_quaternion() * animation_tree.get_root_motion_rotation()) velocity : Vector3 = (animation_tree.get_root_motion_rotation_accumulator().inverse() * root.get_quaternion()) * animation_tree.get_root_motion_position() / delta root.set_velocity(velocity) root.move_and_slide()}If root_motion_local is true, returns the pre-multiplied translation value with the inverted rotation.
In this case, the code can be written as follows:
use actor::Player as root : CharacterBody3Duse actor::AnimationTree as animation_tree : AnimationTree
@onready state_machine : AnimationNodeStateMachinePlayback = animation_tree.get("parameters/playback") as AnimationNodeStateMachinePlayback
fn _process(delta: float) { if Input.is_action_just_pressed("animate") { state_machine.travel("Animate") } root.set_quaternion(root.get_quaternion() * animation_tree.get_root_motion_rotation()) velocity : Vector3 = root.get_quaternion() * animation_tree.get_root_motion_position() / delta root.set_velocity(velocity) root.move_and_slide()}get_root_motion_position_accumulator
Section titled “get_root_motion_position_accumulator”Vector3 get_root_motion_position_accumulator() const
Retrieve the blended value of the position tracks with the root_motion_track as a Vector3 that can be used elsewhere.
This is useful in cases where you want to respect the initial key values of the animation.
For example, if an animation with only one key Vector3(0, 0, 0) is played in the previous frame and then an animation with only one key Vector3(1, 0, 1) is played in the next frame, the difference can be calculated as follows:
use actor::Player as root : CharacterBody3Duse actor::AnimationTree as animation_tree : AnimationTree
@onready state_machine : AnimationNodeStateMachinePlayback = animation_tree.get("parameters/playback") as AnimationNodeStateMachinePlaybackmut prev_root_motion_position_accumulator : Vector3 = Vector3.ZERO
fn _process(delta: float) { if Input.is_action_just_pressed("animate") { state_machine.travel("Animate") } current_root_motion_position_accumulator : Vector3 = animation_tree.get_root_motion_position_accumulator() difference : Vector3 = current_root_motion_position_accumulator - prev_root_motion_position_accumulator prev_root_motion_position_accumulator = current_root_motion_position_accumulator root.transform.origin += difference}However, if the animation loops, an unintended discrete change may occur, so this is only useful for some simple use cases.
get_root_motion_rotation
Section titled “get_root_motion_rotation”Quaternion get_root_motion_rotation() const
Retrieve the motion delta of rotation with the root_motion_track as a Quaternion that can be used elsewhere.
If root_motion_track is not a path to a track of type Animation.TYPE_ROTATION_3D, returns Quaternion(0, 0, 0, 1).
See also root_motion_track and RootMotionView.
The most basic example is applying rotation to CharacterBody3D:
use actor::Player as root : CharacterBody3Duse actor::AnimationTree as animation_tree : AnimationTree
@onready state_machine : AnimationNodeStateMachinePlayback = animation_tree.get("parameters/playback") as AnimationNodeStateMachinePlayback
fn _process(delta: float) { if Input.is_action_just_pressed("animate") { state_machine.travel("Animate") } root.set_quaternion(root.get_quaternion() * animation_tree.get_root_motion_rotation())}get_root_motion_rotation_accumulator
Section titled “get_root_motion_rotation_accumulator”Quaternion get_root_motion_rotation_accumulator() const
Retrieve the blended value of the rotation tracks with the root_motion_track as a Quaternion that can be used elsewhere.
This is necessary to apply the root motion position correctly, taking rotation into account. See also get_root_motion_position().
Also, this is useful in cases where you want to respect the initial key values of the animation.
For example, if an animation with only one key Quaternion(0, 0, 0, 1) is played in the previous frame and then an animation with only one key Quaternion(0, 0.707, 0, 0.707) is played in the next frame, the difference can be calculated as follows:
use actor::Player as root : CharacterBody3Duse actor::AnimationTree as animation_tree : AnimationTree
@onready state_machine : AnimationNodeStateMachinePlayback = animation_tree.get("parameters/playback") as AnimationNodeStateMachinePlaybackmut prev_root_motion_rotation_accumulator : Quaternion = Quaternion.IDENTITY
fn _process(delta: float) { if Input.is_action_just_pressed("animate") { state_machine.travel("Animate") } current_root_motion_rotation_accumulator : Quaternion = animation_tree.get_root_motion_rotation_accumulator() difference : Quaternion = prev_root_motion_rotation_accumulator.inverse() * current_root_motion_rotation_accumulator prev_root_motion_rotation_accumulator = current_root_motion_rotation_accumulator root.transform.basis *= Basis(difference)}However, if the animation loops, an unintended discrete change may occur, so this is only useful for some simple use cases.
get_root_motion_scale
Section titled “get_root_motion_scale”Vector3 get_root_motion_scale() const
Retrieve the motion delta of scale with the root_motion_track as a Vector3 that can be used elsewhere.
If root_motion_track is not a path to a track of type Animation.TYPE_SCALE_3D, returns Vector3(0, 0, 0).
See also root_motion_track and RootMotionView.
The most basic example is applying scale to CharacterBody3D:
use actor::Player as root : CharacterBody3Duse actor::AnimationTree as animation_tree : AnimationTree
@onready state_machine : AnimationNodeStateMachinePlayback = animation_tree.get("parameters/playback") as AnimationNodeStateMachinePlaybackmut current_scale : Vector3 = Vector3(1, 1, 1)mut scale_accum : Vector3 = Vector3(1, 1, 1)
fn _process(delta: float) { if Input.is_action_just_pressed("animate") { current_scale = root.get_scale() scale_accum = Vector3(1, 1, 1) state_machine.travel("Animate") } scale_accum += animation_tree.get_root_motion_scale() root.set_scale(current_scale * scale_accum)}get_root_motion_scale_accumulator
Section titled “get_root_motion_scale_accumulator”Vector3 get_root_motion_scale_accumulator() const
Retrieve the blended value of the scale tracks with the root_motion_track as a Vector3 that can be used elsewhere.
For example, if an animation with only one key Vector3(1, 1, 1) is played in the previous frame and then an animation with only one key Vector3(2, 2, 2) is played in the next frame, the difference can be calculated as follows:
use actor::Player as root : CharacterBody3Duse actor::AnimationTree as animation_tree : AnimationTree
@onready state_machine : AnimationNodeStateMachinePlayback = animation_tree.get("parameters/playback") as AnimationNodeStateMachinePlaybackmut prev_root_motion_scale_accumulator : Vector3 = Vector3(1, 1, 1)
fn _process(delta: float) { if Input.is_action_just_pressed("animate") { state_machine.travel("Animate") } current_root_motion_scale_accumulator : Vector3 = animation_tree.get_root_motion_scale_accumulator() difference : Vector3 = current_root_motion_scale_accumulator - prev_root_motion_scale_accumulator prev_root_motion_scale_accumulator = current_root_motion_scale_accumulator root.transform.basis = root.transform.basis.scaled(difference)}However, if the animation loops, an unintended discrete change may occur, so this is only useful for some simple use cases.
has_animation
Section titled “has_animation”bool has_animation(name: StringName) const
Returns true if the AnimationMixer stores an Animation with key name.
has_animation_library
Section titled “has_animation_library”bool has_animation_library(name: StringName) const
Returns true if the AnimationMixer stores an AnimationLibrary with key name.
remove_animation_library
Section titled “remove_animation_library”void remove_animation_library(name: StringName)
Removes the AnimationLibrary associated with the key name.
rename_animation_library
Section titled “rename_animation_library”void rename_animation_library(name: StringName, newname: StringName)
Moves the AnimationLibrary associated with the key name to the key newname.