event_routing.h

#pragma once
 
#include "pixelbullet/application/layer.h"
#include "pixelbullet/core/event.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;
};
 
inline pixelbullet::core::EventResult GetImGuiCaptureResult(const pixelbullet::core::Event& event,
                                                            const ImGuiCaptureState& capture_state) noexcept
{
    if (!capture_state.block_events)
    {
        return pixelbullet::core::EventResult::Ignored;
    }
 
    if (event.is_in_category(pixelbullet::core::EventCategory::Mouse) && capture_state.want_capture_mouse)
    {
        return pixelbullet::core::EventResult::Consumed;
    }
 
    if (event.is_in_category(pixelbullet::core::EventCategory::Keyboard) && capture_state.want_capture_keyboard)
    {
        return pixelbullet::core::EventResult::Consumed;
    }
 
    return pixelbullet::core::EventResult::Ignored;
}
 
template <typename BuiltInHandler>
pixelbullet::core::EventResult RouteEvent(pixelbullet::core::Event& event, const std::vector<std::unique_ptr<Layer>>& layers,
                                          BuiltInHandler&& built_in_handler)
{
    event.reset_result();
 
    const auto merge_result = [&](const pixelbullet::core::EventResult result) -> pixelbullet::core::EventResult
    {
        event.merge_result(result);
        return event.result();
    };
 
    const auto route_layers = [&]() -> pixelbullet::core::EventResult
    {
        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;
                }
 
                merge_result((*it)->OnEvent(event));
                if (event.consumed())
                {
                    return event.result();
                }
            }
        }
 
        return event.result();
    };
    const auto invoke_built_in = [&]() -> pixelbullet::core::EventResult
    { return merge_result(std::forward<BuiltInHandler>(built_in_handler)(event)); };
 
    if (event.type() == pixelbullet::core::EventType::WindowClose)
    {
        route_layers();
        if (event.consumed())
        {
            return event.result();
        }
 
        invoke_built_in();
        return event.result();
    }
 
    invoke_built_in();
    if (event.consumed())
    {
        return event.result();
    }
 
    route_layers();
    return event.result();
}
} // namespace pixelbullet::application_internal