ReTween is blazing fast, zero-garbage, modular, really simple and effective Tweening System for Unity.

So, let's use the Tween!

Tween position and color:

Tween.Position(transform, Vector3.right);
Tween.Color(someImage, Color.blue).SetDelay(0.5f);

So, it's pretty easy!

Tween position and color with functions, methods and custom delays, durations and easings:

Tween.Position(transform, new Vecor3(0, 5, 0), delay, duration);
Tween.Position(transform, position);
Tween.Position(transform, () => FindTarget());

Tween.Color(image, Color.blue, delay, 1.0f, Ease.InOut);
Tween.Color(image, Color.blue).SetDelay(0.5f).SetEase(EaseType.Linear);

Tween scale using custom chain of things called in sequence, one after one, with waiting:

Tween.Scale(transform, Vector3.one * 3f, 1f, 0f, anotherEase)
    .Next(Tween.Scale(transform, Vector3.one * 4f))
    .Next(Tween.Wait(3f))
    .Next(Tween.Scale(transform, Vector3.one * 2f, 1f, 0f, anotherEase))
        .SetDelay(5f));

Tweening fully asynchronous, where you can yield custom async function by them, and use it as enumerables:

yield return Tween.Scale(transform, Vector3.zero, 1f, 0f, scaleEase);
yield return Tween.Position(transform, Vector3.right * 3f, 1f, 0f, anotherEase);
yield return Tween.Wait(2f);
yield return Tween.Scale(transform, Vector3.one * 3f, 1f, 0f, anotherEase);

Tweening with custom cause of break, based on boolean expression and object existence check:

Break Point @ set if you want to finish tween on reaching some function:

Tween.Color(someImage, Color.blue)
    .SetBreakPoint(() => colorLoopActive && colorTarget == 1);

Tween.Position(transform, targetPosition)
    .SetBreakPoint(() => IsTweenActive());

Break Object @ set if you want to finish tween on destroy of target object:

Tween.Color(someImage, Color.blue)
    .SetBreakObject(parentObject);

ReTween supports custom [extensions, like predefined:

ReTween.Next()

Where you can define next custom Action and TweenAction.

ReTween.SetEase() - where you can define easing mode.

ReTween.SetDelay() - where you can define delay.

SetAction, SetDuration, SetStartTime, SetBreakPoint, SetBreakObject - and more.

You can create new ReModule by writing new script in ReTween/Modules that will assign new method by Tween.Add() and describe new Action<float>, where the float is easing time, from 0 to 1.

To follow the ReTween guidelines, you can write your new class as partial of the RwTween (by Tween.YourModule()).

Example: If we want to add a Color Lerp module for UI.Image, we need to write simple instruction:

public static void Color(Image image, Color target)
{
    Tween.Add(new TweenAction((float time) => image.color = UnityEngine.Color.LerpUnclamped(image.color, target, time)));
}

Obviously, you can create more complex Tweens. Basic TweenAction is built with pre-implemented values, like: duration, delay, easing, like:

public static void Color(Image image, Color target, float duration = 1f, float delay = 0f, Ease ease = null)
{
    Tween.Add(new TweenAction((float time) => image.color = UnityEngine.Color.LerpUnclamped(image.color, target, time), duration, delay, ease));
}

Now to tween the UI Image color, you can write in your code:

Tween.Color(someImage, Color.blue, 0.5f, 2f);

Easings are some sort of simple curves, that helps to visualise and evaluate smooth and juicy, animations. You can use some of the predefined curves or create own.

Easing Examples:

Ease is fully compatible and swapable with Unity AnimationCurves - which with you may be already familiar. In every field you have used AnimationCurve, you can use Ease as the replacement, without changing the implementation. The most important difference is that Eases has many predefined, basic values - a bank of custom definition - they are completely garbage-free and made with optimisation in-mind.

ReTween provides implementation of 30 high-performance math patterns for easing types:

    Linear = 0,
    QuadIn = 1,
    QuadOut = 2,
    QuadInOut = 3,
    CubicIn = 4,
    CubicOut = 5,
    CubicInOut = 6,
    QuartIn = 7,
    QuartOut = 8,
    QuartInOut = 9,
    QuintIn = 10,
    QuintOut = 11,
    QuintInOut = 12,
    BounceIn = 13,
    BounceOut = 14,
    BounceInOut = 15,
    ElasticIn = 16,
    ElasticOut = 17,
    ElasticInOut = 18,
    SlowElasticIn  =  19,
    CircularIn  =  20,
    CircularOut  =  21,
    CircularInOut  =  22,
    SinusIn  =  23,
    SinusOut  =  24,
    SinusInOut  =  25,
    ExponentialIn  =  26,
    ExponentialOut  =  27,
    ExponentialInOut  =  28,|
    BackwardIn  =  29,
    BackwardOut  =  30,
    BackwardInOut  =  31,
    BackwardInOutHalf  =  32,

You can cuse predefined or custom Ease Tweening Curve, and expose it in editor, by declaring:

[SerializeField] Ease customEase;

Now you have ecess to exposed Ease definition, which you can use in any Tween:

Ease Drawer allows you to use - preview and selection:

If you select the last type - "Custom", you can declare your own Ease Curve, which can be used as Ease everywhere:

For example, by:

Tween.Scale(transform, Vector3.zero).SetEase(myEase);

EaseType, AnimationCurve, Ease

Ease SetEaseName<string>(value)
Ease GetCustom<string>(value)
Ease SetCustom<string>(value)

License: Copyright (c) 2023 - Przemysław Orłowski

MIT License

https://raw.githubusercontent.com/ovsky/ReTween/main/Assets/Lab7/LICENSE.txt