entity.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "entity_view.hpp"
#include "mixins/entity/builder.hpp"
 
namespace flecs
{
 
struct entity : entity_builder<entity>
{
    entity() : entity_builder<entity>() { }
 
    explicit entity(world_t *world)
        : entity_builder()
    {
        world_ = world;
        if (!ecs_get_scope(world_) && !ecs_get_with(world_)) {
            id_ = ecs_new(world);
        } else {
            ecs_entity_desc_t desc = {};
            id_ = ecs_entity_init(world_, &desc);
        }
    }
 
    explicit entity(const flecs::world_t *world, flecs::entity_t id) {
        world_ = const_cast<flecs::world_t*>(world);
        id_ = id;
    }
 
    explicit entity(world_t *world, const char *name)
        : entity_builder()
    {
        world_ = world;
 
        ecs_entity_desc_t desc = {};
        desc.name = name;
        desc.sep = "::";
        desc.root_sep = "::";
        id_ = ecs_entity_init(world, &desc);
    }
 
    explicit entity(world_t *world, const char *name, const char *sep, const char *root_sep)
        : entity_builder()
    {
        world_ = world;
 
        ecs_entity_desc_t desc = {};
        desc.name = name;
        desc.sep = sep;
        desc.root_sep = root_sep;
        id_ = ecs_entity_init(world, &desc);
    }
 
    explicit entity(entity_t id)
        : entity_builder( nullptr, id ) { }
 
    #ifndef ensure
 
    template <typename T>
    T& ensure() const {
        auto comp_id = _::type<T>::id(world_);
        ecs_assert(_::type<T>::size() != 0, ECS_INVALID_PARAMETER,
            "operation invalid for empty type");
        return *static_cast<T*>(ecs_ensure_id(world_, id_, comp_id, sizeof(T)));
    }
 
    void* ensure(entity_t comp) const {
        const flecs::type_info_t *ti = ecs_get_type_info(world_, comp);
        ecs_assert(ti != nullptr && ti->size != 0, ECS_INVALID_PARAMETER, 
            "provided component is not a type or has size 0");
        return ecs_ensure_id(world_, id_, comp, static_cast<size_t>(ti->size));
    }
 
    template <typename First, typename Second, typename P = pair<First, Second>,
        typename A = actual_type_t<P>, if_not_t< flecs::is_pair<First>::value> = 0>
    A& ensure() const {
        return *static_cast<A*>(ecs_ensure_id(world_, id_, ecs_pair(
            _::type<First>::id(world_),
            _::type<Second>::id(world_)), sizeof(A)));
    }
 
    template <typename First>
    First& ensure(entity_t second) const {
        auto first = _::type<First>::id(world_);
        ecs_assert(_::type<First>::size() != 0, ECS_INVALID_PARAMETER,
            "operation invalid for empty type");
        return *static_cast<First*>(
            ecs_ensure_id(world_, id_, ecs_pair(first, second), sizeof(First)));
    }
 
    void* ensure(entity_t first, entity_t second) const {
        return ensure(ecs_pair(first, second));
    }
 
    template <typename Second>
    Second& ensure_second(entity_t first) const {
        auto second = _::type<Second>::id(world_);
        ecs_assert( ecs_get_type_info(world_, ecs_pair(first, second)) != NULL,
            ECS_INVALID_PARAMETER, "pair is not a component");
        ecs_assert( ecs_get_type_info(world_, ecs_pair(first, second))->component == second,
            ECS_INVALID_PARAMETER, "type of pair is not Second");
        ecs_assert(_::type<Second>::size() != 0, ECS_INVALID_PARAMETER,
            "operation invalid for empty type");
        return *static_cast<Second*>(
            ecs_ensure_id(world_, id_, ecs_pair(first, second), sizeof(Second)));
    }
 
    #endif
 
    template <typename T>
    void modified() const {
        auto comp_id = _::type<T>::id(world_);
        ecs_assert(_::type<T>::size() != 0, ECS_INVALID_PARAMETER,
            "operation invalid for empty type");
        this->modified(comp_id);
    }
 
