animation.h

/*
 * Copyright (C) 2018 Microchip Technology Inc.  All rights reserved.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
#ifndef EGT_ANIMATION_H
#define EGT_ANIMATION_H
 
#include <chrono>
#include <egt/detail/meta.h>
#include <egt/easing.h>
#include <egt/geometry.h>
#include <egt/timer.h>
#include <functional>
#include <memory>
#include <vector>
 
namespace egt
{
inline namespace v1
{
using EasingScalar = float;
 
using AnimationCallback = std::function<void (EasingScalar value)>;
 
using EasingFunc = std::function<EasingScalar(EasingScalar percent)>;
 
namespace detail
{
 
template<class Functor, class T>
T interpolate(Functor&& easing, T percent, T start, T end, bool reverse = false)
{
    if (percent < 0.0f)
        return start;
    else if (percent > 1.0f)
        return end;
 
    if (reverse)
        percent = 1.0f - easing(1.0f - percent);
    else
        percent = easing(percent);
 
    return start * (1.0f - percent) + end * percent;
}
 
class EGT_API AnimationBase
{
public:
 
    AnimationBase() = default;
    AnimationBase(const AnimationBase&) = delete;
    AnimationBase& operator=(const AnimationBase&) = delete;
    AnimationBase(AnimationBase&&) noexcept = default;
    AnimationBase& operator=(AnimationBase&&) noexcept = default;
 
    virtual void start() = 0;
 
    virtual bool next() = 0;
 
    virtual void stop() = 0;
 
    virtual void resume() = 0;
 
    EGT_NODISCARD virtual bool running() const { return m_running; }
 
    void add_callback(AnimationCallback callback)
    {
        if (callback)
            m_callbacks.emplace_back(std::move(callback));
    }
 
    void clear_callbacks()
    {
        m_callbacks.clear();
    }
 
    virtual ~AnimationBase() noexcept = default;
 
protected:
 
    bool m_running{false};
 
    std::vector<AnimationCallback> m_callbacks;
};
}
 
class EGT_API Animation : public detail::AnimationBase
{
public:
 
    Animation(EasingScalar start,
              EasingScalar end,
              const AnimationCallback& callback,
              std::chrono::milliseconds duration,
              EasingFunc func = easing_linear);
 
    EGT_NODISCARD EasingScalar starting() const { return m_start; }
 
    void starting(EasingScalar start) { m_start = start; }
 
    EGT_NODISCARD EasingScalar ending() const { return m_end; }
 
    void ending(EasingScalar end) { m_end = end; }
 
    void duration(std::chrono::milliseconds dur) { m_duration = dur; }
 
    void easing_func(EasingFunc func);
 
    void reverse(bool rev) { m_reverse = rev; }
 
    void start() override;
 
    bool next() override;
 
    void stop() override;
 
    void resume() override;
 
    EGT_NODISCARD EasingScalar current() const { return m_current; }
 
    void rounding(bool enable) { m_round = enable; }
 
protected:
 
    EasingScalar m_start{0};
 
    EasingScalar m_end{0};
 
    EasingScalar m_elapsed{0};
 
    EasingFunc m_easing{easing_linear};
 
    EasingScalar m_current{0};
 
    std::chrono::milliseconds m_duration{};
 
    std::chrono::time_point<std::chrono::steady_clock> m_intermediate_time;
 
    bool m_reverse{false};
 
    bool m_round{false};
};
 
class EGT_API AnimationSequence : public detail::AnimationBase
{
public:
 
    explicit AnimationSequence(bool loop = false) noexcept
        : m_loop(loop)
    {}
 
    virtual void add(detail::AnimationBase& animation)
    {
        // Nasty, but it gets the job done.  If a widget is passed in as a
        // reference, we don't own it, so create a "pointless" shared_ptr that
        // will not delete it.
        add(std::shared_ptr<detail::AnimationBase>(&animation, [](detail::AnimationBase*) {}));
    }
 
    template<class T>
    void add(const std::shared_ptr<T>& animation)
    {
        add(std::dynamic_pointer_cast<detail::AnimationBase>(animation));
    }
 
    virtual void add(const std::shared_ptr<detail::AnimationBase>& animation)
    {
        if (!animation)
            return;
 
        m_animations.push_back(animation);
 
        auto weak_animation = std::weak_ptr<detail::AnimationBase>(animation);
        animation->add_callback([this, weak_animation](EasingScalar)
        {
            auto animation = weak_animation.lock();
            if (animation)
            {
                // when the animation ever completes, we go next
                if (!animation->running())
                    next();
            }
        });
    }
 
    void removeLast()
    {
        if (!m_animations.empty())
            m_animations.pop_back();
    }
 
    void removeAt(size_t pos)
    {
        if (pos < m_animations.size())
            m_animations.erase(m_animations.begin() + pos);
    }
 
    void remove(detail::AnimationBase* animation)
    {
        if (!animation)
            return;
 
        const auto i = std::find_if(m_animations.begin(), m_animations.end(),
                                    [animation](const auto & ptr)
        {
            return ptr.get() == animation;
        });
        if (i != m_animations.end())
        {
            m_animations.erase(i);
        }
    }
 
    bool skip()
    {
        if (m_current >= m_animations.size())
            return false;
 
        m_animations[m_current]->stop();
 
        if (++m_current >= m_animations.size())
            return false;
 
        m_animations[m_current]->start();
 
        return true;
    }
 
    void start() override
    {
        // Prevent case when sequence is started without any animation added.
        if (m_current >= m_animations.size())
            return;
 
        if (running())
            stop();
 
        m_current = 0;
 
        m_animations[m_current]->start();
 
        m_running = true;
    }
 
    bool next() override
    {
        if (!running())
            return true;
 
        if (m_animations[m_current]->running())
            return false;
 
        if (++m_current >= m_animations.size())
        {
            if (m_loop)
            {
                m_current = 0;
            }
            else
            {
                m_current = 0;
                m_running = false;
                return m_running;
            }
        }
 
        m_animations[m_current]->start();
 
        return m_running;
    }
 
    void stop() override
    {
        if (m_current >= m_animations.size())
            return;
 
        m_animations[m_current]->stop();
 
        m_running = false;
    }
 
    void resume() override
    {
        if (m_current >= m_animations.size())
            return;
 
        if (running())
            return;
 
        m_animations[m_current]->resume();
 
        m_running = true;
    }
 
protected:
 
    using AnimationArray = std::vector<std::shared_ptr<detail::AnimationBase>>;
 
    AnimationArray m_animations;
 
    size_t m_current{0};
 
    bool m_loop{false};
};
 
class EGT_API AutoAnimation : public Animation
{
public:
 
    AutoAnimation(EasingScalar start,
                  EasingScalar end,
                  std::chrono::milliseconds duration,
                  const EasingFunc& func = easing_linear,
                  const AnimationCallback& callback = nullptr);
 
    explicit AutoAnimation(std::chrono::milliseconds duration,
                           const EasingFunc& func = easing_linear,
                           const AnimationCallback& callback = nullptr);
 
    void start() override;
    void stop() override;
    void resume() override;
 
    void interval(std::chrono::milliseconds duration);
 
protected:
 
    PeriodicTimer m_timer;
};
 
template <class T>
class PropertyAnimatorType : public AutoAnimation
{
public:
 
    using Value = T;
 
    explicit PropertyAnimatorType(T start = T(),
                                  T end = T(),
                                  std::chrono::milliseconds duration = std::chrono::milliseconds(),
                                  const EasingFunc& func = easing_linear)
        : AutoAnimation(start, end, duration, func,
                        [this](T value) { invoke_handlers(value); })
    {}
 
    explicit PropertyAnimatorType(std::chrono::milliseconds duration,
                                  const EasingFunc& func = easing_linear)
        : AutoAnimation(duration, func,
                        [this](T value)
    {
        invoke_handlers(value);
    })
    {}
 
    using PropertyCallback = std::function<void (T v)>;
 
    void on_change(PropertyCallback callback)
    {
        m_callbacks.emplace_back(std::move(callback));
    }
 
    void clear_change_callbacks()
    {
        m_callbacks.clear();
    }
 
protected:
 
    void invoke_handlers(T value)
    {
        for (const auto& callback : m_callbacks)
            callback(value);
    }
 
    using CallbackArray = std::vector<PropertyCallback>;
 
    CallbackArray m_callbacks;
};
 
using PropertyAnimator = PropertyAnimatorType<DefaultDim>;
 
using PropertyAnimatorF = PropertyAnimatorType<float>;
 
class EGT_API AnimationDelay : public detail::AnimationBase
{
public:
 
    AnimationDelay() = delete;
 
    explicit AnimationDelay(std::chrono::milliseconds duration) noexcept
        : m_timer(duration)
    {
        m_timer.on_timeout([this]()
        {
            if (!next())
            {
                stop();
            }
        });
    }
 
    void start() override
    {
        m_timer.start();
    }
 
    bool next() override
    {
        for (const auto& c : m_callbacks)
            c(0);
 
        return false;
    }
 
    void stop() override
    {
        m_timer.cancel();
    }
 
    void resume() override
    {
        m_timer.start();
    }
 
protected:
 
    Timer m_timer;
};
 
}
}
 
#endif