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, bool useAA = true);
 
    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 UseAntiAliasing(bool useAA);
 
    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