Documentation.md

January 14, 2026 · View on GitHub

Overview v2.0.0

TweenManager – Controls state switching and step updating for all Tween instances.

Tween – Controls the state and updates of all its TweenActions. It supports both sequential and concurrent execution modes. For example: Methods with the Append prefix add queue actions, while those with the Add prefix add concurrent actions.

Tween constructs a sequence timeline and fills it with various types of TweenActions to achieve the orderly execution of queue actions and concurrent actions.

TweenExtensions – Extends the functionality of Tween, demonstrating how to use existing interfaces to customize Tween's implementation.

TweenAction – Controls a group of TweenActionValues. These action values execute concurrently to drive the progressive realization of a complete action.

TweenActionExtensions – Extends the functionality of TweenAction. Since TweenAction needs to be bound to a Tween to execute, this extension provides a default binding to a Tween, allowing TweenAction to be executed directly.

TweenActionAPIExtensions – Extends the functionality of Unity Objects, enabling them to directly create and use TweenActions.

TweenAction can be created manually, but TweenActionAPIExtensions provides extensive property extensions for many Unity Objects, so typically manual creation is not required.

For example, for a Transform, you can directly call a series of methods prefixed with Action to create a TweenAction, similar to:

transform.ActionMoveX(float x, float duration)

TweenActionValue – Controls the initialization, start, and end of an object's property value, using easing functions to drive the value change.

TweenEase – Controls the routing and implementation of easing functions.

Tween and TweenAction, along with their extensions, all support chained calls to set various properties, such as: ease, isRelative, callback, etc.

The detailed structural relationships of the core MojoTween classes can be viewed in the Code Architecture.

Feature List

Below are the methods and functions of the core classes. Expanding each section reveals usage instructions and examples.

Tween
TweenExtensions
TweenAction
TweenActionExtensions
TweenActionAPIExtensions
TweenManager

Tween

Create Tween

static Tween Create(bool isRecyclable = true)

Creates a Tween.

If [isRecyclable] is true, the Tween will be automatically recycled upon completion — in this case, you don't need to keep a reference to a Tween for reuse, but can always create a new one.

If [isRecyclable] is false, the Tween requires calling SetRecyclable for manual recycling — in this case, the Tween can use Restart and Rewind.
```
// Will be automatically recycled
var tween = Tween.Create();
// Requires manual recycling
var tween = Tween.Create(false);
// Manual recycling method
tween.SetRecyclable(true);
```

static Tween PlayDelayCallback(float delay, Action Callback)

Creates a Tween that executes a delayed callback function.
```
Tween.PlayDelayCallback(1.0f, MyDelayCallbackAction);
```

Append

Tween Append(TweenAction action)

Appends a TweenAction to the action queue. The Tween will execute queue actions one after another.
```
Tween.Create()
     .Append(MyQueueTweenAction1)
     .Append(MyQueueTweenAction2)
     .Play();
```

Tween AppendInterval(float interval)

Appends a time interval to the action queue, creating a delay between two actions in the Tween queue.

Tween.Create()
     .AppendInterval(0.8f)
     .Append(MyQueueTweenAction1)
     .AppendInterval(1.5f)
     .Append(MyQueueTweenAction2)
     .Play();

Tween AppendCallback(Action Callback)

Appends a callback function to the action queue. When execution reaches this point in the queue, the callback function will be executed.

Tween.Create()
     .AppendInterval(0.8f)
     .AppendCallback(MyQueueCallbackAction1)
     .AppendInterval(1.5f)
     .AppendCallback(MyQueueCallbackAction2)
     .Play();

Tween AppendIntervalCallback(float interval, Action Callback)

Appends a callback function with a time interval to the action queue. The queue will execute the callback after the specified delay.
```
Tween.Create()
     .Append(MyQueueTweenAction1)
     .AppendIntervalCallback(0.7f, MyQueueCallbackAction2)
     .Play();
```

Add

Tween Add(TweenAction action)

Adds a TweenAction to the concurrent actions of the Tween. These actions will execute simultaneously.
```
Tween.Create()
     .Add(MyConcurrentTweenAction1)
     .Add(MyConcurrentTweenAction2)
     .Play();
```

Add Delay

Tween AddDelay(float delay, TweenAction action)

Adds a delayed TweenAction to the concurrent actions. This action will start after a specified delay.

Tween.Create()
     .AddDelay(0.0f, MyConcurrentTweenAction1)
     .AddDelay(0.2f, MyConcurrentTweenAction2)
     .AddDelay(0.4f, MyConcurrentTweenAction3)
     .Play();

Tween AddDelayAfterAppend(float delay, TweenAction action)

Adds a delayed TweenAction to the concurrent actions. Its execution order is after the last Append action.
```
Tween.Create()
     .Append(MyQueueTweenAction1)
     .AddDelayAfterAppend(0.2f, MyConcurrentTweenAction1)
     .Play();
```

Tween AddDelayAfterAdd(float delay, TweenAction action)

Adds a delayed TweenAction to the concurrent actions. Its execution order is after the last Add action.
```
Tween.Create()
     .Add(MyConcurrentTweenAction1)
     .AddDelayAfterAdd(0.2f, MyConcurrentTweenAction2)
     .Play();
```

Add After

Tween AddAfterAppend(TweenAction action)

Adds a TweenAction to the concurrent actions. Its execution order is after the last Append action.
```
Tween.Create()
     .Append(MyQueueTweenAction1)
     .AddAfterAppend(MyConcurrentTweenAction1)
     .Play();
```

Tween AddAfterAdd(TweenAction action)

Adds a TweenAction to the concurrent actions. Its execution order is after the last Add action.

Tween.Create()
     .Add(MyConcurrentTweenAction1)
     .AddAfterAdd(MyConcurrentTweenAction2)
     .AddAfterAdd(MyConcurrentTweenAction3)
     .Play();

Add Callback

Tween AddCallback(Action Callback)

Adds a callback function to the concurrent actions.

Tween.Create()
     .AddCallback(MyConcurrentCallbackAction1)
     .AddCallback(MyConcurrentCallbackAction2)
     .Play();

Tween AddCallbackAfterAppend(Action Callback)

Adds a callback function to the concurrent actions. Its execution order is after the last Append action.

Tween.Create()
     .AppendCallback(MyQueueCallbackAction1)
     .AddCallbackAfterAppend(MyConcurrentCallbackAction1)
     .AppendCallback(MyQueueCallbackAction2)
     .AddCallbackAfterAppend(MyConcurrentCallbackAction2)
     .Play();

Tween AddCallbackAfterAdd(Action Callback)

Adds a callback function to the concurrent actions. Its execution order is after the last Add action.

Tween.Create()
     .AddCallback(MyConcurrentCallbackAction1)
     .AddCallbackAfterAdd(MyConcurrentCallbackAction2)
     .AddCallbackAfterAdd(MyConcurrentCallbackAction3)
     .Play();

Add Delay Callback

Tween AddDelayCallback(float delay, Action Callback)

Adds a delayed callback function to the concurrent actions.

