ReJUI/include/JUI/Tween.hpp

#pragma once

#include <functional>
#include "Event.h"

namespace JUI
{

    using EasingFunc = std::function<float(float)>;
    using TweenTickFunc = std::function<void(float, float)>;

    namespace EasingFunctions
    {

        float EaseInOutLinear(float t);

        /// Speed is determined by a sine wave for gentle easing motion.
        float EaseInSine(float t);
        /// Speed is determined by a sine wave for gentle easing motion.
        float EaseOutSine(float t);
        /// Speed is determined by a sine wave for gentle easing motion.
        float EaseInOutSine(float t);

        /// Similar to Sine but with a slightly sharper curve based on quadratic interpolation.
        float EaseInQuad(float t);
        /// Similar to Sine but with a slightly sharper curve based on quadratic interpolation.
        float EaseOutQuad(float t);
        /// Similar to Sine but with a slightly sharper curve based on quadratic interpolation.
        float EaseInOutQuad(float t);

        /// Similar to Quad but with a slightly sharper curve based on cubic interpolation.
        float EaseInCubic(float t);
        /// Similar to Quad but with a slightly sharper curve based on cubic interpolation.
        float EaseOutCubic(float t);
        /// Similar to Quad but with a slightly sharper curve based on cubic interpolation.
        float EaseInOutCubic(float t);

        /// Similar to Cubic but with an even sharper curve based on quartic interpolation.
        float EaseInQuart(float t);
        /// Similar to Cubic but with an even sharper curve based on quartic interpolation.
        float EaseOutQuart(float t);
        /// Similar to Cubic but with an even sharper curve based on quartic interpolation.
        float EaseInOutQuart(float t);

        /// Similar to Quart but with an even sharper curve based on quintic interpolation.
        float EaseInQuint(float t);
        /// Similar to Quart but with an even sharper curve based on quintic interpolation.
        float EaseOutQuint(float t);
        /// Similar to Quart but with an even sharper curve based on quintic interpolation.
        float EaseInOutQuint(float t);

        /// The sharpest curve based on exponential interpolation.
        float EaseInExpo(float t);
        /// The sharpest curve based on exponential interpolation.
        float EaseOutExpo(float t);
        /// The sharpest curve based on exponential interpolation.
        float EaseInOutExpo(float t);

        /// Follows a circular arc, such that acceleration is more sudden and deceleration more gradual versus Quint or Exponential.
        float EaseInCirc(float t);
        /// Follows a circular arc, such that acceleration is more sudden and deceleration more gradual versus Quint or Exponential.
        float EaseOutCirc(float t);
        /// Follows a circular arc, such that acceleration is more sudden and deceleration more gradual versus Quint or Exponential.
        float EaseInOutCirc(float t);

        /// Slightly overshoots the target, then backs into place.
        float EaseInBack(float t);
        /// Slightly overshoots the target, then backs into place.
        float EaseOutBack(float t);
        /// Slightly overshoots the target, then backs into place.
        float EaseInOutBack(float t);

        float EaseInElastic(float t);
        float EaseOutElastic(float t);
        float EaseInOutElastic(float t);

        float EaseInBounce(float t);
        float EaseOutBounce(float t);
        float EaseInOutBounce(float t);
    }

    struct TweenInfo {
        float time = 1.f;
        float delay = 0.f;
        int repeats = 0;
        bool reverse = false;
        EasingFunc easing = &EasingFunctions::EaseInOutLinear;
        bool overwritable = true;
    };

    /// A class that represents an animation-in-action.
    class Tween {
    public:
        Tween(TweenTickFunc tick_func);
        Tween(TweenTickFunc tick_func, const TweenInfo& info) {
            this->tick_func = tick_func;

            this->time = info.time;
            this->delay_time = info.delay;
            this->repeat_count = info.repeats;
            this->reverses = info.reverse;
            this->easing_func = info.easing;
            this->overwritable = info.overwritable;
        }
        Event<> Completed;

        void Update(float elapsed);

        std::function<float(float)> easing_func = &EasingFunctions::EaseInOutLinear;
        std::function<void(float, float)> tick_func;

        /// Duration of the tween, in seconds.
        float time = 5;
        /// Time of delay until the tween begins, in seconds.
        float delay_time = 0;
        /// Number of times the tween repeats. -1 indicates indefinite repetition.
        int repeat_count = 0; // TODO: Implement
        /// Whether or not the tween interpolates in reverse once the initial tween completes.
        bool reverses = false; // TODO: Implement

        float progress = 0;
        bool alive = true;
        bool paused = false;
        bool completed = false;
        bool overwritable = true;


        void Cancel();
        void ForceFinish();
        void Pause() { paused = true; }
        void Resume() { paused = false; }
        void Start();

        bool Paused() const;
        bool HasCompleted() const;
    };
}