ui_system.h

Go to the documentation of this file.

#pragma once
 
#include "entt/entity/fwd.hpp"
#include <engine/engine_export.h>
#include <base/basetypes.hpp>
#include <context/context.hpp>
#include <ospp/event.h>
#include <hpp/utility.hpp>
#include <engine/ecs/scene.h>
#include <math/math.h>
#include <string>
#include <vector>
#include <entt/entt.hpp>
#include <graphics/frame_buffer.h>
#include <engine/ui/rmlui/RmlUi_RenderLayerStack.h>
 
// Forward declarations
namespace Rml
{
    class Context;
    class ElementDocument;
    class Element;
}
 
namespace unravel
{
    class camera;
    struct ui_document_component;
 
struct ui_system
{
    static void on_create_component(entt::registry& r, entt::entity e);
    static void on_load_component(entt::registry& r, entt::entity e);
    static void on_destroy_component(entt::registry& r, entt::entity e);
 
    auto init(rtti::context& ctx) -> bool;
 
    auto deinit(rtti::context& ctx) -> bool;
 
    void update_world_space(rtti::context& ctx, entt::handle camera_entity, scene& scn, bool& process_input);
 
    void render_world_space(rtti::context& ctx, entt::handle camera_entity, scene& scn, delta_t dt);
 
    void update_screen_space(rtti::context& ctx, entt::handle camera_entity, scene& scn, bool& process_input);
 
    void render_screen_space(rtti::context& ctx, const gfx::frame_buffer::ptr& output, entt::handle camera_entity,
                            scene& scn, delta_t dt);
 
 
 
    void on_os_event(rtti::context& ctx, os::event& event);
 
    void load_fonts();
 
    void release_resources();
    
    void register_component_callbacks(rtti::context& ctx);
 
    auto is_debugger_enabled() const -> bool;
    void set_debugger_enabled(bool enabled);
 
    void update_ui_documents(rtti::context& ctx, scene& scn);
 
    void update_world_space_document(rtti::context& ctx, scene& scn, entt::handle handle, ui_document_component& comp,
                                    const camera& cam, float dp_ratio, bool process_input, bool& hit_found);
 
    void update_screen_space_document(rtti::context& ctx, Rml::Context* context, int viewport_width,
                                     int viewport_height, float dp_ratio, scene& scn, bool process_input, bool& hit_found);
    
 
    void update_ui_document_common(entt::handle handle, ui_document_component& ui_comp, bool is_playing);                                 
    auto load_ui_document(entt::handle entity, ui_document_component& component, bool log_error = true) -> bool;
 
 
 
    auto is_not_root_element(scene& scn, Rml::Element* element) -> bool;
 
    // OS event input routing (implemented in ui_system_input.cpp)
    struct ui_pointer_dispatch_result
    {
        Rml::Context* target_context = nullptr;
    };
 
    auto find_keyboard_context(scene& scn) const -> Rml::Context*;
    auto try_consume_keyboard_event(scene& scn, os::event& event) -> bool;
    auto dispatch_pointer_event(rtti::context& ctx, scene& scn, os::event& event) -> ui_pointer_dispatch_result;
    void apply_mouse_press_focus(scene& scn, os::event& event, Rml::Context* target_context, bool input_allowed);
 
    void blur_ui_context(Rml::Context* context) const;
    void refresh_mouse_state(rtti::context& ctx, scene& scn);
    auto process_mouse_move(scene& scn, Rml::Context* context, int x, int y) -> bool;
    auto process_event(scene& scn, Rml::Context* context, os::event& event) -> bool;
 
    void load_font(const std::string& path);
 
    void ensure_document_framebuffer(ui_document_component& comp);
    private:
 
    Rml::Context* debug_context_ = nullptr;
    Rml::Context* debug_target_context_ = nullptr;
    std::shared_ptr<RmlUi_RenderLayerStack> debug_render_layer_stack_ = nullptr;
 
 
    std::shared_ptr<int> sentinel_ = std::make_shared<int>();
    std::set<std::string> fonts_loaded_;
};
 
} // namespace unravel