Tween

package
v0.0.0-...-82be904 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Sep 6, 2025 License: MIT Imports: 26 Imported by: 0

Documentation

Overview

Package Tween provides methods for working with Tween object instances.

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func InterpolateValue 

func InterpolateValue(initial_value any, delta_value any, elapsed_time Float.X, duration Float.X, trans_type TransitionType, ease_type EaseType) any

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. [param initial_value] is the starting value of the interpolation. [param delta_value] is the change of the value in the interpolation, i.e. it's equal to [code]final_value - initial_value[/code]. [param 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 [param duration], the interpolated value will be halfway between initial and final values. This value can also be greater than [param duration] or lower than 0, which will extrapolate the value. [param duration] is the total time of the interpolation. [b]Note:[/b] If [param duration] is equal to [code]0[/code], the method will always return the final value, regardless of [param elapsed_time] provided.

Types

type Advanced 

type Advanced = class

Advanced exposes a 1:1 low-level instance of the class, undocumented, for those who know what they are doing.

type Any 

type Any interface {
	gd.IsClass
	AsTween() Instance
}

type EaseType 

type EaseType int //gd:Tween.EaseType

const (
	/*The interpolation starts slowly and speeds up towards the end.*/
	EaseIn EaseType = 0
	/*The interpolation starts quickly and slows down towards the end.*/
	EaseOut EaseType = 1
	/*A combination of [constant EASE_IN] and [constant EASE_OUT]. The interpolation is slowest at both ends.*/
	EaseInOut EaseType = 2
	/*A combination of [constant EASE_IN] and [constant EASE_OUT]. The interpolation is fastest at both ends.*/
	EaseOutIn EaseType = 3
)

type Expanded 

type Expanded [1]gdclass.Tween

func (Expanded) SetIgnoreTimeScale 

func (self Expanded) SetIgnoreTimeScale(ignore bool) Instance

If [param ignore] is [code]true[/code], the tween will ignore [member Engine.time_scale] and update with the real, elapsed time. This affects all [Tweener]s and their delays. Default value is [code]false[/code].

func (Expanded) SetLoops 

func (self Expanded) SetLoops(loops int) Instance

Sets the number of times the tweening sequence will be repeated, i.e. [code]set_loops(2)[/code] will run the animation twice. Calling this method without arguments will make the [Tween] run infinitely, until either it is killed with [method kill], the [Tween]'s bound node is freed, or all the animated objects have been freed (which makes further animation impossible). [b]Warning:[/b] 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 [method bind_node].

func (Expanded) SetParallel 

func (self Expanded) SetParallel(parallel bool) Instance

If [param parallel] is [code]true[/code], the [Tweener]s appended after this method will by default run simultaneously, as opposed to sequentially. [b]Note:[/b] Just like with [method parallel], the tweener added right before this method will also be part of the parallel step. [codeblock] tween.tween_property(self, "position", Vector2(300, 0), 0.5) tween.set_parallel() tween.tween_property(self, "modulate", Color.GREEN, 0.5) # Runs together with the position tweener. [/codeblock]

type Extension 

type Extension[T gdclass.Interface] struct{ gdclass.Extension[T, Instance] }

Extension can be embedded in a new struct to create an extension of this class. T should be the type that is embedding this Extension

func (*Extension[T]) AsObject 

func (self *Extension[T]) AsObject() [1]gd.Object

func (*Extension[T]) AsRefCounted 

func (self *Extension[T]) AsRefCounted() [1]gd.RefCounted

func (*Extension[T]) AsTween 

func (self *Extension[T]) AsTween() Instance

type ID 

type ID Object.ID

ID is a typed object ID (reference) to an instance of this class, use it to store references to objects with unknown lifetimes, as an ID will not panic on use if the underlying object has been destroyed.

func (ID) Instance 

func (id ID) Instance() (Instance, bool)

type Instance 

type Instance [1]gdclass.Tween