Tween.Create()
     .AddDelayCallback(1.0f, MyConcurrentCallbackAction1)
     .AddDelayCallback(2.8f, MyConcurrentCallbackAction2)
     .AddDelayCallback(3.0f, MyConcurrentCallbackAction3)
     .Play();

Tween AddDelayCallbackAfterAppend(float delay, Action Callback)

Adds a delayed callback function to the concurrent actions. Its execution order is after the last Append action.
```
Tween.Create()
     .Append(MyQueueTweenAction1)
     .AddDelayCallbackAfterAppend(1.0f, MyConcurrentCallbackAction1)
     .Play();
```

Tween AddDelayCallbackAfterAdd(float delay, Action Callback)

Adds a delayed callback function to the concurrent actions. Its execution order is after the last Add action.
```
Tween.Create()
     .Add(MyConcurrentTweenAction1)
     .AddDelayCallbackAfterAdd(1.0f, MyConcurrentCallbackAction1)
     .Play();
```

Tween On Callback

Tween SetOnStart(Action OnStart)

Sets the callback function for when the Tween starts. Called when both playing and rewinding start.
```
Tween.Create().SetOnStart(MyStartAction);
```

Tween SetOnUpdate(Action<float> OnUpdate)

Sets the callback function for when the Tween updates. Called when both playing and rewinding update. The callback parameter float ranges from [0.0f, 1.0f], corresponding to the Tween's progress from start to end.
```
Tween.Create().SetOnUpdate(MyUpdateAction);
```

Tween SetOnComplete(Action OnComplete)

Sets the callback function for when the Tween completes. Called when both playing and rewinding complete.
```
Tween.Create().SetOnComplete(MyCompleteAction);
```

Tween SetOnStop(Action OnStop)

Sets the callback function for when the Tween stops. Called when both playing and rewinding stop.
```
Tween.Create().SetOnStop(MyStopAction);
```

Tween SetOnRecycle(Action OnRecycle)

Sets the callback function for when the Tween is recycled. You can use this function to clear data bound to the Tween.
```
Tween.Create().SetOnRecycle(MyRecycleAction);
```

Set Default Properties

Tween SetDefaultEase(TweenEase ease)

Sets the default [ease] for TweenActions when they are added. Default is Smooth. Only TweenActions that have not already set their [ease] (i.e., not Smooth) will use the Tween's default.
```
Tween.Create().SetDefaultEase(TweenEase.ExponentialOut);
```

Tween SetDefaultRelative(bool isRelative)

Sets the default [isRelative] for TweenActions when they are added. Default is false. Only TweenActions that have not already set their [isRelative] (i.e., not false) will use the Tween's default.
```
Tween.Create().SetDefaultRelative(true);
```

Controls

Tween SetRecyclable(bool isRecyclable)

Sets whether the Tween is recyclable. If true, the Tween will be recycled directly when its state is Setup, Stopped, or Completed. Otherwise, it will be recycled after stopping or completion.

Tween Play()

Starts playing the Tween. If the Tween is rewinding, or was previously rewinding, it will reverse to playing. If the Tween has completed or stopped, it will restart playing.

Tween Rewind()

Starts rewinding the Tween. If the Tween is playing, or was previously playing, it will reverse to rewinding. If the Tween has completed or stopped, it will restart rewinding.

Tween Restart()

Restarts the Tween's play or rewind. If the Tween is playing, or was previously playing, it will restart playing. If the Tween is rewinding, or was previously rewinding, it will restart rewinding. If the Tween has completed, it will restart based on its previous state (play or rewind).

Tween GotoStart()

Directly jumps to the start of the Tween's play or rewind. The Tween's state remains unchanged, only its position changes.

Tween GotoEnd()

Directly jumps to the end of the Tween's play or rewind. The Tween enters the completed state.

Tween Reverse()

Reverses the Tween's running direction. If playing, switches to rewind; if rewinding, switches to play; if not running, reverses the previous play or rewind direction.

void Pause(bool isPause)

Pauses or resumes a playing or rewinding Tween.

Tween Stop()

Stops the Tween from running. If the Tween is recyclable, it will be recycled after stopping.

Test States

bool IsSetup()

Is the Tween's state Setup?

bool IsPlaying()

Is the Tween's state Playing?

bool IsRewinding()

Is the Tween's state Rewinding?

bool IsRunning()

Is the Tween's state Playing or Rewinding?

bool IsPaused()

Is the Tween's state Paused?

bool IsStopping()

Is the Tween's state Stopping?

bool IsCompleting()

Is the Tween's state Completing?

bool IsStopped()

Is the Tween's state Stopped?

bool IsStoppedDuringPlay()

Is the Tween's state Stopped during play?

bool IsStoppedDuringRewind()

Is the Tween's state Stopped during rewind?

bool IsCompleted()

Is the Tween's state Completed?

bool IsCompletedAfterPlay()

Is the Tween's state Completed after play?

bool IsCompletedAfterRewind()

Is the Tween's state Completed after rewind?

bool IsRecycled()

Is the Tween's state Recycled?

bool IsOPRestart()

Is the Tween's operation state Restart? This operation is instantaneous, involving only state switching and executing relevant callback functions. Therefore, you can use this check within those callbacks to determine the current operation state.

bool IsOPGotoStart()

Is the Tween's operation state GotoStart? This operation is instantaneous, involving only state switching and executing relevant callback functions. Therefore, you can use this check within those callbacks to determine the current operation state.

bool IsOPGotoEnd()

Is the Tween's operation state GotoEnd? This operation is instantaneous, involving only state switching and executing relevant callback functions. Therefore, you can use this check within those callbacks to determine the current operation state.

TweenExtensions

void TogglePause()

Toggles the Tween between playing/rewinding and pausing.

Tween SetOnStartForPlay(Action OnStartForPlay)

Sets the callback function for when the Tween starts playing.

Tween SetOnStartForRewind(Action OnStartForRewind)

Sets the callback function for when the Tween starts rewinding.

Tween SetOnStopForPlay(Action OnStopForPlay)

Sets the callback function for when the Tween stops playing.

Tween SetOnStopForRewind(Action OnStopForRewind)

Sets the callback function for when the Tween stops rewinding.

Tween SetOnCompleteForPlay(Action OnCompleteForPlay)

Sets the callback function for when the Tween completes playing.

Tween SetOnCompleteForRewind(Action OnCompleteForRewind)

Sets the callback function for when the Tween completes rewinding.

Tween SetLoops(int loops, bool isRewindToStart = false, Action OnCompleteAllLoops = null)

Sets the number of times the Tween repeats playback. Repeated calls will increase the playback and callback count.

[loops]: The number of loops. -1 means infinite loops. [isRewindToStart]: When a loop completes, whether to rewind to the start before playing again. If false, it will Restart directly. [OnCompleteAllLoops]: Callback function executed when all loops are complete.
```
tween.SetLoops(1)
     .SetLoops(2, true, () => tween.Rewind().SetOnComplete(() => tween.SetRecyclable(true)))
     .Play();
```

TweenAction

Create Action

static TweenAction CreateFloat(Func<float> OnGetTargetFloat, Action<float> OnSetTargetFloat, float finalValue, float duration)

