event_routing.h

#pragma once
 
#include "pixelbullet/application/event.h"
#include "pixelbullet/application/layer.h"
 
#include <array>
#include <memory>
#include <utility>
#include <vector>
 
namespace pixelbullet::application_internal
{
struct ImGuiCaptureState
{
    bool block_events = true;
    bool want_capture_mouse = false;
    bool want_capture_keyboard = false;
};
 
constexpr EventResult MergeEventResults(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;
}
 
constexpr bool IsConsumed(const EventResult result) noexcept
{
    return result == EventResult::Consumed;
}
 
inline EventResult GetImGuiCaptureResult(const Event& event, const ImGuiCaptureState& capture_state) noexcept
{
    if (!capture_state.block_events)
    {
        return EventResult::Ignored;
    }
 
    if (event.IsInCategory(EventCategoryMouse) && capture_state.want_capture_mouse)
    {
        return EventResult::Consumed;
    }
 
    if (event.IsInCategory(EventCategoryKeyboard) && capture_state.want_capture_keyboard)
    {
        return EventResult::Consumed;
    }
 
    return EventResult::Ignored;
}
 
template <typename BuiltInHandler>
EventResult RouteEvent(Event& event, const std::vector<std::unique_ptr<Layer>>& layers, BuiltInHandler&& built_in_handler)
{
    EventResult result = std::forward<BuiltInHandler>(built_in_handler)(event);
    if (IsConsumed(result))
    {
        return result;
    }
 
    constexpr std::array<EventPhase, 2> k_event_phases = { EventPhase::Early, EventPhase::Normal };
    for (const EventPhase phase : k_event_phases)
    {
        for (auto it = layers.rbegin(); it != layers.rend(); ++it)
        {
            if ((*it)->GetEventPhase() != phase)
            {
                continue;
            }
 
            result = MergeEventResults(result, (*it)->OnEvent(event));
            if (IsConsumed(result))
            {
                return result;
            }
        }
    }
 
    return result;
}
} // namespace pixelbullet::application_internal