QuadAnimator.hpp

Go to the documentation of this file.

#pragma once
#include "AnimationPack.hpp"
#include "WorldSystem/Entity.hpp"
 
namespace Cori {
    namespace World {
        namespace Systems {
            class Animation;
        }
 
        namespace Components {
            namespace Entity {

                class QuadAnimator {
                public:
                    using StopCallbackFn = std::function<void()>;
 
                    QuadAnimator();
                    ~QuadAnimator();

                    void SetStopCallback(StopCallbackFn callback);

                    void Play(const Graphics::IsAnimationWithParams auto&... sequence) {
                        m_AnimationSequence.clear();
                        m_AnimationSequence.reserve(sizeof...(sequence));
                        (m_AnimationSequence.emplace_back(sequence), ...);
                        m_CurrentLoopedSequenceIndex = 0;
                        m_CurrentFrame = 0;
                        m_CurrentFrameTick = 0;
                        //m_TicksElapsedSinceStart = 0;
                        m_ActiveSequence = true;
 
                        bool loopedFlags[] = { sequence.second.LoopedInSequence ... };
                        m_LoopStartIndex = 0xFFFF;
                        for (uint32_t i = 0; i < sizeof...(sequence); ++i) {
                            if (loopedFlags[i]) {
                                m_LoopStartIndex = i;
                                break;
                            }
                        }
 
                        OnTickUpdate();
                    }

                    void Stop(const bool abruptStop);

                    void SetSizeScale(const glm::vec2 scale);

                    [[nodiscard]] glm::vec2 GetSizeScale() const;
 
                    //[[nodiscard]] uint64_t GetTicksElapsed() const;
 
                protected:
                    friend Systems::Animation;
 
                    void OnTickUpdate();
 
                    void SetEngineStopCallback(StopCallbackFn callback);
 
                private:
                    StopCallbackFn m_StopCallBack;
                    StopCallbackFn m_EngineCallBack;
                    bool m_ActiveSequence;
                    glm::vec2 m_SizeScale{ 1.0f, 1.0f };
                    uint16_t m_LoopStartIndex{ 0xFFFF };
                    uint16_t m_CurrentLoopedSequenceIndex{ 0 };
 
                    uint32_t m_CurrentFrame{ 0 };
                    uint32_t m_CurrentFrameTick{ 0 };
                    //uint64_t m_TicksElapsedSinceStart{ 0 };
 
                    std::vector<Graphics::AnimationWithParams> m_AnimationSequence;
                    World::Entity m_Entity{};
                };
            }
        }
    }
}