Creates a TweenAction that tweens a target object's property value to a float value.
```
TweenAction.CreateFloat
(
    ()      => transform.position.x,
    (value) => transform.SetPositionX(value),
    toFloatX,
    duration
);
```

static TweenAction CreateVector2(OnGetTargetVector2 OnGetTargetVector2, OnSetTargetVector2 OnSetTargetVector2, in Vector2 finalValues, float duration)

Creates a TweenAction that tweens a target object's property value to a vector2 value.
```
TweenAction.CreateVector2
(
    (out Vector2 vector2) => vector2 = transform.position,
    (in  Vector2 vector2) => transform.SetPositionXY(vector2),
    toV2,
    duration
);
```

static TweenAction CreateVector3(OnGetTargetVector3 OnGetTargetVector3, OnSetTargetVector3 OnSetTargetVector3, in Vector3 finalValues, float duration)

Creates a TweenAction that tweens a target object's property value to a vector3 value.
```
TweenAction.CreateVector3
(
    (out Vector3 vector3) => vector3 = transform.position,
    (in  Vector3 vector3) => transform.position = vector3,
    toV3,
    duration
);
```

static TweenAction CreateVector4(OnGetTargetVector4 OnGetTargetVector4, OnSetTargetVector4 OnSetTargetVector4, in Vector4 finalValues, float duration)

Creates a TweenAction that tweens a target object's property value to a vector4 value.
```
TweenAction.CreateVector4
(
    (out Vector4 vector4) => vector4       = graphic.color,
    (in  Vector4 vector4) => graphic.color = vector4,
    toColor,
    duration
);
```

Action On Callback

TweenAction SetOnStart(Action OnStart)

Sets the callback function for when the TweenAction starts. Called when both playing and rewinding start.

TweenAction SetOnUpdate(Action<float> OnUpdate)

Sets the callback function for when the TweenAction updates. Called when both playing and rewinding update. The callback parameter float ranges from [0.0f, 1.0f], corresponding to the TweenAction's progress from start to end.

TweenAction SetOnComplete(Action OnComplete)

Sets the callback function for when the TweenAction completes. Called when both playing and rewinding complete.

Set Properties

TweenAction SetRelative(bool isRelative)

Sets the [isRelative] for all TweenActionValues. Default is false.

TweenAction SetRelativeAt(int index, bool isRelative)

Sets the [isRelative] for the TweenActionValue at position [index]. Default is false.

The prefix methods Vector2/Vector3/Vector4 for creating TweenAction correspond to containing 2/3/4 TweenActionValues. This allows you to set properties for a specific TweenActionValue.

TweenAction SetEase(TweenEase ease)

Sets the [ease] for all TweenActionValues. Default is Smooth.

TweenAction SetEaseAt(int index, TweenEase ease)

Sets the [ease] for the TweenActionValue at position [index]. Default is Smooth.

The prefix methods Vector2/Vector3/Vector4 for creating TweenAction correspond to containing 2/3/4 TweenActionValues. This allows you to set properties for a specific TweenActionValue.

TweenAction SetExtraParams(params float[] extraParams)

Sets a group of extra parameters [extraParams] for TweenEase to use.

TweenAction.CreateFloat(...)
           .SetRelative(true)
           .SetEase(TweenEase.ShakeX)
           .SetExtraParams(amplitude, speed);

TweenActionExtensions

Tween Play()

Plays the TweenAction. Creates a Tween to include the current action and returns this Tween.
```
audioSource.ActionVolumeTo(toValue, duration).Play();
```

Tween PlayDelay(float delay)

Plays a delayed TweenAction. Creates a Tween to include the current action and returns this Tween.

TweenActionAPIExtensions

Note: Overloads of the same method are combined into one, using / to separate overload parameters, and [] to wrap overloadable parameters. That is, [] contains parameters for different overloads separated by /.

Transform Move

TweenAction ActionMoveX/Y/Z([float x/float y/float z], float duration)

Creates a TweenAction that moves Transform position x to [x]. Creates a TweenAction that moves Transform position y to [y]. Creates a TweenAction that moves Transform position z to [z].

TweenAction ActionMoveXY([in Vector2 v2/float x, float y/Transform final], float duration)

Creates a TweenAction that moves Transform position xy to [v2]. Creates a TweenAction that moves Transform position xy to [xy]. Creates a TweenAction that moves Transform position xy to [final].

TweenAction ActionMoveXZ([in Vector2 v2/float x, float z/Transform final], float duration)

Creates a TweenAction that moves Transform position xz to [v2]. Creates a TweenAction that moves Transform position xz to [xz]. Creates a TweenAction that moves Transform position xz to [final].

TweenAction ActionMoveYZ([in Vector2 v2/float y, float z/Transform final], float duration)

Creates a TweenAction that moves Transform position yz to [v2]. Creates a TweenAction that moves Transform position yz to [yz]. Creates a TweenAction that moves Transform position yz to [final].

TweenAction ActionMove([in Vector3 v3/float x, float y, float z/Transform final], float duration)

Creates a TweenAction that moves Transform position to [v3]. Creates a TweenAction that moves Transform position to [xyz]. Creates a TweenAction that moves Transform position to [final].

Transform Local Move

TweenAction ActionLocalMoveX/Y/Z([float x/float y/float z], float duration)

Creates a TweenAction that moves Transform localPosition x to [x]. Creates a TweenAction that moves Transform localPosition y to [y]. Creates a TweenAction that moves Transform localPosition z to [z].

TweenAction ActionLocalMoveXY([in Vector2 v2/float x, float y/Transform final], float duration)

Creates a TweenAction that moves Transform localPosition xy to [v2]. Creates a TweenAction that moves Transform localPosition xy to [xy]. Creates a TweenAction that moves Transform localPosition xy to [final].

TweenAction ActionLocalMoveXZ([in Vector2 v2/float x, float z/Transform final], float duration)

Creates a TweenAction that moves Transform localPosition xz to [v2]. Creates a TweenAction that moves Transform localPosition xz to [xz]. Creates a TweenAction that moves Transform localPosition xz to [final].

TweenAction ActionLocalMoveYZ([in Vector2 v2/float y, float z/Transform final], float duration)

Creates a TweenAction that moves Transform localPosition yz to [v2]. Creates a TweenAction that moves Transform localPosition yz to [yz]. Creates a TweenAction that moves Transform localPosition yz to [final].

TweenAction ActionLocalMove([in Vector3 v3/float x, float y, float z/Transform final], float duration)

Creates a TweenAction that moves Transform localPosition to [v3]. Creates a TweenAction that moves Transform localPosition to [xyz]. Creates a TweenAction that moves Transform localPosition to [final].

Transform Scale

TweenAction ActionScaleX/Y/Z([float x/float y/float z], float duration)

Creates a TweenAction that scales Transform localScale x to [x]. Creates a TweenAction that scales Transform localScale y to [y]. Creates a TweenAction that scales Transform localScale z to [z].

TweenAction ActionScaleXY([in Vector2 v2/float x, float y/float value/Transform final], float duration)

Creates a TweenAction that scales Transform localScale xy to [v2]. Creates a TweenAction that scales Transform localScale xy to [xy]. Creates a TweenAction that scales Transform localScale xy to [value]. Creates a TweenAction that scales Transform localScale xy to [final].

