event.h

#pragma once
 
#include "pixelbullet/core/bits.h"
 
#include <functional>
#include <ostream>
#include <string>
#include <utility>
 
#define PB_BIND_EVENT_FN(fn) [this](auto&&... args) -> decltype(auto) { return this->fn(std::forward<decltype(args)>(args)...); }
 
namespace pixelbullet
{
enum class EventType
{
    None = 0,
    WindowClose,
    WindowResize,
    WindowFocus,
    WindowLostFocus,
    WindowMoved,
    AppTick,
    AppUpdate,
    AppRender,
    KeyPressed,
    KeyReleased,
    KeyTyped,
    MouseButtonPressed,
    MouseButtonReleased,
    MouseMoved,
    MouseScrolled
};
 
enum EventCategory
{
    None = 0,
    EventCategoryApplication = Bit(0),
    EventCategoryInput = Bit(1),
    EventCategoryKeyboard = Bit(2),
    EventCategoryMouse = Bit(3),
    EventCategoryMouseButton = Bit(4)
};
 
enum class EventResult
{
    Ignored,
    Handled,
    Consumed
};
 
#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 category;                          \
    }
 
class Event
{
public:
    virtual ~Event() = default;
 
    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) const;
};
 
class EventDispatcher
{
public:
    explicit EventDispatcher(Event& event);
 
    template <typename T, typename F>
    EventResult Dispatch(const F& func)
    {
        if (event_.GetEventType() == T::GetStaticType())
        {
            return func(static_cast<T&>(event_));
        }
        return EventResult::Ignored;
    }
 
private:
    Event& event_;
};
 
std::ostream& operator<<(std::ostream& os, const Event& e);
 
} // namespace pixelbullet