Index · Object → RefCounted → Resource → Animation

Animation

Holds data that can be used to animate anything in the engine.

Class Description

This resource holds data that can be used to animate anything in the engine. Animations are divided into tracks and each track must be linked to a node. The state of that node can be changed through time, by adding timed keys (events) to the track.

# This creates an animation that makes the node "Enemy" move to the right by
# 100 pixels in 2.0 seconds.
var animation = Animation.new()
var track_index = animation.add_track(Animation.TYPE_VALUE)
animation.track_set_path(track_index, "Enemy:position:x")
animation.track_insert_key(track_index, 0.0, 0)
animation.track_insert_key(track_index, 2.0, 100)
animation.length = 2.0

Animations are just data containers, and must be added to nodes such as an AnimationPlayer to be played back. Animation tracks have different types, each with its own set of dedicated methods. Check TrackType to see available types.

Note: For 3D position/rotation/scale, using the dedicated TYPE_POSITION_3D, TYPE_ROTATION_3D and TYPE_SCALE_3D track types instead of TYPE_VALUE is recommended for performance reasons.

Properties

var capture_included: bool = false

Returns true if the capture track is included. This is a cached readonly value for performance.

var length: float = 1.0

The total length of the animation (in seconds).

Note: Length is not delimited by the last key, as this one may be before or after the end to ensure correct interpolation and looping.

var loop_mode: Animation.LoopMode = 0

Determines the behavior of both ends of the animation timeline during animation playback. This indicates whether and how the animation should be restarted, and is also used to correctly interpolate animation cycles.

var step: float = 0.033333335

The animation step value.

Inherited from Resource (4)

Methods

func add_marker(name: StringName, time: float) -> void

Adds a marker to this Animation.

func add_track(type: Animation.TrackType, at_position: int = -1) -> int

Adds a track to the Animation.

func animation_track_get_key_animation(track_idx: int, key_idx: int) -> StringName

Returns the animation name at the key identified by key_idx. The track_idx must be the index of an Animation Track.

func animation_track_insert_key(track_idx: int, time: float, animation: StringName) -> int

Inserts a key with value animation at the given time (in seconds). The track_idx must be the index of an Animation Track.

func animation_track_set_key_animation(track_idx: int, key_idx: int, animation: StringName) -> void

Sets the key identified by key_idx to value animation. The track_idx must be the index of an Animation Track.

func audio_track_get_key_end_offset(track_idx: int, key_idx: int) -> float

Returns the end offset of the key identified by key_idx. The track_idx must be the index of an Audio Track.

End offset is the number of seconds cut off at the ending of the audio stream.

func audio_track_get_key_start_offset(track_idx: int, key_idx: int) -> float

Returns the start offset of the key identified by key_idx. The track_idx must be the index of an Audio Track.

Start offset is the number of seconds cut off at the beginning of the audio stream.

func audio_track_get_key_stream(track_idx: int, key_idx: int) -> Resource

Returns the audio stream of the key identified by key_idx. The track_idx must be the index of an Audio Track.

func audio_track_insert_key(track_idx: int, time: float, stream: Resource, start_offset: float = 0, end_offset: float = 0) -> int

Inserts an Audio Track key at the given time in seconds. The track_idx must be the index of an Audio Track.

stream is the AudioStream resource to play. start_offset is the number of seconds cut off at the beginning of the audio stream, while end_offset is at the ending.

func audio_track_is_use_blend(track_idx: int) -> bool

Returns true if the track at track_idx will be blended with other animations.

func audio_track_set_key_end_offset(track_idx: int, key_idx: int, offset: float) -> void

Sets the end offset of the key identified by key_idx to value offset. The track_idx must be the index of an Audio Track.

func audio_track_set_key_start_offset(track_idx: int, key_idx: int, offset: float) -> void

Sets the start offset of the key identified by key_idx to value offset. The track_idx must be the index of an Audio Track.

func audio_track_set_key_stream(track_idx: int, key_idx: int, stream: Resource) -> void

Sets the stream of the key identified by key_idx to value stream. The track_idx must be the index of an Audio Track.