TweenAction ActionScaleXZ([in Vector2 v2/float x, float z/float value/Transform final], float duration)

Creates a TweenAction that scales Transform localScale xz to [v2]. Creates a TweenAction that scales Transform localScale xz to [xz]. Creates a TweenAction that scales Transform localScale xz to [value]. Creates a TweenAction that scales Transform localScale xz to [final].

TweenAction ActionScaleYZ([in Vector2 v2/float y, float z/float value/Transform final], float duration)

Creates a TweenAction that scales Transform localScale yz to [v2]. Creates a TweenAction that scales Transform localScale yz to [yz]. Creates a TweenAction that scales Transform localScale yz to [value]. Creates a TweenAction that scales Transform localScale yz to [final].

TweenAction ActionScale([in Vector3 v3/float x, float y, float z/float value/Transform final], float duration)

Creates a TweenAction that scales Transform localScale to [v3]. Creates a TweenAction that scales Transform localScale to [xyz]. Creates a TweenAction that scales Transform localScale to [value]. Creates a TweenAction that scales Transform localScale to [final].

Transform Rotate

TweenAction ActionRotateX/Y/Z([float x/float y/float z], float duration)

Creates a TweenAction that rotates Transform eulerAngles x to [x]. Creates a TweenAction that rotates Transform eulerAngles y to [y]. Creates a TweenAction that rotates Transform eulerAngles z to [z].

TweenAction ActionRotateXY([in Vector2 v2/float x, float y/Transform final], float duration)

Creates a TweenAction that rotates Transform eulerAngles xy to [v2]. Creates a TweenAction that rotates Transform eulerAngles xy to [xy]. Creates a TweenAction that rotates Transform eulerAngles xy to [final].

TweenAction ActionRotateXZ([in Vector2 v2/float x, float z/Transform final], float duration)

Creates a TweenAction that rotates Transform eulerAngles xz to [v2]. Creates a TweenAction that rotates Transform eulerAngles xz to [xz]. Creates a TweenAction that rotates Transform eulerAngles xz to [final].

TweenAction ActionRotateYZ([in Vector2 v2/float y, float z/Transform final], float duration)

Creates a TweenAction that rotates Transform eulerAngles yz to [v2]. Creates a TweenAction that rotates Transform eulerAngles yz to [yz]. Creates a TweenAction that rotates Transform eulerAngles yz to [final].

TweenAction ActionRotate([in Vector3 v3/float x, float y, float z/Transform final], float duration)

Creates a TweenAction that rotates Transform eulerAngles to [v3]. Creates a TweenAction that rotates Transform eulerAngles to [xyz]. Creates a TweenAction that rotates Transform eulerAngles to [final].

Transform Local Rotate

TweenAction ActionLocalRotateX/Y/Z([float x/float y/float z], float duration)

Creates a TweenAction that rotates Transform localEulerAngles x to [x]. Creates a TweenAction that rotates Transform localEulerAngles y to [y]. Creates a TweenAction that rotates Transform localEulerAngles z to [z].

TweenAction ActionLocalRotateXY([in Vector2 v2/float x, float y/Transform final], float duration)

Creates a TweenAction that rotates Transform localEulerAngles xy to [v2]. Creates a TweenAction that rotates Transform localEulerAngles xy to [xy]. Creates a TweenAction that rotates Transform localEulerAngles xy to [final].

TweenAction ActionLocalRotateXZ([in Vector2 v2/float x, float z/Transform final], float duration)

Creates a TweenAction that rotates Transform localEulerAngles xz to [v2]. Creates a TweenAction that rotates Transform localEulerAngles xz to [xz]. Creates a TweenAction that rotates Transform localEulerAngles xz to [final].

TweenAction ActionLocalRotateYZ([in Vector2 v2/float y, float z/Transform final], float duration)

Creates a TweenAction that rotates Transform localEulerAngles yz to [v2]. Creates a TweenAction that rotates Transform localEulerAngles yz to [yz]. Creates a TweenAction that rotates Transform localEulerAngles yz to [final].

TweenAction ActionLocalRotate([in Vector3 v3/float x, float y, float z/Transform final], float duration)

Creates a TweenAction that rotates Transform localEulerAngles to [v3]. Creates a TweenAction that rotates Transform localEulerAngles to [xyz]. Creates a TweenAction that rotates Transform localEulerAngles to [final].

Transform Rotate And Move

TweenAction ActionMoveXYAndRotateZ([in Vector3 v3/in Vector2 v2, float z/float x, float y, float z/Transform final], float duration)

Creates a TweenAction that moves Transform position xy to [v3.xy] and rotates Transform eulerAngles z to [v3.z].

Creates a TweenAction that moves Transform position xy to [v2] and rotates Transform eulerAngles z to [z].

Creates a TweenAction that moves Transform position xy to [xy] and rotates Transform eulerAngles z to [z].

Creates a TweenAction that moves Transform position xy to [final] and rotates Transform eulerAngles z to [final].

Optimized using Transform's built-in methods GetPositionAndRotation and SetPositionAndRotation.

TweenAction ActionMoveAndRotate([in Vector3 position, in Vector3 eulerAngles/Transform final], float duration)

Creates a TweenAction that moves Transform position to [position] and rotates Transform eulerAngles to [eulerAngles].

Creates a TweenAction that moves Transform position to [final] and rotates Transform eulerAngles to [final].

Optimized using Transform's built-in methods GetPositionAndRotation and SetPositionAndRotation.

Transform Local Rotate And Move

TweenAction ActionLocalMoveXYAndRotateZ([in Vector3 v3/in Vector2 v2, float z/float x, float y, float z/Transform final], float duration)

Creates a TweenAction that moves Transform localPosition xy to [v3.xy] and rotates Transform localEulerAngles z to [v3.z].

Creates a TweenAction that moves Transform localPosition xy to [v2] and rotates Transform localEulerAngles z to [z].

Creates a TweenAction that moves Transform localPosition xy to [xy] and rotates Transform localEulerAngles z to [z].

Creates a TweenAction that moves Transform localPosition xy to [final] and rotates Transform localEulerAngles z to [final].

Optimized using Transform's built-in methods GetPositionAndRotation and SetPositionAndRotation.

TweenAction ActionLocalMoveAndRotate([in Vector3 localPosition, in Vector3 localEulerAngles/Transform final], float duration)

Creates a TweenAction that moves Transform localPosition to [localPosition] and rotates Transform localEulerAngles to [localEulerAngles].

Creates a TweenAction that moves Transform localPosition to [final] and rotates Transform localEulerAngles to [final].

Optimized using Transform's built-in methods GetPositionAndRotation and SetPositionAndRotation.

Transform Shake Position

TweenAction ActionShakePositionX/Y/Z(float amplitude, float speed, float duration)

Creates a TweenAction that shakes Transform position x based on [amplitude] and [speed]. Creates a TweenAction that shakes Transform position y based on [amplitude] and [speed]. Creates a TweenAction that shakes Transform position z based on [amplitude] and [speed].

Note: Do not modify the isRelative and TweenEase of the TweenAction, as the shake has fixed settings.

