class-description NEWS COMMUNITY STORE LABS SIGN UP LOGIN LOGOUT ROKOJORI NEWSLETTER SIGN UP LOGIN LOGOUT NEWS COMMUNITY STORE LABS TOGGLE FULLSCREEN VOLLBILD AN/AUS ObjectNode AnimationMixer
Base class for AnimationPlayer and AnimationTree.

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.

 animation_finished animation_finished<>( StringName anim_name=, anim_name:StringName=, ):animation_finished

Notifies when an animation finished playing.

Note: This signal is not emitted if an animation is looping.

 animation_libraries_updated animation_libraries_updated<>():animation_libraries_updated

Notifies when the animation libraries have changed.

 animation_list_changed animation_list_changed<>():animation_list_changed

Notifies when an animation list is changed.

 animation_started animation_started<>( StringName anim_name=, anim_name:StringName=, ):animation_started

Notifies when an animation starts playing.

 caches_cleared caches_cleared<>():caches_cleared

Notifies when the caches have been cleared, either automatically, or manually via clear_caches.

 mixer_updated mixer_updated<>():mixer_updated

Editor only. Notifies when the property have been updated to update dummy AnimationPlayer in animation player editor.

 Enum AnimationCallbackModeProcess<>():Enum

ANIMATION_CALLBACK_MODE_PROCESS_PHYSICS = 0

Process animation during physics frames (see Node.NOTIFICATION_INTERNAL_PHYSICS_PROCESS). This is especially useful when animating physics bodies.


ANIMATION_CALLBACK_MODE_PROCESS_IDLE = 1

Process animation during process frames (see Node.NOTIFICATION_INTERNAL_PROCESS).


ANIMATION_CALLBACK_MODE_PROCESS_MANUAL = 2

Do not process animation. Use advance to process the animation manually.

 Enum AnimationCallbackModeMethod<>():Enum

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 nodes or modifying the AnimationPlayer while playing.


ANIMATION_CALLBACK_MODE_METHOD_IMMEDIATE = 1

Make method calls immediately when reached in the animation.

 bool active<>():bool

If true, the AnimationMixer will be processing.

 int audio_max_polyphony<>():int

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.

 AnimationCallbackModeMethod callback_mode_method<>():AnimationCallbackModeMethod

The call mode to use for Call Method tracks.

 AnimationCallbackModeProcess callback_mode_process<>():AnimationCallbackModeProcess

The process notification in which to update animations.

 bool deterministic<>():bool

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 nodes 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.

 bool reset_on_save<>():bool

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.

 NodePath root_motion_track<>():NodePath

The path to the Animation track used for root motion. Paths must be valid scene-tree paths to a node, and must be specified starting from the parent node of the node that will reproduce the animation. To specify a track that controls properties or bones, append its name after the path, separated by ":". For example, "character/skeleton:ankle" or "character/mesh:transform/local".

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.

 NodePath root_node<>():NodePath

The node from which node path references will travel.

 Variant _post_process_key_value<>( Animation animation=, animation:Animation=, int track=, track:int=, Variant value=, value:Variant=, int object_id=, object_id:int=, int object_sub_idx=, object_sub_idx:int=, ):Variant

A virtual function for processing after getting a key during playback.

 Error add_animation_library<>( StringName name=, name:StringName=, AnimationLibrary library=, library:AnimationLibrary=, ):Error

Adds library to the animation player, under the key name.

 void advance<>( float delta=, delta:float=, ):void

Manually advance the animations by the specified time (in seconds).

 void clear_caches<>():void

AnimationMixer caches animated nodes. It may not notice if a node disappears; clear_caches forces it to update the cache again.

 StringName find_animation<>( Animation animation=, animation:Animation=, ):StringName

Returns the key of animation or an empty StringName if not found.

 StringName find_animation_library<>( Animation animation=, animation:Animation=, ):StringName

Returns the key for the AnimationLibrary that contains animation or an empty StringName if not found.

 Animation get_animation<>( StringName name=, name:StringName=, ):Animation

Returns the Animation with the key name. If the animation does not exist, null is returned and an error is logged.

 AnimationLibrary get_animation_library<>( StringName name=, name:StringName=, ):AnimationLibrary

Returns the first AnimationLibrary with key name or null if not found.

To get the AnimationPlayer's global animation library, use get_animation_library("").

 StringName[] get_animation_library_list<>():StringName[]