func audio_track_set_use_blend(track_idx: int, enable: bool) -> void

Sets whether the track will be blended with other animations. If true, the audio playback volume changes depending on the blend value.

func bezier_track_get_key_in_handle(track_idx: int, key_idx: int) -> Vector2

Returns the in handle of the key identified by key_idx. The track_idx must be the index of a Bezier Track.

func bezier_track_get_key_out_handle(track_idx: int, key_idx: int) -> Vector2

Returns the out handle of the key identified by key_idx. The track_idx must be the index of a Bezier Track.

func bezier_track_get_key_value(track_idx: int, key_idx: int) -> float

Returns the value of the key identified by key_idx. The track_idx must be the index of a Bezier Track.

func bezier_track_insert_key(track_idx: int, time: float, value: float, in_handle: Vector2 = Vector2(0, 0), out_handle: Vector2 = Vector2(0, 0)) -> int

Inserts a Bezier Track key at the given time in seconds. The track_idx must be the index of a Bezier Track.

in_handle is the left-side weight of the added Bezier curve point, out_handle is the right-side one, while value is the actual value at this point.

func bezier_track_interpolate(track_idx: int, time: float) -> float

Returns the interpolated value at the given time (in seconds). The track_idx must be the index of a Bezier Track.

func bezier_track_set_key_in_handle(track_idx: int, key_idx: int, in_handle: Vector2, balanced_value_time_ratio: float = 1.0) -> void

Sets the in handle of the key identified by key_idx to value in_handle. The track_idx must be the index of a Bezier Track.

func bezier_track_set_key_out_handle(track_idx: int, key_idx: int, out_handle: Vector2, balanced_value_time_ratio: float = 1.0) -> void

Sets the out handle of the key identified by key_idx to value out_handle. The track_idx must be the index of a Bezier Track.

func bezier_track_set_key_value(track_idx: int, key_idx: int, value: float) -> void

Sets the value of the key identified by key_idx to the given value. The track_idx must be the index of a Bezier Track.

func blend_shape_track_insert_key(track_idx: int, time: float, amount: float) -> int

Inserts a key in a given blend shape track. Returns the key index.

func blend_shape_track_interpolate(track_idx: int, time_sec: float, backward: bool = false) -> float

Returns the interpolated blend shape value at the given time (in seconds). The track_idx must be the index of a blend shape track.

func clear() -> void

Clear the animation (clear all tracks and reset all).

func compress(page_size: int = 8192, fps: int = 120, split_tolerance: float = 4.0) -> void

Compress the animation and all its tracks in-place. This will make track_is_compressed() return true once called on this Animation. Compressed tracks require less memory to be played, and are designed to be used for complex 3D animations (such as cutscenes) imported from external 3D software. Compression is lossy, but the difference is usually not noticeable in real world conditions.

Note: Compressed tracks have various limitations (such as not being editable from the editor), so only use compressed animations if you actually need them.

func copy_track(track_idx: int, to_animation: Animation) -> void

Adds a new track to to_animation that is a copy of the given track from this animation.

func find_track(path: NodePath, type: Animation.TrackType) -> int

Returns the index of the specified track. If the track is not found, return -1.

func get_marker_at_time(time: float) -> StringName

Returns the name of the marker located at the given time.

func get_marker_color(name: StringName) -> Color

Returns the given marker's color.

func get_marker_names() -> PackedStringArray

Returns every marker in this Animation, sorted ascending by time.

func get_marker_time(name: StringName) -> float

Returns the given marker's time.

func get_next_marker(time: float) -> StringName

Returns the closest marker that comes after the given time. If no such marker exists, an empty string is returned.

func get_prev_marker(time: float) -> StringName

Returns the closest marker that comes before the given time. If no such marker exists, an empty string is returned.

func get_track_count() -> int

Returns the amount of tracks in the animation.

func has_marker(name: StringName) -> bool

Returns true if this Animation contains a marker with the given name.

func method_track_get_name(track_idx: int, key_idx: int) -> StringName

Returns the method name of a method track.

func method_track_get_params(track_idx: int, key_idx: int) -> Array