TweenAction ActionShakePositionXY/XZ/YZ(float amplitude, float speed, float duration)

Creates a TweenAction that shakes Transform position xy based on [amplitude] and [speed]. Creates a TweenAction that shakes Transform position xz based on [amplitude] and [speed]. Creates a TweenAction that shakes Transform position yz based on [amplitude] and [speed].

Note: Do not modify the isRelative and TweenEase of the TweenAction, as the shake has fixed settings.

TweenAction ActionShakePosition(float amplitude, float speed, float duration)

Creates a TweenAction that shakes Transform position based on [amplitude] and [speed].

Note: Do not modify the isRelative and TweenEase of the TweenAction, as the shake has fixed settings.

Transform Shake Scale

TweenAction ActionShakeScaleX/Y/Z(float amplitude, float speed, float duration)

Creates a TweenAction that shakes Transform scale x based on [amplitude] and [speed]. Creates a TweenAction that shakes Transform scale y based on [amplitude] and [speed]. Creates a TweenAction that shakes Transform scale z based on [amplitude] and [speed].

Note: Do not modify the isRelative and TweenEase of the TweenAction, as the shake has fixed settings.

TweenAction ActionShakeScaleXY/XZ/YZ(float amplitude, float speed, float duration)

Creates a TweenAction that shakes Transform scale xy based on [amplitude] and [speed]. Creates a TweenAction that shakes Transform scale xz based on [amplitude] and [speed]. Creates a TweenAction that shakes Transform scale yz based on [amplitude] and [speed].

Note: Do not modify the isRelative and TweenEase of the TweenAction, as the shake has fixed settings.

TweenAction ActionShakeScale(float amplitude, float speed, float duration)

Creates a TweenAction that shakes Transform scale based on [amplitude] and [speed].

Note: Do not modify the isRelative and TweenEase of the TweenAction, as the shake has fixed settings.

Transform Shake Rotation

TweenAction ActionShakeRotationX/Y/Z(float amplitude, float speed, float duration)

Creates a TweenAction that shakes Transform rotation x based on [amplitude] and [speed]. Creates a TweenAction that shakes Transform rotation y based on [amplitude] and [speed]. Creates a TweenAction that shakes Transform rotation z based on [amplitude] and [speed].

Note: Do not modify the isRelative and TweenEase of the TweenAction, as the shake has fixed settings.

TweenAction ActionShakeRotationXY/XZ/YZ(float amplitude, float speed, float duration)

Creates a TweenAction that shakes Transform rotation xy based on [amplitude] and [speed]. Creates a TweenAction that shakes Transform rotation xz based on [amplitude] and [speed]. Creates a TweenAction that shakes Transform rotation yz based on [amplitude] and [speed].

Note: Do not modify the isRelative and TweenEase of the TweenAction, as the shake has fixed settings.

TweenAction ActionShakeRotation(float amplitude, float speed, float duration)

Creates a TweenAction that shakes Transform rotation based on [amplitude] and [speed].

Note: Do not modify the isRelative and TweenEase of the TweenAction, as the shake has fixed settings.

Transform Bezier Quadratic Move

TweenAction ActionBezier2MoveXY( [in Vector2 v2/float x, float y/Transform final], [in Vector2 controlPos/float controlPosX, float controlPosY/Transform controlPos], float duration)

Creates a TweenAction that moves Transform position xy to [v2] using a Bezier2 control point [controlPosVector2].

Creates a TweenAction that moves Transform position xy to [xy] using a Bezier2 control point [controlPosXY].

Creates a TweenAction that moves Transform position xy to [final] using a Bezier2 control point [controlPosTransform].

Note: Do not modify the TweenEase of the TweenAction, as the Bezier curve has fixed settings.
```
transform.ActionBezier2MoveXY(toVector2,   controlPosVector2,        duration);
transform.ActionBezier2MoveXY(toX, toY,    controlPosX, controlPosY, duration);
transform.ActionBezier2MoveXY(toTransform, controlPosTransform,      duration);
```

TweenAction ActionBezier2MoveXZ( [in Vector2 v2/float x, float z/Transform final], [in Vector2 controlPos/float controlPosX, float controlPosZ/Transform controlPos], float duration)

Creates a TweenAction that moves Transform position xz to [v2] using a Bezier2 control point [controlPosVector2].

Creates a TweenAction that moves Transform position xz to [xz] using a Bezier2 control point [controlPosXZ].

Creates a TweenAction that moves Transform position xz to [final] using a Bezier2 control point [controlPosTransform].

Note: Do not modify the TweenEase of the TweenAction, as the Bezier curve has fixed settings.
```
transform.ActionBezier2MoveXZ(toVector2,   controlPosVector2,        duration);
transform.ActionBezier2MoveXZ(toX, toZ,    controlPosX, controlPosZ, duration);
transform.ActionBezier2MoveXZ(toTransform, controlPosTransform,      duration);
```

TweenAction ActionBezier2MoveYZ( [in Vector2 v2/float y, float z/Transform final], [in Vector2 controlPos/float controlPosY, float controlPosZ/Transform controlPos], float duration)

Creates a TweenAction that moves Transform position yz to [v2] using a Bezier2 control point [controlPosVector2].

Creates a TweenAction that moves Transform position yz to [yz] using a Bezier2 control point [controlPosYZ].

Creates a TweenAction that moves Transform position yz to [final] using a Bezier2 control point [controlPosTransform].

Note: Do not modify the TweenEase of the TweenAction, as the Bezier curve has fixed settings.
```
transform.ActionBezier2MoveYZ(toVector2,   controlPosVector2,        duration);
transform.ActionBezier2MoveYZ(toY, toZ,    controlPosY, controlPosZ, duration);
transform.ActionBezier2MoveYZ(toTransform, controlPosTransform,      duration);
```

TweenAction ActionBezier2Move( [in Vector3 v3/float x, float y, float z/Transform final], [in Vector3 controlPos/float controlPosX, float controlPosY, float controlPosZ/Transform controlPos], float duration)

Creates a TweenAction that moves Transform position to [v3] using a Bezier2 control point [controlPosVector3].

Creates a TweenAction that moves Transform position to [xyz] using a Bezier2 control point [controlPosXYZ].

Creates a TweenAction that moves Transform position to [final] using a Bezier2 control point [controlPosTransform].

Note: Do not modify the TweenEase of the TweenAction, as the Bezier curve has fixed settings.
```
transform.ActionBezier2Move(toVector3,     controlPosVector3,                     duration);
transform.ActionBezier2Move(toX, toY, toZ, controlPosX, controlPosY, controlPosZ, duration);
transform.ActionBezier2Move(toTransform,   controlPosTransform,                   duration);
```

Transform Bezier Quadratic Local Move

TweenAction ActionBezier2LocalMoveXY( [in Vector2 v2/float x, float y/Transform final], [in Vector2 controlPos/float controlPosX, float controlPosY/Transform controlPos], float duration)

Creates a TweenAction that moves Transform localPosition xy to [v2] using a Bezier2 control point [controlPosVector2].

Creates a TweenAction that moves Transform localPosition xy to [xy] using a Bezier2 control point [controlPosXY].