    template <typename First, typename Second, typename A = actual_type_t<flecs::pair<First, Second>>>
    void modified() const {
        auto first = _::type<First>::id(world_);
        auto second = _::type<Second>::id(world_);
        ecs_assert(_::type<A>::size() != 0, ECS_INVALID_PARAMETER,
            "operation invalid for empty type");
        this->modified(first, second);
    }
 
    template <typename First>
    void modified(entity_t second) const {
        auto first = _::type<First>::id(world_);
        ecs_assert(_::type<First>::size() != 0, ECS_INVALID_PARAMETER,
            "operation invalid for empty type");
        this->modified(first, second);
    }
 
    void modified(entity_t first, entity_t second) const {
        this->modified(ecs_pair(first, second));
    }
 
    void modified(entity_t comp) const {
        ecs_modified_id(world_, id_, comp);
    }
 
    template <typename T, if_t< is_actual<T>::value > = 0>
    ref<T> get_ref_w_id(flecs::id_t component) const {
        _::type<T>::id(world_); // ensure type is registered
        return ref<T>(world_, id_, component);
    }
 
    template <typename T, if_t< is_actual<T>::value > = 0>
    ref<T> get_ref() const {
        return ref<T>(world_, id_, _::type<T>::id(world_));
    }
 
    template <typename T, typename A = actual_type_t<T>, if_t< flecs::is_pair<T>::value > = 0>
    ref<A> get_ref() const {
        return ref<A>(world_, id_,
                      ecs_pair(_::type<typename T::first>::id(world_),
                               _::type<typename T::second>::id(world_)));
    }
 
 
    template <typename First, typename Second, typename P = flecs::pair<First, Second>,
        typename A = actual_type_t<P>>
    ref<A> get_ref() const {
        return ref<A>(world_, id_,
            ecs_pair(_::type<First>::id(world_), _::type<Second>::id(world_)));
    }
 
    template <typename First>
    ref<First> get_ref(flecs::entity_t second) const {
        auto first = _::type<First>::id(world_);
        return ref<First>(world_, id_, ecs_pair(first, second));
    }
 
    untyped_ref get_ref(flecs::id_t component) const {
        return untyped_ref(world_, id_, component);
    } 
 
    untyped_ref get_ref(flecs::id_t first, flecs::id_t second) const {
        return untyped_ref(world_, id_, ecs_pair(first, second));
    } 
 
    template <typename Second>
    ref<Second> get_ref_second(flecs::entity_t first) const {
        auto second = _::type<Second>::id(world_);
        ecs_assert( ecs_get_type_info(world_, ecs_pair(first, second)) != NULL,
            ECS_INVALID_PARAMETER, "pair is not a component");
        ecs_assert( ecs_get_type_info(world_, ecs_pair(first, second))->component == second,
            ECS_INVALID_PARAMETER, "type of pair is not Second");
        return ref<Second>(world_, id_, ecs_pair(first, second));
    }
 
    void clear() const {
        ecs_clear(world_, id_);
    }
 
    void destruct() const {
        ecs_delete(world_, id_);
    }
 
    template <typename ... Args>
    flecs::entity child(flecs::entity_t r = flecs::ChildOf, Args&&... args) {
        flecs::world world(world_);
        return world.entity(FLECS_FWD(args)...).add(r, id_);
    }
 
    template <typename R, typename ... Args>
    flecs::entity child(Args&&... args) {
        flecs::world world(world_);
        return world.entity(FLECS_FWD(args)...).add(_::type<R>::id(world_), id_);
    }
 
    void set_child_order(flecs::entity_t *children, int32_t child_count) const {
        ecs_set_child_order(world_, id_, children, child_count);
    }
 
    flecs::entity_view view() const {
        return flecs::entity_view(
            const_cast<flecs::world_t*>(ecs_get_world(world_)), id_);
    }
 
    static
    flecs::entity null(const flecs::world_t *world) {
        flecs::entity result;
        result.world_ = const_cast<flecs::world_t*>(world);
        return result;
    }
 
    static
    flecs::entity null() {
        return flecs::entity();
    }
 
#   ifdef FLECS_JSON
#   include "mixins/json/entity.inl"
#   endif
};
 
} // namespace flecs