Returns the arguments values to be called on a method track for a given key in a given track.

func optimize(allowed_velocity_err: float = 0.01, allowed_angular_err: float = 0.01, precision: int = 3) -> void

Optimize the animation and all its tracks in-place. This will preserve only as many keys as are necessary to keep the animation within the specified bounds.

func position_track_insert_key(track_idx: int, time: float, position: Vector3) -> int

Inserts a key in a given 3D position track. Returns the key index.

func position_track_interpolate(track_idx: int, time_sec: float, backward: bool = false) -> Vector3

Returns the interpolated position value at the given time (in seconds). The track_idx must be the index of a 3D position track.

func remove_marker(name: StringName) -> void

Removes the marker with the given name from this Animation.

func remove_track(track_idx: int) -> void

Removes a track by specifying the track index.

func rotation_track_insert_key(track_idx: int, time: float, rotation: Quaternion) -> int

Inserts a key in a given 3D rotation track. Returns the key index.

func rotation_track_interpolate(track_idx: int, time_sec: float, backward: bool = false) -> Quaternion

Returns the interpolated rotation value at the given time (in seconds). The track_idx must be the index of a 3D rotation track.

func scale_track_insert_key(track_idx: int, time: float, scale: Vector3) -> int

Inserts a key in a given 3D scale track. Returns the key index.

func scale_track_interpolate(track_idx: int, time_sec: float, backward: bool = false) -> Vector3

Returns the interpolated scale value at the given time (in seconds). The track_idx must be the index of a 3D scale track.

func set_marker_color(name: StringName, color: Color) -> void

Sets the given marker's color.

func track_find_key(track_idx: int, time: float, find_mode: Animation.FindMode = 0, limit: bool = false, backward: bool = false) -> int

Finds the key index by time in a given track. Optionally, only find it if the approx/exact time is given.

If limit is true, it does not return keys outside the animation range.

If backward is true, the direction is reversed in methods that rely on one directional processing.

For example, in case find_mode is FIND_MODE_NEAREST, if there is no key in the current position just after seeked, the first key found is retrieved by searching before the position, but if backward is true, the first key found is retrieved after the position.

func track_get_interpolation_loop_wrap(track_idx: int) -> bool

Returns true if the track at track_idx wraps the interpolation loop. New tracks wrap the interpolation loop by default.

func track_get_interpolation_type(track_idx: int) -> Animation.InterpolationType

Returns the interpolation type of a given track.

func track_get_key_count(track_idx: int) -> int

Returns the number of keys in a given track.

func track_get_key_time(track_idx: int, key_idx: int) -> float

Returns the time at which the key is located.

func track_get_key_transition(track_idx: int, key_idx: int) -> float

Returns the transition curve (easing) for a specific key (see the built-in math function ease()).

func track_get_key_value(track_idx: int, key_idx: int) -> Variant

Returns the value of a given key in a given track.

func track_get_path(track_idx: int) -> NodePath

Gets the path of a track. For more information on the path format, see track_set_path().

func track_get_type(track_idx: int) -> Animation.TrackType

Gets the type of a track.

func track_insert_key(track_idx: int, time: float, key: Variant, transition: float = 1) -> int

Inserts a generic key in a given track. Returns the key index.

func track_is_compressed(track_idx: int) -> bool

Returns true if the track is compressed, false otherwise. See also compress().

func track_is_enabled(track_idx: int) -> bool

Returns true if the track at index track_idx is enabled.

func track_is_imported(track_idx: int) -> bool

Returns true if the given track is imported. Else, return false.

func track_move_down(track_idx: int) -> void

Moves a track down.

func track_move_to(track_idx: int, to_idx: int) -> void

Changes the index position of track track_idx to the one defined in to_idx.

func track_move_up(track_idx: int) -> void

Moves a track up.

func track_remove_key(track_idx: int, key_idx: int) -> void

Removes a key by index in a given track.

func track_remove_key_at_time(track_idx: int, time: float) -> void

Removes a key at time in a given track.

func track_set_enabled(track_idx: int, enabled: bool) -> void

Enables/disables the given track. Tracks are enabled by default.