Tweens are mostly useful for animations requiring a numerical property to be interpolated over a range of values. The name [i]tween[/i] comes from [i]in-betweening[/i], an animation technique where you specify [i]keyframes[/i] and the computer interpolates the frames that appear between them. Animating something with a [Tween] is called tweening. [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]. [Tween]s created manually (i.e. by using [code]Tween.new()[/code]) are invalid and can't be used for tweening values. A tween animation is created by adding [Tweener]s to the [Tween] object, using [method tween_property], [method tween_interval], [method tween_callback] or [method tween_method]: [codeblocks] [gdscript] var tween = get_tree().create_tween() tween.tween_property($Sprite, "modulate", Color.RED, 1) tween.tween_property($Sprite, "scale", Vector2(), 1) tween.tween_callback($Sprite.queue_free) [/gdscript] [csharp] Tween tween = GetTree().CreateTween(); tween.TweenProperty(GetNode("Sprite"), "modulate", Colors.Red, 1.0f); tween.TweenProperty(GetNode("Sprite"), "scale", Vector2.Zero, 1.0f); tween.TweenCallback(Callable.From(GetNode("Sprite").QueueFree)); [/csharp] [/codeblocks] This sequence will make the [code]$Sprite[/code] node turn red, then shrink, before finally calling [method Node.queue_free] to free the sprite. [Tweener]s are executed one after another by default. This behavior can be changed using [method parallel] and [method set_parallel]. When a [Tweener] is created with one of the [code]tween_*[/code] methods, a chained method call can be used to tweak the properties of this [Tweener]. For example, if you want to set a different transition type in the above example, you can use [method set_trans]: [codeblocks] [gdscript] var tween = get_tree().create_tween() tween.tween_property($Sprite, "modulate", Color.RED, 1).set_trans(Tween.TRANS_SINE) tween.tween_property($Sprite, "scale", Vector2(), 1).set_trans(Tween.TRANS_BOUNCE) tween.tween_callback($Sprite.queue_free) [/gdscript] [csharp] Tween tween = GetTree().CreateTween(); tween.TweenProperty(GetNode("Sprite"), "modulate", Colors.Red, 1.0f).SetTrans(Tween.TransitionType.Sine); tween.TweenProperty(GetNode("Sprite"), "scale", Vector2.Zero, 1.0f).SetTrans(Tween.TransitionType.Bounce); tween.TweenCallback(Callable.From(GetNode("Sprite").QueueFree)); [/csharp] [/codeblocks] 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 [Tweener]s: [codeblocks] [gdscript] var tween = get_tree().create_tween().bind_node(self).set_trans(Tween.TRANS_ELASTIC) tween.tween_property($Sprite, "modulate", Color.RED, 1) tween.tween_property($Sprite, "scale", Vector2(), 1) tween.tween_callback($Sprite.queue_free) [/gdscript] [csharp] var tween = GetTree().CreateTween().BindNode(this).SetTrans(Tween.TransitionType.Elastic); tween.TweenProperty(GetNode("Sprite"), "modulate", Colors.Red, 1.0f); tween.TweenProperty(GetNode("Sprite"), "scale", Vector2.Zero, 1.0f); tween.TweenCallback(Callable.From(GetNode("Sprite").QueueFree)); [/csharp] [/codeblocks] Another interesting use for [Tween]s is animating arbitrary sets of objects: [codeblocks] [gdscript] var tween = create_tween() for sprite in get_children(): 

tween.tween_property(sprite, "position", Vector2(0, 0), 1)

[/gdscript] [csharp] Tween tween = CreateTween(); foreach (Node sprite in GetChildren()) 

tween.TweenProperty(sprite, "position", Vector2.Zero, 1.0f);

[/csharp] [/codeblocks] In the example above, all children of a node are moved one after another to position (0, 0). 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: [codeblocks] [gdscript] var tween func animate(): 

if tween:
    tween.kill() # Abort the previous animation.
tween = create_tween()

[/gdscript] [csharp] private Tween _tween;

public void Animate() 

{
    if (_tween != null)
        _tween.Kill(); // Abort the previous animation
    _tween = CreateTween();
}