Creates a TweenAction that moves Transform localPosition xy to [final] using a Bezier2 control point [controlPosTransform].

Note: Do not modify the TweenEase of the TweenAction, as the Bezier curve has fixed settings.
```
transform.ActionBezier2LocalMoveXY(toVector2,   controlPosVector2,        duration);
transform.ActionBezier2LocalMoveXY(toX, toY,    controlPosX, controlPosY, duration);
transform.ActionBezier2LocalMoveXY(toTransform, controlPosTransform,      duration);
```

TweenAction ActionBezier2LocalMoveXZ( [in Vector2 v2/float x, float z/Transform final], [in Vector2 controlPos/float controlPosX, float controlPosZ/Transform controlPos], float duration)

Creates a TweenAction that moves Transform localPosition xz to [v2] using a Bezier2 control point [controlPosVector2].

Creates a TweenAction that moves Transform localPosition xz to [xz] using a Bezier2 control point [controlPosXZ].

Creates a TweenAction that moves Transform localPosition xz to [final] using a Bezier2 control point [controlPosTransform].

Note: Do not modify the TweenEase of the TweenAction, as the Bezier curve has fixed settings.
```
transform.ActionBezier2LocalMoveXZ(toVector2,   controlPosVector2,        duration);
transform.ActionBezier2LocalMoveXZ(toX, toZ,    controlPosX, controlPosZ, duration);
transform.ActionBezier2LocalMoveXZ(toTransform, controlPosTransform,      duration);
```

TweenAction ActionBezier2LocalMoveYZ( [in Vector2 v2/float y, float z/Transform final], [in Vector2 controlPos/float controlPosY, float controlPosZ/Transform controlPos], float duration)

Creates a TweenAction that moves Transform localPosition yz to [v2] using a Bezier2 control point [controlPosVector2].

Creates a TweenAction that moves Transform localPosition yz to [yz] using a Bezier2 control point [controlPosYZ].

Creates a TweenAction that moves Transform localPosition yz to [final] using a Bezier2 control point [controlPosTransform].

Note: Do not modify the TweenEase of the TweenAction, as the Bezier curve has fixed settings.
```
transform.ActionBezier2LocalMoveYZ(toVector2,   controlPosVector2,        duration);
transform.ActionBezier2LocalMoveYZ(toY, toZ,    controlPosY, controlPosZ, duration);
transform.ActionBezier2LocalMoveYZ(toTransform, controlPosTransform,      duration);
```

TweenAction ActionBezier2LocalMove( [in Vector3 v3/float x, float y, float z/Transform final], [in Vector3 controlPos/float controlPosX, float controlPosY, float controlPosZ/Transform controlPos], float duration)

Creates a TweenAction that moves Transform localPosition to [v3] using a Bezier2 control point [controlPosVector3].

Creates a TweenAction that moves Transform localPosition to [xyz] using a Bezier2 control point [controlPosXYZ].

Creates a TweenAction that moves Transform localPosition to [final] using a Bezier2 control point [controlPosTransform].

Note: Do not modify the TweenEase of the TweenAction, as the Bezier curve has fixed settings.
```
transform.ActionBezier2LocalMove(toVector3,     controlPosVector3,                     duration);
transform.ActionBezier2LocalMove(toX, toY, toZ, controlPosX, controlPosY, controlPosZ, duration);
transform.ActionBezier2LocalMove(toTransform,   controlPosTransform,                   duration);
```

Transform Bezier Cubic Move

TweenAction ActionBezier3MoveXY( [in Vector2 v2/float x, float y/Transform final], [in Vector2 controlPos1/float controlPos1X, float controlPos1Y/Transform controlPos1], [in Vector2 controlPos2/float controlPos2X, float controlPos2Y/Transform controlPos2], float duration)

Creates a TweenAction that moves Transform position xy to [v2] using Bezier3 control points [controlPos1Vector2] and [controlPos2Vector2].

Creates a TweenAction that moves Transform position xy to [xy] using Bezier3 control points [controlPos1XY] and [controlPos2XY].

Creates a TweenAction that moves Transform position xy to [final] using Bezier3 control points [controlPos1Transform] and [controlPos2Transform].

Note: Do not modify the TweenEase of the TweenAction, as the Bezier curve has fixed settings.
```
transform.ActionBezier3MoveXY(toVector2,   controlPos1Vector2,         controlPos2Vector2,         duration);
transform.ActionBezier3MoveXY(toX, toY,    controlPos1X, controlPos1Y, controlPos2X, controlPos2Y, duration);
transform.ActionBezier3MoveXY(toTransform, controlPos1Transform,       controlPos2Transform,       duration);
```

TweenAction ActionBezier3MoveXZ( [in Vector2 v2/float x, float z/Transform final], [in Vector2 controlPos1/float controlPos1X, float controlPos1Z/Transform controlPos1], [in Vector2 controlPos2/float controlPos2X, float controlPos2Z/Transform controlPos2], float duration)

Creates a TweenAction that moves Transform position xz to [v2] using Bezier3 control points [controlPos1Vector2] and [controlPos2Vector2].

Creates a TweenAction that moves Transform position xz to [xz] using Bezier3 control points [controlPos1XZ] and [controlPos2XZ].

Creates a TweenAction that moves Transform position xz to [final] using Bezier3 control points [controlPos1Transform] and [controlPos2Transform].

Note: Do not modify the TweenEase of the TweenAction, as the Bezier curve has fixed settings.
```
transform.ActionBezier3MoveXZ(toVector2,   controlPos1Vector2,         controlPos2Vector2,         duration);
transform.ActionBezier3MoveXZ(toX, toZ,    controlPos1X, controlPos1Z, controlPos2X, controlPos2Z, duration);
transform.ActionBezier3MoveXZ(toTransform, controlPos1Transform,       controlPos2Transform,       duration);
```

TweenAction ActionBezier3MoveYZ( [in Vector2 v2/float y, float z/Transform final], [in Vector2 controlPos1/float controlPos1Y, float controlPos1Z/Transform controlPos1], [in Vector2 controlPos2/float controlPos2Y, float controlPos2Z/Transform controlPos2], float duration)

Creates a TweenAction that moves Transform position yz to [v2] using Bezier3 control points [controlPos1Vector2] and [controlPos2Vector2].

Creates a TweenAction that moves Transform position yz to [yz] using Bezier3 control points [controlPos1YZ] and [controlPos2YZ].

Creates a TweenAction that moves Transform position yz to [final] using Bezier3 control points [controlPos1Transform] and [controlPos2Transform].

Note: Do not modify the TweenEase of the TweenAction, as the Bezier curve has fixed settings.
```
transform.ActionBezier3MoveYZ(toVector2,   controlPos1Vector2,         controlPos2Vector2,         duration);
transform.ActionBezier3MoveYZ(toY, toZ,    controlPos1Y, controlPos1Z, controlPos2Y, controlPos2Z, duration);
transform.ActionBezier3MoveYZ(toTransform, controlPos1Transform,       controlPos2Transform,       duration);
```

TweenAction ActionBezier3Move( [in Vector3 v3/float x, float y, float z/Transform final], [in Vector3 controlPos1/float controlPos1X, float controlPos1Y, float controlPos1Z/Transform controlPos1], [in Vector3 controlPos2/float controlPos2X, float controlPos2Y, float controlPos2Z/Transform controlPos2], float duration)