func track_set_imported(track_idx: int, imported: bool) -> void

Sets the given track as imported or not.

func track_set_interpolation_loop_wrap(track_idx: int, interpolation: bool) -> void

If true, the track at track_idx wraps the interpolation loop.

func track_set_interpolation_type(track_idx: int, interpolation: Animation.InterpolationType) -> void

Sets the interpolation type of a given track.

func track_set_key_time(track_idx: int, key_idx: int, time: float) -> void

Sets the time of an existing key.

func track_set_key_transition(track_idx: int, key_idx: int, transition: float) -> void

Sets the transition curve (easing) for a specific key (see the built-in math function ease()).

func track_set_key_value(track_idx: int, key: int, value: Variant) -> void

Sets the value of an existing key.

func track_set_path(track_idx: int, path: NodePath) -> void

Sets the path of a track. Paths must be valid scene-tree paths to a node and must be specified starting from the AnimationMixer.root_node that will reproduce the animation. Tracks that control properties or bones must append their name after the path, separated by ":".

For example, "character/skeleton:ankle" or "character/mesh:transform/local".

func track_swap(track_idx: int, with_idx: int) -> void

Swaps the track track_idx's index position with the track with_idx.

func value_track_get_update_mode(track_idx: int) -> Animation.UpdateMode

Returns the update mode of a value track.

func value_track_interpolate(track_idx: int, time_sec: float, backward: bool = false) -> Variant

Returns the interpolated value at the given time (in seconds). The track_idx must be the index of a value track.

A backward mainly affects the direction of key retrieval of the track with UPDATE_DISCRETE converted by AnimationMixer.ANIMATION_CALLBACK_MODE_DISCRETE_FORCE_CONTINUOUS to match the result with track_find_key().

func value_track_set_update_mode(track_idx: int, mode: Animation.UpdateMode) -> void

Sets the update mode of a value track.

Inherited from Resource (18)
func _get_rid() -> RID
func _reset_state() -> void
func _set_path_cache(path: String) -> void
func _setup_local_to_scene() -> void
func copy_from_resource(resource: Resource) -> Error
func duplicate(deep: bool = false) -> Resource
func duplicate_deep(deep_subresources_mode: Resource.DeepDuplicateMode = 1) -> Resource
func emit_changed() -> void
func get_rid() -> RID
func is_built_in() -> bool
func reset_state() -> void
func set_id_for_path(path: String, id: String) -> void
func set_path_cache(path: String) -> void
func setup_local_to_scene() -> void
func take_over_path(path: String) -> void
Inherited from RefCounted (4)
func init_ref() -> bool
func reference() -> bool
func unreference() -> bool
Inherited from Object (62)
func _get(property: StringName) -> Variant
func _get_property_list() -> Dictionary[]
func _init() -> void
func _iter_get(iter: Variant) -> Variant
func _iter_init(iter: Array) -> bool
func _iter_next(iter: Array) -> bool
func _notification(what: int) -> void
func _set(property: StringName, value: Variant) -> bool
func _to_string() -> String
func _validate_property(property: Dictionary) -> void
func add_user_signal(signal: String, arguments: Array = []) -> void
func call(method: StringName) -> Variant
func callv(method: StringName, arg_array: Array) -> Variant
func cancel_free() -> void
func connect(signal: StringName, callable: Callable, flags: int = 0) -> Error
func disconnect(signal: StringName, callable: Callable) -> void
func emit_signal(signal: StringName) -> Error
func free() -> void
func get(property: StringName) -> Variant
func get_class() -> String
func get_incoming_connections() -> Dictionary[]
func get_indexed(property_path: NodePath) -> Variant
func get_meta(name: StringName, default: Variant = null) -> Variant
func get_meta_list() -> StringName[]
func get_method_list() -> Dictionary[]
func get_property_list() -> Dictionary[]
func get_signal_connection_list(signal: StringName) -> Dictionary[]
func get_signal_list() -> Dictionary[]
func has_meta(name: StringName) -> bool
func has_method(method: StringName) -> bool
func has_signal(signal: StringName) -> bool
func is_class(class: StringName) -> bool
func is_connected(signal: StringName, callable: Callable) -> bool
func notification(what: int, reversed: bool = false) -> void
func remove_meta(name: StringName) -> void
func remove_user_signal(signal: StringName) -> void
func set(property: StringName, value: Variant) -> void
func set_block_signals(enable: bool) -> void
func set_deferred(property: StringName, value: Variant) -> void
func set_indexed(property_path: NodePath, value: Variant) -> void
func set_message_translation(enable: bool) -> void
func set_meta(name: StringName, value: Variant) -> void
func set_script(script: Variant) -> void
func set_translation_domain(domain: StringName) -> void
func to_string() -> String
func tr(message: StringName, context: StringName = &"") -> String
func tr_n(message: StringName, plural_message: StringName, n: int, context: StringName = &"") -> String

