Animation.hpp

#ifndef UTIL_ANIMATION_HPP
#define UTIL_ANIMATION_HPP
 
#include "pch.hpp"
 
#include <exception>
 
#include "Core/Drawable.hpp"
 
#include "Util/Image.hpp"
 
namespace Util {
class Animation : public Core::Drawable {
public:
    enum class State {
        PLAY,     
        PAUSE,    
        COOLDOWN, 
        ENDED     
    };

    Animation(const std::vector<std::string> &paths, bool play,
              std::size_t interval, bool looping = true,
              std::size_t cooldown = 100);

    int GetInterval() const { return m_Interval; }

    bool GetLooping() const { return m_Looping; }

    int GetCooldown() const { return m_Cooldown; }

    std::size_t GetCurrentFrameIndex() const { return m_Index; }

    std::size_t GetFrameCount() const { return m_Frames.size(); }

    State GetState() const { return m_State; }

    glm::vec2 GetSize() const override { return m_Frames[m_Index]->GetSize(); }

    void SetInterval(int interval) { m_Interval = interval; }

    void SetLooping(bool looping) { m_Looping = looping; }

    void SetCooldown(int cooldown) { m_Cooldown = cooldown; }

    void SetCurrentFrame(std::size_t index);

    void Draw(const Core::Matrices &data) override;

    void Play();

    void Pause();
 
private:
    void Update();
 
private:
    std::vector<std::shared_ptr<Util::Image>> m_Frames;
    State m_State;
    double m_Interval;
    bool m_Looping;
    std::size_t m_Cooldown;
    bool m_IsChangeFrame = false;
 
    unsigned long m_CooldownEndTime = 0;
    double m_TimeBetweenFrameUpdate = 0;
 
    std::size_t m_Index = 0;
};
} // namespace Util
 
#endif