Returns the list of stored library keys.

 PackedStringArray get_animation_list<>():PackedStringArray

Returns the list of stored animation keys.

 Vector3 get_root_motion_position<>():Vector3

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:

var current_rotation: Quaternion func _process(delta): if Input.is_action_just_pressed("animate"): current_rotation = get_quaternion() state_machine.travel("Animate") var velocity: Vector3 = current_rotation * animation_tree.get_root_motion_position() / delta set_velocity(velocity) move_and_slide()

By using this in combination with get_root_motion_position_accumulator, you can apply the root motion position more correctly to account for the rotation of the node.

func _process(delta): if Input.is_action_just_pressed("animate"): state_machine.travel("Animate") set_quaternion(get_quaternion() * animation_tree.get_root_motion_rotation()) var velocity: Vector3 = (animation_tree.get_root_motion_rotation_accumulator().inverse() * get_quaternion()) * animation_tree.get_root_motion_position() / delta set_velocity(velocity) move_and_slide()
Vector3 get_root_motion_position_accumulator<>():Vector3

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:

var prev_root_motion_position_accumulator: Vector3 func _process(delta): if Input.is_action_just_pressed("animate"): state_machine.travel("Animate") var current_root_motion_position_accumulator: Vector3 = animation_tree.get_root_motion_position_accumulator() var difference: Vector3 = current_root_motion_position_accumulator - prev_root_motion_position_accumulator prev_root_motion_position_accumulator = current_root_motion_position_accumulator transform.origin += difference

However, if the animation loops, an unintended discrete change may occur, so this is only useful for some simple use cases.

 Quaternion get_root_motion_rotation<>():Quaternion

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:

func _process(delta): if Input.is_action_just_pressed("animate"): state_machine.travel("Animate") set_quaternion(get_quaternion() * animation_tree.get_root_motion_rotation())
Quaternion get_root_motion_rotation_accumulator<>():Quaternion

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:

var prev_root_motion_rotation_accumulator: Quaternion func _process(delta): if Input.is_action_just_pressed("animate"): state_machine.travel("Animate") var current_root_motion_rotation_accumulator: Quaternion = animation_tree.get_root_motion_Quaternion_accumulator() var difference: Quaternion = prev_root_motion_rotation_accumulator.inverse() * current_root_motion_rotation_accumulator prev_root_motion_rotation_accumulator = current_root_motion_rotation_accumulator transform.basis *= difference

However, if the animation loops, an unintended discrete change may occur, so this is only useful for some simple use cases.

 Vector3 get_root_motion_scale<>():Vector3

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:

var current_scale: Vector3 = Vector3(1, 1, 1) var scale_accum: Vector3 = Vector3(1, 1, 1) func _process(delta): if Input.is_action_just_pressed("animate"): current_scale = get_scale() scale_accum = Vector3(1, 1, 1) state_machine.travel("Animate") scale_accum += animation_tree.get_root_motion_scale() set_scale(current_scale * scale_accum)
Vector3 get_root_motion_scale_accumulator<>():Vector3

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:

var prev_root_motion_scale_accumulator: Vector3 func _process(delta): if Input.is_action_just_pressed("animate"): state_machine.travel("Animate") var current_root_motion_scale_accumulator: Vector3 = animation_tree.get_root_motion_scale_accumulator() var difference: Vector3 = current_root_motion_scale_accumulator - prev_root_motion_scale_accumulator prev_root_motion_scale_accumulator = current_root_motion_scale_accumulator transform.basis = 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.

 bool has_animation<>( StringName name=, name:StringName=, ):bool

Returns true if the AnimationPlayer stores an Animation with key name.

 bool has_animation_library<>( StringName name=, name:StringName=, ):bool

Returns true if the AnimationPlayer stores an AnimationLibrary with key name.

 void remove_animation_library<>( StringName name=, name:StringName=, ):void

Removes the AnimationLibrary associated with the key name.

 void rename_animation_library<>( StringName name=, name:StringName=, StringName newname=, newname:StringName=, ):void

Moves the AnimationLibrary associated with the key name to the key newname.


All social media brands are registrated trademarks and belong to their respective owners.





CONTACT IMPRINT TERMS OF USE PRIVACY © ROKOROJI ® 2021 rokojori.com CONTACT IMPRINT TERMS OF USE PRIVACY © ROKOROJI ® 2021 rokojori.com We are using cookies on this site. Read more... Wir benutzen Cookies auf dieser Seite. Mehr lesen...