mirror/godot
2
0
Fork 0
mirror of https://github.com/godotengine/godot.git synced 2024-12-15 10:12:40 +08:00
Code Issues Packages Projects Releases Wiki Activity
89eb6d372d
godot/doc/classes/PropertyTweener.xml

67 lines
2.9 KiB
XML
Raw Normal View History

Complete rewrite of Tweens * Tweens were changed from Node to RefCounted. New API is inspired by DOTween. * Tweens are created and managed by SceneTree, similar to SceneTreeTimer, which makes them ultra cheap to use a lot. * Animating with Tweens is done by creating sequences of Tweeners. You create them from code and they autostart by default (fire-and-forget). * There are 4 Tweeners that cover the former Tween functionality: PropertyTweener, IntervalTweener, CallbackTweener and MethodTweener. * The methods were simplified a lot. Long argument lists are replaced with chained calls on Tweens and Tweeners. * Tweeners by default execute in sequence, so it's easy to create complex chained animations. * You can bind a Tween to a node. Tween will be removed automatically when the bound node is freed.
2020-09-05 09:05:30 +08:00
<?xml version="1.0" encoding="UTF-8" ?>
<class name="PropertyTweener" inherits="Tweener" version="4.0">
<brief_description>
Interpolates an [Object]'s property over time.
</brief_description>
<description>
[PropertyTweener] is used to interpolate a property in an object. See [method Tween.tween_property] for more usage information.
[b]Note:[/b] [method Tween.tween_property] is the only correct way to create [PropertyTweener]. Any [PropertyTweener] created manually will not function correctly.
</description>
<tutorials>
</tutorials>
<methods>
<method name="as_relative">
doc: Use self-closing tags for `return` and `argument` For the time being we don't support writing a description for those, preferring having all details in the method's description. Using self-closing tags saves half the lines, and prevents contributors from thinking that they should write the argument or return documentation there.
2021-07-30 21:28:05 +08:00
<return type="PropertyTweener" />
Complete rewrite of Tweens * Tweens were changed from Node to RefCounted. New API is inspired by DOTween. * Tweens are created and managed by SceneTree, similar to SceneTreeTimer, which makes them ultra cheap to use a lot. * Animating with Tweens is done by creating sequences of Tweeners. You create them from code and they autostart by default (fire-and-forget). * There are 4 Tweeners that cover the former Tween functionality: PropertyTweener, IntervalTweener, CallbackTweener and MethodTweener. * The methods were simplified a lot. Long argument lists are replaced with chained calls on Tweens and Tweeners. * Tweeners by default execute in sequence, so it's easy to create complex chained animations. * You can bind a Tween to a node. Tween will be removed automatically when the bound node is freed.
2020-09-05 09:05:30 +08:00
<description>
When called, the final value will be used as a relative value instead. Example:
[codeblock]
var tween = get_tree().create_tween()
tween.tween_property(self, "position", Vector2.RIGHT * 100, 1).as_relative() #the node will move by 100 pixels to the right
[/codeblock]
</description>
</method>
<method name="from">
doc: Use self-closing tags for `return` and `argument` For the time being we don't support writing a description for those, preferring having all details in the method's description. Using self-closing tags saves half the lines, and prevents contributors from thinking that they should write the argument or return documentation there.
2021-07-30 21:28:05 +08:00
<return type="PropertyTweener" />
<argument index="0" name="value" type="Variant" />
Complete rewrite of Tweens * Tweens were changed from Node to RefCounted. New API is inspired by DOTween. * Tweens are created and managed by SceneTree, similar to SceneTreeTimer, which makes them ultra cheap to use a lot. * Animating with Tweens is done by creating sequences of Tweeners. You create them from code and they autostart by default (fire-and-forget). * There are 4 Tweeners that cover the former Tween functionality: PropertyTweener, IntervalTweener, CallbackTweener and MethodTweener. * The methods were simplified a lot. Long argument lists are replaced with chained calls on Tweens and Tweeners. * Tweeners by default execute in sequence, so it's easy to create complex chained animations. * You can bind a Tween to a node. Tween will be removed automatically when the bound node is freed.
2020-09-05 09:05:30 +08:00
<description>
Sets a custom initial value to the [PropertyTweener]. Example:
[codeblock]
var tween = get_tree().create_tween()
tween.tween_property(self, "position", Vector2(200, 100), 1).from(Vector2(100, 100) #this will move the node from position (100, 100) to (200, 100)
[/codeblock]
</description>
</method>
<method name="from_current">
doc: Use self-closing tags for `return` and `argument` For the time being we don't support writing a description for those, preferring having all details in the method's description. Using self-closing tags saves half the lines, and prevents contributors from thinking that they should write the argument or return documentation there.
2021-07-30 21:28:05 +08:00
<return type="PropertyTweener" />
Complete rewrite of Tweens * Tweens were changed from Node to RefCounted. New API is inspired by DOTween. * Tweens are created and managed by SceneTree, similar to SceneTreeTimer, which makes them ultra cheap to use a lot. * Animating with Tweens is done by creating sequences of Tweeners. You create them from code and they autostart by default (fire-and-forget). * There are 4 Tweeners that cover the former Tween functionality: PropertyTweener, IntervalTweener, CallbackTweener and MethodTweener. * The methods were simplified a lot. Long argument lists are replaced with chained calls on Tweens and Tweeners. * Tweeners by default execute in sequence, so it's easy to create complex chained animations. * You can bind a Tween to a node. Tween will be removed automatically when the bound node is freed.
2020-09-05 09:05:30 +08:00
<description>
Makes the [PropertyTweener] use the current property value (i.e. at the time of creating this [PropertyTweener]) as a starting point. This is equivalent of using [method from] with the current value. These two calls will do the same:
[codeblock]
tween.tween_property(self, "position", Vector2(200, 100), 1).from(position)
tween.tween_property(self, "position", Vector2(200, 100), 1).from_current()
[/codeblock]
</description>
</method>
<method name="set_delay">
doc: Use self-closing tags for `return` and `argument` For the time being we don't support writing a description for those, preferring having all details in the method's description. Using self-closing tags saves half the lines, and prevents contributors from thinking that they should write the argument or return documentation there.
2021-07-30 21:28:05 +08:00
<return type="PropertyTweener" />
<argument index="0" name="delay" type="float" />
Complete rewrite of Tweens * Tweens were changed from Node to RefCounted. New API is inspired by DOTween. * Tweens are created and managed by SceneTree, similar to SceneTreeTimer, which makes them ultra cheap to use a lot. * Animating with Tweens is done by creating sequences of Tweeners. You create them from code and they autostart by default (fire-and-forget). * There are 4 Tweeners that cover the former Tween functionality: PropertyTweener, IntervalTweener, CallbackTweener and MethodTweener. * The methods were simplified a lot. Long argument lists are replaced with chained calls on Tweens and Tweeners. * Tweeners by default execute in sequence, so it's easy to create complex chained animations. * You can bind a Tween to a node. Tween will be removed automatically when the bound node is freed.
2020-09-05 09:05:30 +08:00
<description>
Sets the time in seconds after which the [PropertyTweener] will start interpolating. By default there's no delay.
</description>
</method>
<method name="set_ease">
doc: Use self-closing tags for `return` and `argument` For the time being we don't support writing a description for those, preferring having all details in the method's description. Using self-closing tags saves half the lines, and prevents contributors from thinking that they should write the argument or return documentation there.
2021-07-30 21:28:05 +08:00
<return type="PropertyTweener" />
<argument index="0" name="ease" type="int" enum="Tween.EaseType" />
Complete rewrite of Tweens * Tweens were changed from Node to RefCounted. New API is inspired by DOTween. * Tweens are created and managed by SceneTree, similar to SceneTreeTimer, which makes them ultra cheap to use a lot. * Animating with Tweens is done by creating sequences of Tweeners. You create them from code and they autostart by default (fire-and-forget). * There are 4 Tweeners that cover the former Tween functionality: PropertyTweener, IntervalTweener, CallbackTweener and MethodTweener. * The methods were simplified a lot. Long argument lists are replaced with chained calls on Tweens and Tweeners. * Tweeners by default execute in sequence, so it's easy to create complex chained animations. * You can bind a Tween to a node. Tween will be removed automatically when the bound node is freed.
2020-09-05 09:05:30 +08:00
<description>
Sets the type of used easing from [enum Tween.EaseType]. If not set, the default easing is used from the [Tween] that contains this Tweener.
</description>
</method>
<method name="set_trans">
doc: Use self-closing tags for `return` and `argument` For the time being we don't support writing a description for those, preferring having all details in the method's description. Using self-closing tags saves half the lines, and prevents contributors from thinking that they should write the argument or return documentation there.
2021-07-30 21:28:05 +08:00
<return type="PropertyTweener" />
<argument index="0" name="trans" type="int" enum="Tween.TransitionType" />
Complete rewrite of Tweens * Tweens were changed from Node to RefCounted. New API is inspired by DOTween. * Tweens are created and managed by SceneTree, similar to SceneTreeTimer, which makes them ultra cheap to use a lot. * Animating with Tweens is done by creating sequences of Tweeners. You create them from code and they autostart by default (fire-and-forget). * There are 4 Tweeners that cover the former Tween functionality: PropertyTweener, IntervalTweener, CallbackTweener and MethodTweener. * The methods were simplified a lot. Long argument lists are replaced with chained calls on Tweens and Tweeners. * Tweeners by default execute in sequence, so it's easy to create complex chained animations. * You can bind a Tween to a node. Tween will be removed automatically when the bound node is freed.
2020-09-05 09:05:30 +08:00
<description>
Sets the type of used transition from [enum Tween.TransitionType]. If not set, the default transition is used from the [Tween] that contains this Tweener.
</description>
</method>
</methods>
</class>
Reference in New Issue Copy Permalink