Signals

Inherited from Resource (2)
signal changed()
Inherited from Object (2)

Enums & Constants

enum TrackType
TYPE_VALUE = 0

Value tracks set values in node properties, but only those which can be interpolated. For 3D position/rotation/scale, using the dedicated TYPE_POSITION_3D, TYPE_ROTATION_3D and TYPE_SCALE_3D track types instead of TYPE_VALUE is recommended for performance reasons.

TYPE_POSITION_3D = 1

3D position track (values are stored in Vector3s).

TYPE_ROTATION_3D = 2

3D rotation track (values are stored in Quaternions).

TYPE_SCALE_3D = 3

3D scale track (values are stored in Vector3s).

TYPE_BLEND_SHAPE = 4

Blend shape track.

TYPE_METHOD = 5

Method tracks call functions with given arguments per key.

TYPE_BEZIER = 6

Bezier tracks are used to interpolate a value using custom curves. They can also be used to animate sub-properties of vectors and colors (e.g. alpha value of a Color).

TYPE_AUDIO = 7

Audio tracks are used to play an audio stream with either type of AudioStreamPlayer. The stream can be trimmed and previewed in the animation.

TYPE_ANIMATION = 8

Animation tracks play animations in other AnimationPlayer nodes.

enum InterpolationType
INTERPOLATION_NEAREST = 0

No interpolation (nearest value).

INTERPOLATION_LINEAR = 1

Linear interpolation.

INTERPOLATION_CUBIC = 2

Cubic interpolation. This looks smoother than linear interpolation, but is more expensive to interpolate. Stick to INTERPOLATION_LINEAR for complex 3D animations imported from external software, even if it requires using a higher animation framerate in return.

INTERPOLATION_LINEAR_ANGLE = 3

Linear interpolation with shortest path rotation.

Note: The result value is always normalized and may not match the key value.

INTERPOLATION_CUBIC_ANGLE = 4

Cubic interpolation with shortest path rotation.

Note: The result value is always normalized and may not match the key value.

enum UpdateMode
UPDATE_CONTINUOUS = 0

Update between keyframes and hold the value.

UPDATE_DISCRETE = 1

Update at the keyframes.

UPDATE_CAPTURE = 2

Same as UPDATE_CONTINUOUS but works as a flag to capture the value of the current object and perform interpolation in some methods. See also AnimationMixer.capture(), AnimationPlayer.playback_auto_capture, and AnimationPlayer.play_with_capture().

enum LoopMode
LOOP_NONE = 0

At both ends of the animation, the animation will stop playing.

LOOP_LINEAR = 1

At both ends of the animation, the animation will be repeated without changing the playback direction.

LOOP_PINGPONG = 2

Repeats playback and reverse playback at both ends of the animation.

enum LoopedFlag
LOOPED_FLAG_NONE = 0

This flag indicates that the animation proceeds without any looping.

LOOPED_FLAG_END = 1

This flag indicates that the animation has reached the end of the animation and just after loop processed.

LOOPED_FLAG_START = 2

This flag indicates that the animation has reached the start of the animation and just after loop processed.

enum FindMode
FIND_MODE_NEAREST = 0

Finds the nearest time key.

FIND_MODE_APPROX = 1

Finds only the key with approximating the time.

FIND_MODE_EXACT = 2

Finds only the key with matching the time.