[/csharp] [/codeblocks] Some [Tweener]s use transitions and eases. The first accepts a [enum 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 [enum EaseType] constant, and controls where the [code]trans_type[/code] is applied to the interpolation (in the beginning, the end, or both). If you don't know which transition and easing to pick, you can try different [enum TransitionType] constants with [constant EASE_IN_OUT], and use the one that looks best. [url=https://raw.githubusercontent.com/godotengine/godot-docs/master/img/tween_cheatsheet.webp]Tween easing and transition types cheatsheet[/url] [b]Note:[/b] 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. [b]Note:[/b] 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 [method set_process_mode]). 

var Nil Instance

Nil is a nil/null instance of the class. Equivalent to the zero value.

func New 

func New() Instance

func (Instance) AsObject 

func (self Instance) AsObject() [1]gd.Object

func (Instance) AsRefCounted 

func (self Instance) AsRefCounted() [1]gd.RefCounted

func (Instance) AsTween 

func (self Instance) AsTween() Instance

func (Instance) Chain 

func (self Instance) Chain() Instance

Used to chain two [Tweener]s after [method set_parallel] is called with [code]true[/code]. [codeblocks] [gdscript] var tween = create_tween().set_parallel(true) tween.tween_property(...) tween.tween_property(...) # Will run parallelly with above. tween.chain().tween_property(...) # Will run after two above are finished. [/gdscript] [csharp] Tween tween = CreateTween().SetParallel(true); tween.TweenProperty(...); tween.TweenProperty(...); // Will run parallelly with above. tween.Chain().TweenProperty(...); // Will run after two above are finished. [/csharp] [/codeblocks]

func (Instance) CustomStep 

func (self Instance) CustomStep(delta Float.X) bool

Processes the [Tween] by the given [param delta] value, in seconds. This is mostly useful for manual control when the [Tween] is paused. It can also be used to end the [Tween] animation immediately, by setting [param delta] longer than the whole duration of the [Tween] animation. Returns [code]true[/code] if the [Tween] still has [Tweener]s that haven't finished.

func (Instance) GetLoopsLeft 

func (self Instance) GetLoopsLeft() int

Returns the number of remaining loops for this [Tween] (see [method set_loops]). A return value of [code]-1[/code] indicates an infinitely looping [Tween], and a return value of [code]0[/code] indicates that the [Tween] has already finished.

func (Instance) GetTotalElapsedTime 

func (self Instance) GetTotalElapsedTime() Float.X

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 [method set_speed_scale], and [method stop] will reset it to [code]0[/code]. [b]Note:[/b] As it results from accumulating frame deltas, the time returned after the [Tween] has finished animating will be slightly greater than the actual [Tween] duration.

func (Instance) ID 

func (self Instance) ID() ID

func (Instance) IsRunning 

func (self Instance) IsRunning() bool

Returns whether the [Tween] is currently running, i.e. it wasn't paused and it's not finished.

func (Instance) IsValid 

func (self Instance) IsValid() bool

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 [code]Tween.new()[/code]. Invalid [Tween]s can't have [Tweener]s appended.

func (Instance) Kill 

func (self Instance) Kill()

Aborts all tweening operations and invalidates the [Tween].

func (Instance) OnFinished 

func (self Instance) OnFinished(cb func(), flags ...Signal.Flags)

func (Instance) OnLoopFinished 

func (self Instance) OnLoopFinished(cb func(loop_count int), flags ...Signal.Flags)

func (Instance) OnStepFinished 

func (self Instance) OnStepFinished(cb func(idx int), flags ...Signal.Flags)

func (Instance) Parallel 

func (self Instance) Parallel() Instance

Makes the next [Tweener] run parallelly to the previous one. [codeblocks] [gdscript] var tween = create_tween() tween.tween_property(...) tween.parallel().tween_property(...) tween.parallel().tween_property(...) [/gdscript] [csharp] Tween tween = CreateTween(); tween.TweenProperty(...); tween.Parallel().TweenProperty(...); tween.Parallel().TweenProperty(...); [/csharp] [/codeblocks] All [Tweener]s in the example will run at the same time. You can make the [Tween] parallel by default by using [method set_parallel].

func (Instance) Pause 

func (self Instance) Pause()

Pauses the tweening. The animation can be resumed by using [method play]. [b]Note:[/b] 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].

func (Instance) Play 

func (self Instance) Play()

Resumes a paused or stopped [Tween].

func (Instance) SetEase 

func (self Instance) SetEase(ease EaseType) Instance

Sets the default ease type for [PropertyTweener]s and [MethodTweener]s appended after this method. Before this method is called, the default ease type is [constant EASE_IN_OUT]. [codeblock] var tween = create_tween() tween.tween_property(self, "position", Vector2(300, 0), 0.5) # Uses EASE_IN_OUT. tween.set_ease(Tween.EASE_IN) tween.tween_property(self, "rotation_degrees", 45.0, 0.5) # Uses EASE_IN. [/codeblock]

func (Instance) SetIgnoreTimeScale 

func (self Instance) SetIgnoreTimeScale() Instance

If [param ignore] is [code]true[/code], the tween will ignore [member Engine.time_scale] and update with the real, elapsed time. This affects all [Tweener]s and their delays. Default value is [code]false[/code].

func (Instance) SetLoops 

func (self Instance) SetLoops() Instance

Sets the number of times the tweening sequence will be repeated, i.e. [code]set_loops(2)[/code] will run the animation twice. Calling this method without arguments will make the [Tween] run infinitely, until either it is killed with [method kill], the [Tween]'s bound node is freed, or all the animated objects have been freed (which makes further animation impossible). [b]Warning:[/b] 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 [method bind_node].

