Event.hpp

Go to the documentation of this file.

#ifndef _EVENT_H_
#define _EVENT_H_
 
#include <Core/OSDef.hpp>
#include <string>
#include <functional>
#include <unordered_map>
#include <vector>
#include <Events/Delegate.hpp>
 
 
#define BIND_LAMBDA(fn) [this](auto&&... args) -> decltype(auto) { return this->fn(std::forward<decltype(args)>(args)...); }
#define BIND_FUNC_0(Function, class_name) std::bind(&class_name::Function, this)
#define BIND_FUNC_1(Function, class_name) std::bind(&class_name::Function, this, std::placeholders::_1)
#define BIND_FUNC_2(Function, class_name) std::bind(&class_name::Function, this, std::placeholders::_2)
#define BIND_FUNC_3(Function, class_name) std::bind(&class_name::Function, this, std::placeholders::_3)
 
#define GET_DISPATCHER Sleak::EventDispatcher::GetInstance()
 
namespace Sleak {
    /// Concrete kind of Event; each Event subclass reports one of these via GetEventType().
    /// @ingroup events
    enum class EventType {
        Unknown = 0,
        WindowOpen, WindowClose, WindowResize, WindowFullscreen, WindowFocus, WindowLostFocus, WindowMoved,
        Tick, Update, Render,
        KeyPressed, KeyReleased, KeyTyped,
        MousePressed, MouseReleased, MouseMoved, MouseScrolled
    };
 
    /// Bitmask groups an Event can belong to, queried via Event::IsInCategory().
    /// @ingroup events
    enum class EventCategory {
        None = (1 << 0),
        Application = (1 << 1),
        Input = (1 << 2),
        Keyboard = (1 << 3),
        Mouse = (1 << 4),
        MouseButton = (1 << 5)
    };
 
    #define EVENT_CLASS_TYPE(type) \
    static EventType GetStaticType() \
    { \
        return EventType::type;\
    }\
    virtual EventType GetEventType() const override \
    {\
        return GetStaticType();\
    }\
    virtual const char* GetName() const override \
    {\
        return #type;\
    }
 
    #define EVENT_CLASS_CATEGORY(category)\
    virtual int GetCategoryFlags() const override \
     { return static_cast<int>(category); }
 
    /// Base for all engine events; carries type/category identity and the
    /// Handled flag consumers can set to stop further propagation.
    /// @ingroup events
    class ENGINE_API Event {
    public:
        Event() {}
 
        virtual ~Event() = default;
 
        bool Handled = false;
 
        virtual EventType GetEventType() const = 0;
        virtual const char* GetName() const = 0;
        virtual int GetCategoryFlags() const = 0;
        virtual std::string ToString() const { return GetName(); }
 
        bool IsInCategory(EventCategory category)
        {
            return GetCategoryFlags() & (uint16_t)category;
        }
    };
 
