inspectors.h

Go to the documentation of this file.

#pragma once
 
#include "entt/core/fwd.hpp"
#include "inspector.h"
#include "property_path_generator.h"
#include <context/context.hpp>
#include <engine/meta/ecs/entity.hpp>
 
namespace unravel
{
struct inspector_registry
{
    inspector_registry();
 
    std::unordered_map<entt::id_type, std::shared_ptr<inspector>> type_map;
};
 
struct prefab_property_override
{
    std::string pretty_path;
    std::string serialization_path;
 
    prefab_property_override() = default;
    
    static auto create(const std::string& pretty, const std::string& serialization) -> prefab_property_override
    {
        prefab_property_override override;
        override.pretty_path = pretty;
        override.serialization_path = serialization;
        return override;
    }
 
    auto operator==(const prefab_property_override& other) const -> bool
    {
        return serialization_path == other.serialization_path;
    }
 
    auto operator<(const prefab_property_override& other) const -> bool
    {
        return serialization_path < other.serialization_path;
    }
};
 
struct inspector_context
{
    entt::registry* inspected_registry{};
};
 
struct prefab_override_context
{
    prefab_override_context() = default;
 
    std::function<bool(const hpp::uuid& entity_uuid, const std::string& component_path)> is_path_overridden_callback;
 
    property_path_context path_context;
    property_path_context pretty_path_context;
 
    entt::handle prefab_root_entity;
    entt::handle entity;
 
    scene prefab_scene{"prefab_diff_scene"};
    uintptr_t prefab_version{};
 
    bool is_active = false;
 
    void set_entity_uuid(const hpp::uuid& uuid);
 
    void set_component_type(const std::string& type, const std::string& pretty_type);
 
    void push_segment(const std::string& segment, const std::string& pretty_segment);
 
    void pop_segment();
 
    auto begin_prefab_inspection(entt::handle entity) -> bool;
 
    void end_prefab_inspection();
 
    auto record_override() -> bool;
 
    auto reset_override() -> bool;
 
    auto is_path_overridden() const -> bool
    {
        return is_path_overridden_callback
                   ? is_path_overridden_callback(path_context.get_entity_uuid(),
                                                 path_context.get_current_path_with_component_type())
                   : false;
    }
 
    static auto find_prefab_root_entity(entt::handle entity) -> entt::handle;
    
    static auto get_entity_prefab_uuid(entt::handle entity) -> hpp::uuid;
    
    static void mark_transform_as_changed(entt::handle entity, bool position, bool rotation, bool scale, bool skew);
    static void mark_transform_global_as_changed(entt::handle entity, bool position, bool rotation, bool scale, bool skew);
 
    static void mark_active_as_changed(entt::handle entity);
    
    static void mark_text_area_as_changed(entt::handle entity);
    static void mark_ui_document_size_as_changed(entt::handle entity);
    static void mark_material_as_changed(entt::handle entity);
 
    static void mark_property_as_changed(entt::handle entity,
                                         const entt::meta_type& component_type,
                                         const std::string& property_path,
                                         const std::string& property_pretty_path = {});
 
    static void mark_property_as_changed(entt::handle entity,
                                        const std::string& component_type_name,
                                        const std::string& component_pretty_type_name,
                                        const std::string& property_path,
                                        const std::string& property_pretty_path = {});
    
    static auto exists_in_prefab(scene& cache_scene,
                                 const asset_handle<prefab>& prefab,
                                 hpp::uuid entity_uuid,
                                 const std::string& component_type,
                                 const std::string& property_path) -> bool;
 
    static void mark_entity_as_removed(entt::handle entity);
};
 
auto add_property_action(rtti::context& ctx,
                         prefab_override_context& override_ctx,
                         inspect_result& result,
                         meta_any_proxy& var_proxy,
                         const entt::meta_any& old_var,
                         const entt::meta_any& new_var,
                         const entt::meta_custom& custom) -> bool;
void push_debug_view();
 
void pop_debug_view();
 
auto is_debug_view() -> bool;
 
auto inspect_var(rtti::context& ctx,
                 entt::meta_any& var,
                 const meta_any_proxy& var_proxy,
                 const var_info& info = {},
                 const entt::meta_custom& custom = {}) -> inspect_result;
 
auto inspect_var_properties(rtti::context& ctx,
                                entt::meta_any& var,
                                const meta_any_proxy& var_proxy,
                                const var_info& info = {},
                                const entt::meta_custom& custom = {}) -> inspect_result;
 
auto inspect_array(rtti::context& ctx,
                       entt::meta_any& var,
                       const meta_any_proxy& var_proxy,
                       const entt::meta_data& prop,
                       const var_info& info = {},
                       const entt::meta_custom& custom = {}) -> inspect_result;
 
auto inspect_array(rtti::context& ctx,
                       entt::meta_any& var,
                       const meta_any_proxy& var_proxy,
                       const std::string& name,
                       const std::string& tooltip,
                       const var_info& info = {},
                       const entt::meta_custom& custom = {}) -> inspect_result;
 
auto inspect_associative_container(rtti::context& ctx,
                                   entt::meta_any& var,
                                   const meta_any_proxy& var_proxy,
                                   const entt::meta_data& prop,
                                   const var_info& info = {},
                                   const entt::meta_custom& custom = {}) -> inspect_result;
 
auto inspect_enum(rtti::context& ctx,
                  entt::meta_any& var,
                  const meta_any_proxy& var_proxy,
                  const var_info& info = {}) -> inspect_result;
 
template<typename T>
auto inspect(rtti::context& ctx, T& obj, const std::string& name = {}) -> inspect_result
{
    entt::meta_any var = entt::forward_as_meta(obj);
    return inspect_var(ctx, var, make_proxy(var, name));
}
 
} // namespace unravel