Creates a TweenAction that moves Transform position to [v3] using Bezier3 control points [controlPos1Vector3] and [controlPos2Vector3].

Creates a TweenAction that moves Transform position to [xyz] using Bezier3 control points [controlPos1XYZ] and [controlPos2XYZ].

Creates a TweenAction that moves Transform position to [final] using Bezier3 control points [controlPos1Transform] and [controlPos2Transform].

Note: Do not modify the TweenEase of the TweenAction, as the Bezier curve has fixed settings.
```
transform.ActionBezier3Move(toVector3,     controlPos1Vector3,                       controlPos2Vector3,                       duration);
transform.ActionBezier3Move(toX, toY, toZ, controlPos1X, controlPos1Y, controlPos1Z, controlPos2X, controlPos2Y, controlPos2Z, duration);
transform.ActionBezier3Move(toTransform,   controlPos1Transform,                     controlPos2Transform,                     duration);
```

Transform Bezier Cubic Local Move

TweenAction ActionBezier3LocalMoveXY( [in Vector2 v2/float x, float y/Transform final], [in Vector2 controlPos1/float controlPos1X, float controlPos1Y/Transform controlPos1], [in Vector2 controlPos2/float controlPos2X, float controlPos2Y/Transform controlPos2], float duration)

Creates a TweenAction that moves Transform localPosition xy to [v2] using Bezier3 control points [controlPos1Vector2] and [controlPos2Vector2].

Creates a TweenAction that moves Transform localPosition xy to [xy] using Bezier3 control points [controlPos1XY] and [controlPos2XY].

Creates a TweenAction that moves Transform localPosition xy to [final] using Bezier3 control points [controlPos1Transform] and [controlPos2Transform].

Note: Do not modify the TweenEase of the TweenAction, as the Bezier curve has fixed settings.
```
transform.ActionBezier3LocalMoveXY(toVector2,   controlPos1Vector2,         controlPos2Vector2,         duration);
transform.ActionBezier3LocalMoveXY(toX, toY,    controlPos1X, controlPos1Y, controlPos2X, controlPos2Y, duration);
transform.ActionBezier3LocalMoveXY(toTransform, controlPos1Transform,       controlPos2Transform,       duration);
```

TweenAction ActionBezier3LocalMoveXZ( [in Vector2 v2/float x, float z/Transform final], [in Vector2 controlPos1/float controlPos1X, float controlPos1Z/Transform controlPos1], [in Vector2 controlPos2/float controlPos2X, float controlPos2Z/Transform controlPos2], float duration)

Creates a TweenAction that moves Transform localPosition xz to [v2] using Bezier3 control points [controlPos1Vector2] and [controlPos2Vector2].

Creates a TweenAction that moves Transform localPosition xz to [xz] using Bezier3 control points [controlPos1XZ] and [controlPos2XZ].

Creates a TweenAction that moves Transform localPosition xz to [final] using Bezier3 control points [controlPos1Transform] and [controlPos2Transform].

Note: Do not modify the TweenEase of the TweenAction, as the Bezier curve has fixed settings.
```
transform.ActionBezier3LocalMoveXZ(toVector2,   controlPos1Vector2,         controlPos2Vector2,         duration);
transform.ActionBezier3LocalMoveXZ(toX, toZ,    controlPos1X, controlPos1Z, controlPos2X, controlPos2Z, duration);
transform.ActionBezier3LocalMoveXZ(toTransform, controlPos1Transform,       controlPos2Transform,       duration);
```

TweenAction ActionBezier3LocalMoveYZ( [in Vector2 v2/float y, float z/Transform final], [in Vector2 controlPos1/float controlPos1Y, float controlPos1Z/Transform controlPos1], [in Vector2 controlPos2/float controlPos2Y, float controlPos2Z/Transform controlPos2], float duration)

Creates a TweenAction that moves Transform localPosition yz to [v2] using Bezier3 control points [controlPos1Vector2] and [controlPos2Vector2].

Creates a TweenAction that moves Transform localPosition yz to [yz] using Bezier3 control points [controlPos1YZ] and [controlPos2YZ].

Creates a TweenAction that moves Transform localPosition yz to [final] using Bezier3 control points [controlPos1Transform] and [controlPos2Transform].

Note: Do not modify the TweenEase of the TweenAction, as the Bezier curve has fixed settings.
```
transform.ActionBezier3LocalMoveYZ(toVector2,   controlPos1Vector2,         controlPos2Vector2,         duration);
transform.ActionBezier3LocalMoveYZ(toY, toZ,    controlPos1Y, controlPos1Z, controlPos2Y, controlPos2Z, duration);
transform.ActionBezier3LocalMoveYZ(toTransform, controlPos1Transform,       controlPos2Transform,       duration);
```

TweenAction ActionBezier3LocalMove( [in Vector3 v3/float x, float y, float z/Transform final], [in Vector3 controlPos1/float controlPos1X, float controlPos1Y, float controlPos1Z/Transform controlPos1], [in Vector3 controlPos2/float controlPos2X, float controlPos2Y, float controlPos2Z/Transform controlPos2], float duration)

Creates a TweenAction that moves Transform localPosition to [v3] using Bezier3 control points [controlPos1Vector3] and [controlPos2Vector3].

Creates a TweenAction that moves Transform localPosition to [xyz] using Bezier3 control points [controlPos1XYZ] and [controlPos2XYZ].

Creates a TweenAction that moves Transform localPosition to [final] using Bezier3 control points [controlPos1Transform] and [controlPos2Transform].

Note: Do not modify the TweenEase of the TweenAction, as the Bezier curve has fixed settings.
```
transform.ActionBezier3LocalMove(toVector3,     controlPos1Vector3,                       controlPos2Vector3,                       duration);
transform.ActionBezier3LocalMove(toX, toY, toZ, controlPos1X, controlPos1Y, controlPos1Z, controlPos2X, controlPos2Y, controlPos2Z, duration);
transform.ActionBezier3LocalMove(toTransform,   controlPos1Transform,                     controlPos2Transform,                     duration);
```

RectTransform Move

TweenAction ActionMoveAnchoredX/Y/Z([float x/float y/float z], float duration)

Creates a TweenAction that moves RectTransform anchoredPosition x to [x]. Creates a TweenAction that moves RectTransform anchoredPosition y to [y]. Creates a TweenAction that moves RectTransform anchoredPosition3D z to [z].

TweenAction ActionMoveAnchoredXY([in Vector2 v2/float x, float y/RectTransform final], float duration)

Creates a TweenAction that moves RectTransform anchoredPosition xy to [v2]. Creates a TweenAction that moves RectTransform anchoredPosition xy to [xy]. Creates a TweenAction that moves RectTransform anchoredPosition xy to [final].

TweenAction ActionMoveAnchored([in Vector3 v3/float x, float y, float z/RectTransform final], float duration)

Creates a TweenAction that moves RectTransform anchoredPosition3D to [v3]. Creates a TweenAction that moves RectTransform anchoredPosition3D to [xyz]. Creates a TweenAction that moves RectTransform anchoredPosition3D to [final].