func (*Instance) SetObject 

func (self *Instance) SetObject(obj [1]gd.Object) bool

func (Instance) SetParallel 

func (self Instance) SetParallel() Instance

If [param parallel] is [code]true[/code], the [Tweener]s appended after this method will by default run simultaneously, as opposed to sequentially. [b]Note:[/b] Just like with [method parallel], the tweener added right before this method will also be part of the parallel step. [codeblock] tween.tween_property(self, "position", Vector2(300, 0), 0.5) tween.set_parallel() tween.tween_property(self, "modulate", Color.GREEN, 0.5) # Runs together with the position tweener. [/codeblock]

func (Instance) SetPauseMode 

func (self Instance) SetPauseMode(mode TweenPauseMode) Instance

Determines the behavior of the [Tween] when the [SceneTree] is paused. Check [enum TweenPauseMode] for options. Default value is [constant TWEEN_PAUSE_BOUND].

func (Instance) SetProcessMode 

func (self Instance) SetProcessMode(mode TweenProcessMode) Instance

Determines whether the [Tween] should run after process frames (see [method Node._process]) or physics frames (see [method Node._physics_process]). Default value is [constant TWEEN_PROCESS_IDLE].

func (Instance) SetSpeedScale 

func (self Instance) SetSpeedScale(speed Float.X) Instance

Scales the speed of tweening. This affects all [Tweener]s and their delays.

func (Instance) SetTrans 

func (self Instance) SetTrans(trans TransitionType) Instance

Sets the default transition type for [PropertyTweener]s and [MethodTweener]s appended after this method. Before this method is called, the default transition type is [constant TRANS_LINEAR]. [codeblock] var tween = create_tween() tween.tween_property(self, "position", Vector2(300, 0), 0.5) # Uses TRANS_LINEAR. tween.set_trans(Tween.TRANS_SINE) tween.tween_property(self, "rotation_degrees", 45.0, 0.5) # Uses TRANS_SINE. [/codeblock]

func (Instance) Stop 

func (self Instance) Stop()

Stops the tweening and resets the [Tween] to its initial state. This will not remove any appended [Tweener]s. [b]Note:[/b] This does [i]not[/i] reset targets of [PropertyTweener]s to their values when the [Tween] first started. [codeblock] var tween = create_tween()

# Will move from 0 to 500 over 1 second. position.x = 0.0 tween.tween_property(self, "position:x", 500, 1.0)

# Will be at (about) 250 when the timer finishes. await get_tree().create_timer(0.5).timeout

# Will now move from (about) 250 to 500 over 1 second, # thus at half the speed as before. tween.stop() tween.play() [/codeblock] [b]Note:[/b] 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].

func (Instance) TweenCallback 

func (self Instance) TweenCallback(callback func()) CallbackTweener.Instance

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. [b]Example:[/b] Object that keeps shooting every 1 second: [codeblocks] [gdscript] var tween = get_tree().create_tween().set_loops() tween.tween_callback(shoot).set_delay(1) [/gdscript] [csharp] Tween tween = GetTree().CreateTween().SetLoops(); tween.TweenCallback(Callable.From(Shoot)).SetDelay(1.0f); [/csharp] [/codeblocks] [b]Example:[/b] Turning a sprite red and then blue, with 2 second delay: [codeblocks] [gdscript] var tween = get_tree().create_tween() tween.tween_callback($Sprite.set_modulate.bind(Color.RED)).set_delay(2) tween.tween_callback($Sprite.set_modulate.bind(Color.BLUE)).set_delay(2) [/gdscript] [csharp] Tween tween = GetTree().CreateTween(); Sprite2D sprite = GetNode<Sprite2D>("Sprite"); tween.TweenCallback(Callable.From(() => sprite.Modulate = Colors.Red)).SetDelay(2.0f); tween.TweenCallback(Callable.From(() => sprite.Modulate = Colors.Blue)).SetDelay(2.0f); [/csharp] [/codeblocks]

func (Instance) TweenInterval 

