state.hpp

#pragma once
#include <functional>
#include <type_traits>
 
namespace atlas {
 
    namespace detail {
        void invoke_on_update();
        void invoke_defer_update();
        void invoke_physics_update();
        void invoke_ui_update();
        void invoke_start();
 
        // TODO: Look into a different way of doing this
        void poll_update(void* p_address,
                         const std::function<void()>& p_callback);
 
        void poll_defer_update(void* p_address,
                               const std::function<void()>& p_callback);
 
        void poll_physics_update(void* p_address,
                                 const std::function<void()>& p_callback);
 
        void poll_ui_update(void* p_address,
                            const std::function<void()>& p_callback);
 
        void poll_start(void* p_address,
                        const std::function<void()>& p_callback);
 
        // TEMP: This is a temporary solution, should look into doing this
        // differently
        void remove_update(void* p_address);
 
        void remove_defer_update(void* p_address);
 
        void remove_physics_update(void* p_address);
 
        void remove_ui_update(void* p_address);
 
        void remove_start(void* p_address);
 
    };
 
    template<typename UObject, typename UCallback>
    void register_start(UObject* p_instance, const UCallback& p_callable) {
        static_assert(std::is_member_pointer_v<UCallback>,
                      "Cannot register a function that is not a member "
                      "function of a class object");
        detail::poll_start(p_instance, [p_instance, p_callable]() {
            (p_instance->*p_callable)();
        });
    }
 
    template<typename UObject, typename UCallback>
    void register_update(UObject* p_instance, const UCallback& p_callable) {
        static_assert(std::is_member_pointer_v<UCallback>,
                      "Cannot register a function that is not a member "
                      "function of a class object");
        detail::poll_update(p_instance, [p_instance, p_callable]() {
            (p_instance->*p_callable)();
        });
    }
 
    template<typename UObject, typename UCallback>
    void register_physics(UObject* p_instance, const UCallback& p_callable) {
        static_assert(std::is_member_pointer_v<UCallback>,
                      "Cannot register a function that is not a member "
                      "function of a class object");
        detail::poll_physics_update(p_instance, [p_instance, p_callable]() {
            (p_instance->*p_callable)();
        });
    }
 
    template<typename UObject, typename UCallback>
    void register_deferred(UObject* p_instance, const UCallback& p_callable) {
        static_assert(std::is_member_pointer_v<UCallback>,
                      "Cannot register a function that is not a member "
                      "function of a class object");
        detail::poll_defer_update(p_instance, [p_instance, p_callable]() {
            (p_instance->*p_callable)();
        });
    }
 
    template<typename UObject, typename UCallback>
    void register_ui(UObject* p_instance, const UCallback& p_callable) {
        static_assert(std::is_member_pointer_v<UCallback>,
                      "Cannot register a function that is not a member "
                      "function of a class object");
        detail::poll_ui_update(p_instance, [p_instance, p_callable]() {
            (p_instance->*p_callable)();
        });
    }
 
};