    /// Static registry mapping EventType to subscribed handlers; dispatches
    /// events synchronously to every handler registered for its type.
    ///
    /// Everything here is static, so there is no dispatcher instance to
    /// pass around: subscribe from anywhere, and the window layer's
    /// keyboard, mouse, and window events reach you. RegisterEventHandler()
    /// binds a member function and is the form you will use most;
    /// RegisterEventCallback() takes a std::function for lambdas and free
    /// functions.
    ///
    /// Both return a string id. Keep it and pass it to UnregisterEvent()
    /// when the subscriber goes away, typically in a scene's OnDeactivate()
    /// or destructor. Handlers outlive the objects they were bound to
    /// otherwise, and the next dispatch calls into freed memory.
    ///
    /// Dispatch is synchronous and runs in registration order on the
    /// calling thread. The handler list is copied before iteration, so a
    /// handler may register or unregister during dispatch safely.
    ///
    /// @code{.cpp}
    /// class WorldScene : public Sleak::Scene {
    /// public:
    ///     void Begin() override {
    ///         m_keyId = Sleak::EventDispatcher::RegisterEventHandler(
    ///             this, &WorldScene::OnKeyPressed);
    ///         Sleak::Scene::Begin();
    ///     }
    ///
    ///     void OnDeactivate() override {
    ///         if (!m_keyId.empty()) {
    ///             Sleak::EventDispatcher::UnregisterEvent(
    ///                 Sleak::EventType::KeyPressed, m_keyId);
    ///             m_keyId.clear();
    ///         }
    ///         Sleak::Scene::OnDeactivate();
    ///     }
    ///
    ///     void OnKeyPressed(
    ///         const Sleak::Events::Input::KeyPressedEvent& e) {
    ///         if_key_press(KEY__F) { ToggleFlashlight(); }
    ///     }
    ///
    /// private:
    ///     std::string m_keyId;
    /// };
    /// @endcode
    ///
    /// @see Event, EventType, Events::Input::KeyPressedEvent,
    ///      Events::Input::MouseMovedEvent
    /// @ingroup events
    class ENGINE_API EventDispatcher {
        public:
            // Register a handler for any event type
            /// Registers a free-function/lambda callback for EventT, returning an ID for later unregistration.
            template<typename EventT>
            static std::string RegisterEventCallback(std::function<void(const EventT&)> callback) {
                EventType type = EventT::GetStaticType();
                
                auto delegate = std::make_shared<EventDelegate<EventT>>(callback);
                eventHandlers[type].push_back(delegate);
                
                return delegate->GetUUID();
            }
            
            // Register a member function handler
            /// Registers a member-function handler bound to instance, returning an ID for later unregistration.
            template<typename T, typename EventT>
            static std::string RegisterEventHandler(T* instance, void (T::*memberFunction)(const EventT&)) {
                EventType type = EventT::GetStaticType();
                
                auto callback = [instance, memberFunction](const EventT& event) {
                    (instance->*memberFunction)(event);
                };
                
                auto delegate = std::make_shared<EventDelegate<EventT>>(callback);
                eventHandlers[type].push_back(delegate);
 
                return delegate->GetID();
            }
 
            /// Removes the single handler with matching id from type's handler list.
            static void UnregisterEvent(EventType type, std::string id) {
                for(auto it = eventHandlers[type].begin(); it != eventHandlers[type].end(); ++it) {
                    if((*it)->GetID() == id) {
                        eventHandlers[type].erase(it);
                        break;
                    }
                }
            }
 
            /// Drops every handler registered for type.
            static void UnregisterEvents(EventType type) {
                eventHandlers[type].clear();
            }
 
            /// Drops every handler for every event type.
            static void UnregisterAllEvents() {
                eventHandlers.clear();
            }
 
            // Dispatch an event to all registered handlers
            /// Invokes every handler registered for event's type, in registration order.
            template<typename EventT>
            static void DispatchEvent(const EventT& event) {
                EventType type = event.GetEventType();
 
                if (eventHandlers.find(type) == eventHandlers.end())
                    return;
 
                // Copy the handler list so that handlers which add/remove entries
                // during dispatch don't invalidate the iteration.
                auto handlers = eventHandlers[type];
                for (auto& handler : handlers) {
                    // Try to cast to the right event delegate type
                    auto typedDelegate = std::dynamic_pointer_cast<EventDelegate<EventT>>(handler);
                    if (typedDelegate) {
                        typedDelegate->SetEvent(event);
                        typedDelegate->Execute();
                    }
                }
            }
            
            /// Drops every handler for every event type; equivalent to UnregisterAllEvents().
            static void ClearEventHandlers() {
                eventHandlers.clear();
            }
 
        private:
            static inline std::unordered_map<EventType, std::vector<std::shared_ptr<IDelegate>>> eventHandlers;
        };
 
 
        // Helper function for easier event dispatching
        /// Constructs a T from args and dispatches it through EventDispatcher.
        template<typename T, typename... Args>
        void DispatchEvent(Args&&... args) {
            T event(std::forward<Args>(args)...);
            EventDispatcher::DispatchEvent(event);
        }
 
    inline std::ostream& operator<<(std::ostream& os, const Event& e)
    {
        return os << e.ToString();
    }
}
 
#endif