event.h

#pragma once
 
#include "pixelbullet/core/bits.h"
 
#include <concepts>
#include <cstdint>
#include <functional>
#include <ostream>
#include <string>
#include <type_traits>
#include <utility>
 
namespace pixelbullet::core
{
enum class EventType
{
    None = 0,
    WindowClose,
    WindowResize,
    WindowFocus,
    WindowLostFocus,
    WindowMoved,
    AppTick,
    AppUpdate,
    AppRender,
    KeyPressed,
    KeyReleased,
    KeyTyped,
    MouseButtonPressed,
    MouseButtonReleased,
    MouseMoved,
    MouseScrolled
};
 
enum class EventCategory : std::uint32_t
{
    None = 0,
    Application = bit(0),
    Window = bit(1),
    Input = bit(2),
    Keyboard = bit(3),
    Mouse = bit(4),
    MouseButton = bit(5)
};
 
enum class EventResult
{
    Ignored,
    Handled,
    Consumed
};
 
[[nodiscard]] constexpr EventCategory operator|(const EventCategory lhs, const EventCategory rhs) noexcept
{
    using Underlying = std::underlying_type_t<EventCategory>;
    return static_cast<EventCategory>(static_cast<Underlying>(lhs) | static_cast<Underlying>(rhs));
}
 
[[nodiscard]] constexpr EventCategory operator&(const EventCategory lhs, const EventCategory rhs) noexcept
{
    using Underlying = std::underlying_type_t<EventCategory>;
    return static_cast<EventCategory>(static_cast<Underlying>(lhs) & static_cast<Underlying>(rhs));
}
 
constexpr EventCategory& operator|=(EventCategory& lhs, const EventCategory rhs) noexcept
{
    lhs = lhs | rhs;
    return lhs;
}
 
[[nodiscard]] constexpr EventResult merge_event_results(const EventResult current, const EventResult next) noexcept
{
    if (current == EventResult::Consumed || next == EventResult::Consumed)
    {
        return EventResult::Consumed;
    }
 
    if (current == EventResult::Handled || next == EventResult::Handled)
    {
        return EventResult::Handled;
    }
 
    return EventResult::Ignored;
}
 
#define PB_EVENT_TYPE(event_type)                                                      \
    [[nodiscard]] static constexpr pixelbullet::core::EventType static_type() noexcept \
    {                                                                                  \
        return pixelbullet::core::EventType::event_type;                               \
    }                                                                                  \
    [[nodiscard]] pixelbullet::core::EventType type() const override                   \
    {                                                                                  \
        return static_type();                                                          \
    }                                                                                  \
    [[nodiscard]] const char* name() const override                                    \
    {                                                                                  \
        return #event_type;                                                            \
    }
 
#define PB_EVENT_CATEGORIES(event_categories)                                  \
    [[nodiscard]] pixelbullet::core::EventCategory categories() const override \
    {                                                                          \
        return event_categories;                                               \
    }
 
class Event
{
public:
    virtual ~Event() = default;
 
    [[nodiscard]] virtual EventType type() const = 0;
    [[nodiscard]] virtual const char* name() const = 0;
    [[nodiscard]] virtual EventCategory categories() const = 0;
    [[nodiscard]] virtual std::string to_string() const
    {
        return name();
    }
 
    [[nodiscard]] bool is_in_category(EventCategory category) const;
 
    [[nodiscard]] EventResult result() const noexcept
    {
        return result_;
    }
 
    [[nodiscard]] bool handled() const noexcept
    {
        return result_ == EventResult::Handled || result_ == EventResult::Consumed;
    }
 
    [[nodiscard]] bool consumed() const noexcept
    {
        return result_ == EventResult::Consumed;
    }
 
    void merge_result(const EventResult result) noexcept
    {
        result_ = merge_event_results(result_, result);
    }
 
    void reset_result() noexcept
    {
        result_ = EventResult::Ignored;
    }
 
private:
    EventResult result_ = EventResult::Ignored;
};
 
class EventDispatcher
{
public:
    explicit EventDispatcher(Event& event);
 
    template <typename T, typename F>
        requires std::same_as<std::invoke_result_t<F, T&>, EventResult>
    [[nodiscard]] EventResult dispatch(F&& func)
    {
        if (event_.type() == T::static_type())
        {
            const EventResult result = std::invoke(std::forward<F>(func), static_cast<T&>(event_));
            event_.merge_result(result);
            return result;
        }
        return EventResult::Ignored;
    }
 
private:
    Event& event_;
};
 
std::ostream& operator<<(std::ostream& os, const Event& e);
 
} // namespace pixelbullet::core