func (self Instance) TweenInterval(time Float.X) IntervalTweener.Instance

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 [Tweener]s, or when there's no animation (in which case the [Tween] acts as a timer). [param time] is the length of the interval, in seconds. [b]Example:[/b] Creating an interval in code execution: [codeblocks] [gdscript] # ... some code await create_tween().tween_interval(2).finished # ... more code [/gdscript] [csharp] // ... some code await ToSignal(CreateTween().TweenInterval(2.0f), Tween.SignalName.Finished); // ... more code [/csharp] [/codeblocks] [b]Example:[/b] Creating an object that moves back and forth and jumps every few seconds: [codeblocks] [gdscript] var tween = create_tween().set_loops() tween.tween_property($Sprite, "position:x", 200.0, 1).as_relative() tween.tween_callback(jump) tween.tween_interval(2) tween.tween_property($Sprite, "position:x", -200.0, 1).as_relative() tween.tween_callback(jump) tween.tween_interval(2) [/gdscript] [csharp] Tween tween = CreateTween().SetLoops(); tween.TweenProperty(GetNode("Sprite"), "position:x", 200.0f, 1.0f).AsRelative(); tween.TweenCallback(Callable.From(Jump)); tween.TweenInterval(2.0f); tween.TweenProperty(GetNode("Sprite"), "position:x", -200.0f, 1.0f).AsRelative(); tween.TweenCallback(Callable.From(Jump)); tween.TweenInterval(2.0f); [/csharp] [/codeblocks]

func (Instance) TweenSubtween 

func (self Instance) TweenSubtween(subtween Instance) SubtweenTweener.Instance

Creates and appends a [SubtweenTweener]. This method can be used to nest [param subtween] within this [Tween], allowing for the creation of more complex and composable sequences. [codeblock] # Subtween will rotate the object. var subtween = create_tween() subtween.tween_property(self, "rotation_degrees", 45.0, 1.0) subtween.tween_property(self, "rotation_degrees", 0.0, 1.0)

# Parent tween will execute the subtween as one of its steps. var tween = create_tween() tween.tween_property(self, "position:x", 500, 3.0) tween.tween_subtween(subtween) tween.tween_property(self, "position:x", 300, 2.0) [/codeblock] [b]Note:[/b] The methods [method pause], [method stop], and [method set_loops] can cause the parent [Tween] to get stuck on the subtween step; see the documentation for those methods for more information. [b]Note:[/b] The pause and process modes set by [method set_pause_mode] and [method set_process_mode] on [param subtween] will be overridden by the parent [Tween]'s settings.

func (*Instance) UnsafePointer 

func (self *Instance) UnsafePointer() unsafe.Pointer

func (Instance) Virtual 

func (self Instance) Virtual(name string) reflect.Value

type TransitionType 

type TransitionType int //gd:Tween.TransitionType

const (
	/*The animation is interpolated linearly.*/
	TransLinear TransitionType = 0
	/*The animation is interpolated using a sine function.*/
	TransSine TransitionType = 1
	/*The animation is interpolated with a quintic (to the power of 5) function.*/
	TransQuint TransitionType = 2
	/*The animation is interpolated with a quartic (to the power of 4) function.*/
	TransQuart TransitionType = 3
	/*The animation is interpolated with a quadratic (to the power of 2) function.*/
	TransQuad TransitionType = 4
	/*The animation is interpolated with an exponential (to the power of x) function.*/
	TransExpo TransitionType = 5
	/*The animation is interpolated with elasticity, wiggling around the edges.*/
	TransElastic TransitionType = 6
	/*The animation is interpolated with a cubic (to the power of 3) function.*/
	TransCubic TransitionType = 7
	/*The animation is interpolated with a function using square roots.*/
	TransCirc TransitionType = 8
	/*The animation is interpolated by bouncing at the end.*/
	TransBounce TransitionType = 9
	/*The animation is interpolated backing out at ends.*/
	TransBack TransitionType = 10
	/*The animation is interpolated like a spring towards the end.*/
	TransSpring TransitionType = 11
)

type TweenPauseMode 

type TweenPauseMode int //gd:Tween.TweenPauseMode

const (
	/*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 [constant TWEEN_PAUSE_STOP].*/
	TweenPauseBound TweenPauseMode = 0
	/*If [SceneTree] is paused, the [Tween] will also pause.*/
	TweenPauseStop TweenPauseMode = 1
	/*The [Tween] will process regardless of whether [SceneTree] is paused.*/
	TweenPauseProcess TweenPauseMode = 2
)

type TweenProcessMode 

type TweenProcessMode int //gd:Tween.TweenProcessMode

const (
	/*The [Tween] updates after each physics frame (see [method Node._physics_process]).*/
	TweenProcessPhysics TweenProcessMode = 0
	/*The [Tween] updates after each process frame (see [method Node._process]).*/
	TweenProcessIdle TweenProcessMode = 1
)

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.