Controller.hpp

Go to the documentation of this file.

 
#ifndef MATF_RG_PROJECT_CONTROLLER_HPP
#define MATF_RG_PROJECT_CONTROLLER_HPP
 
#include <engine/util/Errors.hpp>
#include <memory>
#include <string_view>
#include <vector>
#include <typeinfo>
 
namespace engine::core {
    class Controller {
        friend class App;
 
    public:
        template<typename TController>
        static TController *get(std::source_location location = std::source_location::current()) {
            static_assert(std::is_base_of_v<Controller, TController>);
            static TController *controller = create_if_absent<TController>();
            RG_GUARANTEE(controller->is_registered(),
                         "Trying to get an unregistered controller in: {}:{}.\nPlease call register_controller<> first during App::app_setup.",
                         location.file_name(), location.line());
            return controller;
        }
 
        virtual std::string_view name() const {
            return typeid(*this).name();
        }
 
        virtual ~Controller() = default;
 
        void before(Controller *next) {
            this->m_next.push_back(next);
        }
 
        void after(Controller *prev) {
            prev->before(this);
        }
 
        const std::vector<Controller *> &next() const {
            return m_next;
        }
 
        bool is_enabled() const {
            return m_enabled;
        }
 
        void set_enable(bool value) {
            m_enabled = value;
        }
 
    private:
        void mark_as_registered() {
            m_registered = true;
        }
 
        bool is_registered() const {
            return m_registered;
        }
 
        virtual void initialize() {
        }
 
        virtual bool loop() {
            return true;
        }
 
        virtual void poll_events() {
        }
 
        virtual void update() {
        }
 
        virtual void begin_draw() {
        }
 
        virtual void draw() {
        }
 
        virtual void end_draw() {
        }
 
        virtual void terminate() {
        }
 
        template<typename TController>
        static TController *create_if_absent() {
            static_assert(std::is_base_of_v<Controller, TController>);
            static std::unique_ptr<TController> controller = std::make_unique<TController>();
            return controller.get();
        }
 
        std::vector<Controller *> m_next{};
 
        bool m_registered{false};
 
        bool m_enabled{true};
    };
 
    class EngineControllersBegin final : public Controller {
    public:
        std::string_view name() const override {
            return "EngineControllersBegin";
        }
    };
 
    class EngineControllersEnd final : public Controller {
    public:
        std::string_view name() const override {
            return "EngineControllersEnd";
        }
    };
} // namespace engine
 
#endif//MATF_RG_PROJECT_CONTROLLER_HPP