RectTransform OffsetMax

TweenAction ActionOffsetMaxX/Y([float x/float y], float duration)

Creates a TweenAction that changes RectTransform offsetMax x to [x]. Creates a TweenAction that changes RectTransform offsetMax y to [y].

TweenAction ActionOffsetMax([in Vector2 v2/float x, float y/RectTransform final], float duration)

Creates a TweenAction that changes RectTransform offsetMax to [v2]. Creates a TweenAction that changes RectTransform offsetMax to [xy]. Creates a TweenAction that changes RectTransform offsetMax to [final].

RectTransform OffsetMin

TweenAction ActionOffsetMinX/Y([float x/float y], float duration)

Creates a TweenAction that changes RectTransform offsetMin x to [x]. Creates a TweenAction that changes RectTransform offsetMin y to [y].

TweenAction ActionOffsetMin([in Vector2 v2/float x, float y/RectTransform final], float duration)

Creates a TweenAction that changes RectTransform offsetMin to [v2]. Creates a TweenAction that changes RectTransform offsetMin to [xy]. Creates a TweenAction that changes RectTransform offsetMin to [final].

RectTransform SizeDelta

TweenAction ActionSizeDeltaX/Y([float x/float y], float duration)

Creates a TweenAction that changes RectTransform sizeDelta x to [x]. Creates a TweenAction that changes RectTransform sizeDelta y to [y].

TweenAction ActionSizeDelta([in Vector2 v2/float x, float y/RectTransform final], float duration)

Creates a TweenAction that changes RectTransform sizeDelta to [v2]. Creates a TweenAction that changes RectTransform sizeDelta to [xy]. Creates a TweenAction that changes RectTransform sizeDelta to [final].

RectTransform Size

TweenAction ActionSizeX/Y([float x/float y], float duration)

Creates a TweenAction that changes RectTransform size x to [x]. Creates a TweenAction that changes RectTransform size y to [y].

TweenAction ActionSize([in Vector2 v2/float x, float y/RectTransform final], float duration)

Creates a TweenAction that changes RectTransform size to [v2]. Creates a TweenAction that changes RectTransform size to [xy]. Creates a TweenAction that changes RectTransform size to [final].

Graphic Color

TweenAction ActionFadeTo(float alpha, float duration)

Creates a TweenAction that fades Graphic color alpha to [alpha].

TweenAction ActionFadeIn/Out(float duration)

Creates a TweenAction that fades in Graphic color alpha to [1.0f]. Creates a TweenAction that fades out Graphic color alpha to [0.0f].

TweenAction ActionColorTo(in Color color, float duration)

Creates a TweenAction that tweens Graphic color to [color].

TweenAction ActionRGBTo(in Color color/ in Vector3 rgb, float duration)

Creates a TweenAction that tweens Graphic color rgb to [color]. Creates a TweenAction that tweens Graphic color rgb to [rgb].

CanvasGroup Color

TweenAction ActionFadeTo(float alpha, float duration)

Creates a TweenAction that fades CanvasGroup color alpha to [alpha].

TweenAction ActionFadeIn/Out(float duration)

Creates a TweenAction that fades in CanvasGroup color alpha to [1.0f]. Creates a TweenAction that fades out CanvasGroup color alpha to [0.0f].

CanvasRenderer Color

TweenAction ActionFadeTo(float alpha, float duration)

Creates a TweenAction that fades CanvasRenderer color alpha to [alpha].

TweenAction ActionFadeIn/Out(float duration)

Creates a TweenAction that fades in CanvasRenderer color alpha to [1.0f]. Creates a TweenAction that fades out CanvasRenderer color alpha to [0.0f].

TweenAction ActionColorTo(in Color color, float duration)

Creates a TweenAction that tweens CanvasRenderer color to [color].

TweenAction ActionRGBTo(in Color color/in Vector3 rgb, float duration)

Creates a TweenAction that tweens CanvasRenderer color rgb to [color]. Creates a TweenAction that tweens CanvasRenderer color rgb to [rgb].

SpriteRenderer Color

TweenAction ActionFadeTo(float alpha, float duration)

Creates a TweenAction that fades SpriteRenderer color alpha to [alpha].

TweenAction ActionFadeIn/Out(float duration)

Creates a TweenAction that fades in SpriteRenderer color alpha to [1.0f]. Creates a TweenAction that fades out SpriteRenderer color alpha to [0.0f].

TweenAction ActionColorTo(in Color color, float duration)

Creates a TweenAction that tweens SpriteRenderer color to [color].

TweenAction ActionRGBTo(in Color color/in Vector3 rgb, float duration)

Creates a TweenAction that tweens SpriteRenderer color rgb to [color]. Creates a TweenAction that tweens SpriteRenderer color rgb to [rgb].

AudioSource Volume

TweenAction ActionVolumeTo(float volume, float duration)

Creates a TweenAction that changes AudioSource volume to [volume].

TweenAction ActionVolumeIn/Out(float duration)

Creates a TweenAction that changes AudioSource volume to [1.0f]. Creates a TweenAction that changes AudioSource volume to [0.0f].

Material Values

TweenAction ActionFloatTo(string name, float value, float duration)

Creates a TweenAction that changes the float property named [name] of a Material to [value].

TweenAction ActionIntTo(string name, int value, float duration)

Creates a TweenAction that changes the int property named [name] of a Material to [value].

TweenAction ActionVectorTo(string name, in Vector4 v4, float duration)

Creates a TweenAction that changes the vector property named [name] of a Material to [v4].

TweenAction ActionColorTo(string name, in Color color, float duration)

Creates a TweenAction that changes the color property named [name] of a Material to [color].

Scrollbar Value

TweenAction ActionValueTo(float value, float duration)

Creates a TweenAction that changes Scrollbar value to [value].

TweenManager

static bool IsAnyUpdating()

Is any Tween currently updating?

static void PlayAll()

Plays all updating Tweens, except those that have stopped or completed and are about to be automatically recycled. Note: If a Tween is currently or was previously rewinding, it will be reversed.

static void RewindAll()

Rewinds all updating Tweens, except those that have stopped or completed and are about to be automatically recycled.

static void RestartAll()

Restarts all updating Tweens, except those that have stopped or completed and are about to be automatically recycled.

static void ReverseAll()

Reverses all updating Tweens, except those that have stopped or completed and are about to be automatically recycled.

static void PauseAll(bool isPause)

Pauses or resumes all updating Tweens.

static void TogglePauseAll()

Toggles pause/resume for all updating Tweens.

static void StopAll()

Stops all updating Tweens, except those in Setup, Stopping, Stopped, Completing, or Completed states. Note: If a Tween is recyclable, it will be recycled after stopping.

static void SetRecyclableAll(bool isRecyclable)

Sets whether all updating Tweens are recyclable.

static void RecycleAll()

Stops all updating Tweens and recycles all unrecycled Tweens.

static void Update()

Updates all updating Tweens. Must be called every frame.

static void DisposeAllNativeData()

Disposes of all native data. Must be called when the application exits. If native data is not disposed, it will cause editor errors upon application exit.