scene.h

Go to the documentation of this file.

#pragma once
#include <engine/engine_export.h>
 
#include <uuid/uuid.h>
 
#include "prefab.h"
#include <base/basetypes.hpp>
#include <context/context.hpp>
#include <engine/assets/asset_handle.h>
#include <entt/entt.hpp>
#include <entt/signal/sigh.hpp>
#include <functional>
 
using namespace entt::literals;
 
namespace unravel
{
 
template<class T>
struct on_load_bus
{
    using sink_t = typename entt::sink<entt::sigh<void(entt::registry&, entt::entity)>>;
    entt::sigh<void(entt::registry&, entt::entity)> sig;
};
 
template<class T>
inline auto on_load(entt::registry& reg) -> typename on_load_bus<T>::sink_t
{
    auto& ctx = reg.ctx();
    if(!ctx.contains<on_load_bus<T>>())
    {
        return typename on_load_bus<T>::sink_t(ctx.emplace<on_load_bus<T>>().sig);
    }
    return typename on_load_bus<T>::sink_t(ctx.get<on_load_bus<T>>().sig);
}
 
template<class T>
inline auto on_construct(entt::registry& reg) -> decltype(auto)
{
    return reg.on_construct<T>();
}
 
template<class T>
inline auto on_update(entt::registry& reg) -> decltype(auto)
{
    return reg.on_update<T>();
}
 
template<class T>
inline auto on_destroy(entt::registry& reg) -> decltype(auto)
{
    return reg.on_destroy<T>();
}
 
template<class T>
inline void emit_on_load(entt::registry& reg, entt::entity e)
{
    if (auto* bus = reg.ctx().find<on_load_bus<T>>())
    {
        bus->sig.publish(reg, e);
    }
}
 
#define ENTT_TAG(name) entt::tag<name##_hs>
struct scene
{
    scene(const std::string& tag_name);
 
    ~scene();
 
    static auto get_all_scenes() -> const std::vector<scene*>&;
    auto load_from(const asset_handle<scene_prefab>& pfb, bool call_callbacks = true) -> bool;
 
    void reload(bool call_callbacks = true);
    void unload();
 
    auto instantiate_out(const asset_handle<prefab>& pfb, entt::handle&, bool call_callbacks = true) -> bool;
    static auto instantiate_out(entt::registry& reg, const asset_handle<prefab>& pfb, entt::handle&, bool call_callbacks = true) -> bool;
    auto instantiate(const asset_handle<prefab>& pfb, bool call_callbacks = true) -> entt::handle;
    auto instantiate(const asset_handle<prefab>& pfb, entt::handle parent, bool call_callbacks = true) -> entt::handle;
 
    void clear_entity(entt::handle& handle);
    auto create_handle(entt::entity e) -> entt::handle;
 
    auto create_handle(entt::entity e) const -> entt::const_handle;
 
    auto create_entity(const std::string& tag = {}, entt::handle parent = {}) -> entt::handle;
 
    auto clone_entity(entt::handle clone_from, bool keep_parent = true, bool call_callbacks = true) -> entt::handle;
    void clone_entity(entt::handle& clone_to, entt::handle clone_from, bool keep_parent = true, bool call_callbacks = true);
 
    static auto create_entity(entt::registry& r, const std::string& name = {}, entt::handle parent = {}) -> entt::handle;
 
    static void clone_scene(const scene& src_scene, scene& dst_scene, bool call_callbacks = true);
 
    static auto find_entity_by_prefab_uuid(entt::handle root_entity, const hpp::uuid& target_uuid) -> entt::handle;
 
     auto find_entity_by_uuid(const hpp::uuid& target_uuid) const -> entt::handle;
 
     static auto get_scene(entt::handle entity) -> scene*;
 
 
    asset_handle<scene_prefab> source;
 
    std::unique_ptr<entt::registry> registry{};
 
 
    std::string tag{};
};
 
 
#define TAG_COMPONENT(name) entt::tag<name##_hs>
 
ENGINE_EXPORT auto find_entity_by_uuid(entt::registry& registry, const hpp::uuid& target_uuid) -> entt::handle;
 
 
} // namespace unravel
 
namespace entt
{
struct uhandle
{
    uhandle() = default;
    uhandle(entt::handle handle);
    uhandle(entt::registry& registry, const hpp::uuid& uuid) : registry(&registry), uuid(uuid) {}
    uhandle(const uhandle& other) = default;
    uhandle(uhandle&& other) = default;
    auto operator=(const uhandle& other) -> uhandle& = default;
    auto operator=(uhandle&& other) -> uhandle& = default;
    ~uhandle() = default;
    auto resolve() const -> entt::handle;
    auto operator==(const uhandle& other) const -> bool
    {
        return registry == other.registry && uuid == other.uuid;
    }
    auto operator!=(const uhandle& other) const -> bool
    {
        return !(*this == other);
    }
    entt::registry* registry{};
    hpp::uuid uuid{};
};
 
inline auto make_uhandle(entt::handle handle) -> uhandle
{
    return uhandle(handle);
}
}