State.hpp

#pragma once
 
#include <map>
#include "../../../Opengl-Core/include/Core.hpp"

class State {
public:
    virtual void onAttach() {
        std::cout << "Attaching state: " << this->m_name << " to StateManager\n";
        this->m_attached = true;
    }

    virtual void onDetach() {
        std::cout << "Detaching state: " << this->m_name << " from StateManager\n";
        this->m_attached = false;
    }

    virtual void onUpdate() {}

    virtual void onRender() {}

    virtual bool isCurrentStateEnd() { return true; }

    std::string getName() const { return this->m_name; }

    bool isAttached() const { return this->m_attached; }

    State(const std::string &name = "State") :
        m_name(std::move(name)) {}
    virtual ~State() = default;
 
protected:
    const std::string m_name;
    bool m_attached = false;
};

class StateManager {
public:
    StateManager(StateManager &other) = delete;
 
    void operator=(const StateManager &other) = delete;

    inline static Shared<StateManager> instance() {
        if (s_pointer == nullptr) {
            Shared<StateManager> copy(new StateManager());
            copy.swap(s_pointer);
        }
        return s_pointer;
    }

    bool shouldExit() const {
        ASSERT(this->m_currentState != nullptr);
        return this->m_currentState->isCurrentStateEnd();
    }

    void execUpdate() { this->m_currentState->onUpdate(); }

    void execRender() { this->m_currentState->onRender(); }

    void sync();

    void clean();

    void changeState(const std::string &name, const Shared<State> &state);

    inline void changeState(const Shared<State> &state) { this->changeState(state->getName(), state); }
    void changeState(const std::string &name);

    bool isCurrentStateDefined() const { return this->m_currentState != nullptr; }

    void cacheState(const std::string &name, const Shared<State> &state);

    inline void cacheState(const Shared<State> &state) { this->cacheState(state->getName(), state); }

    void uncacheState(const std::string &name);

    inline std::map<std::string, Shared<State>> getCachedStates() { return this->m_cacheStates; }
 
    ~StateManager() = default;
 
private:
    inline static Shared<StateManager> s_pointer = nullptr;

    Shared<State> m_currentState = nullptr;
    Shared<State> m_queueState = nullptr;
    std::map<std::string, Shared<State>> m_cacheStates{};

    bool m_stateChanged = false;
 
    StateManager() = default;
};