NEWS
COMMUNITY
STORE
TUTORIALS
ROKOJORI
NEWSLETTER
SIGN UPLOGIN
LOGOUTNEWS
COMMUNITY
STORE
TUTORIALS
Tween is more suited than AnimationPlayer for animations where you don't know the final values in advance. For example, interpolating a dynamically-chosen camera zoom value is best done with a Tween; it would be difficult to do the same thing with an AnimationPlayer node. Tweens are also more light-weight than AnimationPlayer, so they are very much suited for simple animations or general tasks that don't require visual tweaking provided by the editor. They can be used in a "fire-and-forget" manner for some logic that normally would be done by code. You can e.g. make something shoot periodically by using a looped CallbackTweener with a delay.
A Tween can be created by using either [method SceneTree.create_tween] or [method Node.create_tween]. Tweens created manually (i.e. by using
A tween animation is created by adding Tweeners to the Tween object, using tween_property, tween_interval, tween_callback or tween_method:
This sequence will make the
When a Tweener is created with one of the
Most of the Tween methods can be chained this way too. In the following example the Tween is bound to the running script's node and a default transition is set for its Tweeners:
Another interesting use for Tweens is animating arbitrary sets of objects:
In the example above, all children of a node are moved one after another to position
You should avoid using more than one Tween per object's property. If two or more tweens animate one property at the same time, the last one created will take priority and assign the final value. If you want to interrupt and restart an animation, consider assigning the Tween to a variable:
Some Tweeners use transitions and eases. The first accepts a TransitionType constant, and refers to the way the timing of the animation is handled (see [url=https://easings.net/]easings.net[/url] for some examples). The second accepts an EaseType constant, and controls where the
[url=https://raw.githubusercontent.com/godotengine/godot-docs/master/img/tween_cheatsheet.webp]Tween easing and transition types cheatsheet[/url]
Note: Tweens are not designed to be reused and trying to do so results in an undefined behavior. Create a new Tween for each animation and every time you replay an animation from start. Keep in mind that Tweens start immediately, so only create a Tween when you want to start animating.
Note: The tween is processed after all of the nodes in the current frame, i.e. node's [method Node._process] method would be called before the tween (or [method Node._physics_process] depending on the value passed to set_process_mode).
TWEEN_PAUSE_BOUND:null = 0
If the Tween has a bound node, it will process when that node can process (see [member Node.process_mode]). Otherwise it's the same as TWEEN_PAUSE_STOP.
TWEEN_PAUSE_STOP:null = 1
If SceneTree is paused, the Tween will also pause.
TWEEN_PAUSE_PROCESS:null = 2
The Tween will process regardless of whether SceneTree is paused.
TRANS_LINEAR:null = 0
The animation is interpolated linearly.
TRANS_SINE:null = 1
The animation is interpolated using a sine function.
TRANS_QUINT:null = 2
The animation is interpolated with a quintic (to the power of 5) function.
TRANS_QUART:null = 3
The animation is interpolated with a quartic (to the power of 4) function.
TRANS_QUAD:null = 4
The animation is interpolated with a quadratic (to the power of 2) function.
TRANS_EXPO:null = 5
The animation is interpolated with an exponential (to the power of x) function.
TRANS_ELASTIC:null = 6
The animation is interpolated with elasticity, wiggling around the edges.
TRANS_CUBIC:null = 7
The animation is interpolated with a cubic (to the power of 3) function.
TRANS_CIRC:null = 8
The animation is interpolated with a function using square roots.
TRANS_BOUNCE:null = 9
The animation is interpolated by bouncing at the end.
TRANS_BACK:null = 10
The animation is interpolated backing out at ends.
TRANS_SPRING:null = 11
The animation is interpolated like a spring towards the end.
EASE_IN:null = 0
The interpolation starts slowly and speeds up towards the end.
EASE_OUT:null = 1
The interpolation starts quickly and slows down towards the end.
EASE_IN_OUT:null = 2
A combination of EASE_IN and EASE_OUT. The interpolation is slowest at both ends.
EASE_OUT_IN:null = 3
A combination of EASE_IN and EASE_OUT. The interpolation is fastest at both ends.
Binds this Tween with the given node. Tweens are processed directly by the SceneTree, so they run independently of the animated nodes. When you bind a Node with the Tween, the Tween will halt the animation when the object is not inside tree and the Tween will be automatically killed when the bound object is freed. Also TWEEN_PAUSE_BOUND will make the pausing behavior dependent on the bound node.
Returns the total time in seconds the Tween has been animating (i.e. the time since it started, not counting pauses etc.). The time is affected by set_speed_scale, and stop will reset it to 0 .
This method can be used for manual interpolation of a value, when you don't want Tween to do animating for you. It's similar to [method @GlobalScope.lerp], but with support for custom transition and easing.
initial_value is the starting value of the interpolation.
delta_value is the change of the value in the interpolation, i.e. it's equal to
elapsed_time is the time in seconds that passed after the interpolation started and it's used to control the position of the interpolation. E.g. when it's equal to half of the duration, the interpolated value will be halfway between initial and final values. This value can also be greater than duration or lower than 0, which will extrapolate the value.
duration is the total time of the interpolation.
Note: If duration is equal to
Returns whether the Tween is currently running, i.e. it wasn't paused and it's not finished.
Returns whether the Tween is valid. A valid Tween is a Tween contained by the scene tree (i.e. the array from [method SceneTree.get_processed_tweens] will contain this Tween). A Tween might become invalid when it has finished tweening, is killed, or when created with Tween.new() . Invalid Tweens can't have Tweeners appended.
Aborts all tweening operations and invalidates the Tween.
Makes the next Tweener run parallelly to the previous one.
All Tweeners in the example will run at the same time.
You can make the Tween parallel by default by using set_parallel.
Pauses the tweening. The animation can be resumed by using play.
Note: If a Tween is paused and not bound to any node, it will exist indefinitely until manually started or invalidated. If you lose a reference to such Tween, you can retrieve it using [method SceneTree.get_processed_tweens].
Resumes a paused or stopped Tween.
Sets the default ease type for PropertyTweeners and MethodTweeners appended after this method.
Before this method is called, the default ease type is EASE_IN_OUT.
Sets the number of times the tweening sequence will be repeated, i.e. set_loops(2) will run the animation twice.
Calling this method without arguments will make the Tween run infinitely, until either it is killed with kill, the Tween's bound node is freed, or all the animated objects have been freed (which makes further animation impossible).
Warning: Make sure to always add some duration/delay when using infinite loops. To prevent the game freezing, 0-duration looped animations (e.g. a single CallbackTweener with no delay) are stopped after a small number of loops, which may produce unexpected results. If a Tween's lifetime depends on some node, always use bind_node.
Note: Just like with parallel, the tweener added right before this method will also be part of the parallel step.
Determines whether the Tween should run after process frames (see [method Node._process]) or physics frames (see [method Node._physics_process]).
Scales the speed of tweening. This affects all Tweeners and their delays.
Sets the default transition type for PropertyTweeners and MethodTweeners appended after this method.
Before this method is called, the default transition type is TRANS_LINEAR.
Note: This does not reset targets of PropertyTweeners to their values when the Tween first started.
Note: If a Tween is stopped and not bound to any node, it will exist indefinitely until manually started or invalidated. If you lose a reference to such Tween, you can retrieve it using [method SceneTree.get_processed_tweens].
Creates and appends a CallbackTweener. This method can be used to call an arbitrary method in any object. Use [method Callable.bind] to bind additional arguments for the call.
Example: Object that keeps shooting every 1 second:
Example: Turning a sprite red and then blue, with 2 second delay:
Creates and appends an IntervalTweener. This method can be used to create delays in the tween animation, as an alternative to using the delay in other Tweeners, or when there's no animation (in which case the Tween acts as a timer). time is the length of the interval, in seconds.
Example: Creating an interval in code execution:
Example: Creating an object that moves back and forth and jumps every few seconds:
Creates and appends a MethodTweener. This method is similar to a combination of tween_callback and tween_property. It calls a method over time with a tweened value provided as an argument. The value is tweened between from and to over the time specified by duration, in seconds. Use [method Callable.bind] to bind additional arguments for the call. You can use [method MethodTweener.set_ease] and [method MethodTweener.set_trans] to tweak the easing and transition of the value or [method MethodTweener.set_delay] to delay the tweening.
Example: Making a 3D object look from one point to another point:
Example: Setting the text of a Label, using an intermediate method and after a delay:
Creates and appends a PropertyTweener. This method tweens a property of an object between an initial value and final_val in a span of time equal to duration, in seconds. The initial value by default is the property's value at the time the tweening of the PropertyTweener starts.
will move the sprite to position (100, 200) and then to (200, 300). If you use [method PropertyTweener.from] or [method PropertyTweener.from_current], the starting position will be overwritten by the given value instead. See other methods in PropertyTweener to see how the tweening can be tweaked further.
Note: You can find the correct property name by hovering over the property in the Inspector. You can also provide the components of a property directly by using
Example: Moving an object twice from the same position, with different transition types:
Creates and appends a SubtweenTweener. This method can be used to nest subtween within this Tween, allowing for the creation of more complex and composable sequences.
Note: The methods pause, stop, and set_loops can cause the parent Tween to get stuck on the subtween step; see the documentation for those methods for more information.
Note: The pause and process modes set by set_pause_mode and set_process_mode on subtween will be overridden by the parent Tween's settings.
