world.hpp

Go to the documentation of this file.

 
#pragma once
 
namespace flecs
{
 
/* Static helper functions to assign a component value */
 
// set(T&&), T = constructible
template <typename T, if_t< is_flecs_constructible<T>::value > = 0>
inline void set(world_t *world, flecs::entity_t entity, T&& value, flecs::id_t id) {
    ecs_assert(_::cpp_type<T>::size() != 0, ECS_INVALID_PARAMETER, NULL);
 
    if (!ecs_is_deferred(world)) {
        T& dst = *static_cast<T*>(ecs_get_mut_id(world, entity, id));
        dst = FLECS_MOV(value);
 
        ecs_modified_id(world, entity, id);
    } else {
        T& dst = *static_cast<T*>(ecs_get_mut_modified_id(world, entity, id));
        dst = FLECS_MOV(value);
    }
}
 
// set(const T&), T = constructible
template <typename T, if_t< is_flecs_constructible<T>::value > = 0>
inline void set(world_t *world, flecs::entity_t entity, const T& value, flecs::id_t id) {
    ecs_assert(_::cpp_type<T>::size() != 0, ECS_INVALID_PARAMETER, NULL);
 
    if (!ecs_is_deferred(world)) {
        T& dst = *static_cast<T*>(ecs_get_mut_id(world, entity, id));
        dst = FLECS_MOV(value);
 
        ecs_modified_id(world, entity, id);
    } else {
        T& dst = *static_cast<T*>(ecs_get_mut_modified_id(world, entity, id));
        dst = FLECS_MOV(value);
    }
}
 
// set(T&&), T = not constructible
template <typename T, if_not_t< is_flecs_constructible<T>::value > = 0>
inline void set(world_t *world, flecs::entity_t entity, T&& value, flecs::id_t id) {
    ecs_assert(_::cpp_type<T>::size() != 0, ECS_INVALID_PARAMETER, NULL);
 
    if (!ecs_is_deferred(world)) {
        T& dst = *static_cast<remove_reference_t<T>*>(ecs_get_mut_id(world, entity, id));
        dst = FLECS_MOV(value);
 
        ecs_modified_id(world, entity, id);
    } else {
        T& dst = *static_cast<remove_reference_t<T>*>(ecs_get_mut_modified_id(world, entity, id));
        dst = FLECS_MOV(value);
    }
}
 
// set(const T&), T = not constructible
template <typename T, if_not_t< is_flecs_constructible<T>::value > = 0>
inline void set(world_t *world, flecs::entity_t entity, const T& value, flecs::id_t id) {
    ecs_assert(_::cpp_type<T>::size() != 0, ECS_INVALID_PARAMETER, NULL);
 
    if (!ecs_is_deferred(world)) {
        T& dst = *static_cast<remove_reference_t<T>*>(ecs_get_mut_id(world, entity, id));
        dst = FLECS_MOV(value);
 
        ecs_modified_id(world, entity, id);
    } else {
        T& dst = *static_cast<remove_reference_t<T>*>(ecs_get_mut_modified_id(world, entity, id));
        dst = FLECS_MOV(value);
    }
}
 
// emplace for T(Args...)
template <typename T, typename ... Args, if_t< 
    std::is_constructible<actual_type_t<T>, Args...>::value ||
    std::is_default_constructible<actual_type_t<T>>::value > = 0>
inline void emplace(world_t *world, flecs::entity_t entity, flecs::id_t id, Args&&... args) {
    ecs_assert(_::cpp_type<T>::size() != 0, ECS_INVALID_PARAMETER, NULL);
    T& dst = *static_cast<T*>(ecs_emplace_id(world, entity, id));
    
    FLECS_PLACEMENT_NEW(&dst, T{FLECS_FWD(args)...});
 
    ecs_modified_id(world, entity, id);    
}
 
// set(T&&)
template <typename T, typename A>
inline void set(world_t *world, entity_t entity, A&& value) {
    id_t id = _::cpp_type<T>::id(world);
    flecs::set(world, entity, FLECS_FWD(value), id);
}
 
// set(const T&)
template <typename T, typename A>
inline void set(world_t *world, entity_t entity, const A& value) {
    id_t id = _::cpp_type<T>::id(world);
    flecs::set(world, entity, value, id);
}
 
inline flecs::id_t strip_generation(flecs::entity_t e) {
    return ecs_strip_generation(e);
}
 
inline uint32_t get_generation(flecs::entity_t e) {
    return ECS_GENERATION(e);
}
 
struct scoped_world;
 
struct world {
    explicit world() 
        : m_world( ecs_init() )
        , m_owned( true ) { init_builtin_components(); }
 
    explicit world(int argc, char *argv[])
        : m_world( ecs_init_w_args(argc, argv) )
        , m_owned( true ) { init_builtin_components(); }
 
    explicit world(world_t *w)
        : m_world( w ) 
        , m_owned( false ) { }
 
    world(const world& obj) = delete;
 
    world(world&& obj) {
        m_world = obj.m_world;
        m_owned = obj.m_owned;
        obj.m_world = nullptr;
        obj.m_owned = false;
    }
 
    /* Implicit conversion to world_t* */
    operator world_t*() const { return m_world; }
 
    world& operator=(const world& obj) = delete;
 
    world& operator=(world&& obj) {
        this->~world();
 
        m_world = obj.m_world;
        m_owned = obj.m_owned;
        obj.m_world = nullptr;
        obj.m_owned = false;
        return *this;
    }
    
    ~world() { 
        if (m_owned && ecs_stage_is_async(m_world)) {
            ecs_async_stage_free(m_world);
        } else
        if (m_owned && m_world) {
            ecs_fini(m_world); 
        }
    }
 
    void reset() {
        // Can only reset the world if we own the world object.
        ecs_assert(this->m_owned, ECS_INVALID_OPERATION, NULL);
        ecs_fini(m_world);
        m_world = ecs_init();
    }
 
    world_t* c_ptr() const {
        return m_world;
    }
 
    void quit() const {
        ecs_quit(m_world);
    }
 
    void atfini(ecs_fini_action_t action, void *ctx) const {
        ecs_atfini(m_world, action, ctx);
    }
 
    bool should_quit() const {
        return ecs_should_quit(m_world);
    }
 
    ecs_ftime_t frame_begin(float delta_time = 0) const {
        return ecs_frame_begin(m_world, delta_time);
    }
 
    void frame_end() const {
        ecs_frame_end(m_world);
    }
 
    bool readonly_begin() const {
        return ecs_readonly_begin(m_world);
    }
 
    void readonly_end() const {
        ecs_readonly_end(m_world);
    }
 
    bool defer_begin() const {
        return ecs_defer_begin(m_world);
    }
 
    bool defer_end() const {
        return ecs_defer_end(m_world);
    }
 
    bool is_deferred() const {
        return ecs_is_deferred(m_world);
    }
 
    void set_stage_count(int32_t stages) const {
        ecs_set_stage_count(m_world, stages);
    }
 
    int32_t get_stage_count() const {
        return ecs_get_stage_count(m_world);
    }
 
    int32_t get_stage_id() const {
        return ecs_get_stage_id(m_world);
    }
 
    bool is_stage() const {
        ecs_assert(
            ecs_poly_is(m_world, ecs_world_t) || 
            ecs_poly_is(m_world, ecs_stage_t),
                ECS_INVALID_PARAMETER, NULL);
        return ecs_poly_is(m_world, ecs_stage_t);
    }
 
    void set_automerge(bool automerge) const {
        ecs_set_automerge(m_world, automerge);
    }
 
    void merge() const {
        ecs_merge(m_world);
    }
 
    flecs::world get_stage(int32_t stage_id) const {
        return flecs::world(ecs_get_stage(m_world, stage_id));
    }
 
    flecs::world async_stage() const {
        auto result = flecs::world(ecs_async_stage_new(m_world));
        result.m_owned = true;
        return result;
    }
 
    flecs::world get_world() const {
        /* Safe cast, mutability is checked */
        return flecs::world(
            m_world ? const_cast<flecs::world_t*>(ecs_get_world(m_world)) : nullptr);
    }
 
    bool is_readonly() const {
        return ecs_stage_is_readonly(m_world);
    }
 
    void set_ctx(void* ctx, ecs_ctx_free_t ctx_free = nullptr) const {
        ecs_set_ctx(m_world, ctx, ctx_free);
    }
 
    void* get_ctx() const {
        return ecs_get_ctx(m_world);
    }
 
    void set_binding_ctx(void* ctx, ecs_ctx_free_t ctx_free = nullptr) const {
        ecs_set_binding_ctx(m_world, ctx, ctx_free);
    }
 
    void* get_binding_ctx() const {
        return ecs_get_binding_ctx(m_world);
    }
 
    void dim(int32_t entity_count) const {
        ecs_dim(m_world, entity_count);
    }
 
    void set_entity_range(entity_t min, entity_t max) const {
        ecs_set_entity_range(m_world, min, max);
    }
 
    void enable_range_check(bool enabled) const {
        ecs_enable_range_check(m_world, enabled);
    }
 
    flecs::entity set_scope(const flecs::entity_t scope) const;
 
    flecs::entity get_scope() const;
 
    template <typename T>
    flecs::entity set_scope() const;
 
    flecs::entity_t* set_lookup_path(const flecs::entity_t *search_path) const {
        return ecs_set_lookup_path(m_world, search_path);
    }
 
    flecs::entity lookup(const char *name, bool search_path = true) const;
 
    template <typename T, if_t< !is_callable<T>::value > = 0>
    void set(const T& value) const {
        flecs::set<T>(m_world, _::cpp_type<T>::id(m_world), value);
    }
 
    template <typename T, if_t< !is_callable<T>::value > = 0>
    void set(T&& value) const {
        flecs::set<T>(m_world, _::cpp_type<T>::id(m_world), 
            FLECS_FWD(value));
    }
 
    template <typename First, typename Second, typename P = flecs::pair<First, Second>, 
        typename A = actual_type_t<P>, if_not_t< flecs::is_pair<First>::value> = 0>
    void set(const A& value) const {
        flecs::set<P>(m_world, _::cpp_type<First>::id(m_world), value);
    }
 
    template <typename First, typename Second, typename P = flecs::pair<First, Second>, 
        typename A = actual_type_t<P>, if_not_t< flecs::is_pair<First>::value> = 0>
    void set(A&& value) const {
        flecs::set<P>(m_world, _::cpp_type<First>::id(m_world), FLECS_FWD(value));
    }
 
    template <typename First, typename Second>
    void set(Second second, const First& value) const;
 
    template <typename First, typename Second>
    void set(Second second, First&& value) const;
 
    template <typename Func, if_t< is_callable<Func>::value > = 0 >
    void set(const Func& func) const;
 
    template <typename T, typename ... Args>
    void emplace(Args&&... args) const {
        flecs::id_t component_id = _::cpp_type<T>::id(m_world);
        flecs::emplace<T>(m_world, component_id, component_id,
            FLECS_FWD(args)...);
    }        
 
    template <typename T>
    T* get_mut() const;
 
    template <typename T>
    void modified() const;
 
    template <typename T>
    ref<T> get_ref() const;
 
    template <typename T>
    const T* get() const;
 
    template <typename First, typename Second, typename P = flecs::pair<First, Second>, 
        typename A = actual_type_t<P>>
    const A* get() const;
 
    template <typename First, typename Second>
    const First* get(Second second) const;
    
    template <typename Func, if_t< is_callable<Func>::value > = 0 >
    void get(const Func& func) const;
 
    template <typename T>
    bool has() const;
 
    template <typename First, typename Second>
    bool has() const;
 
    template <typename First>
    bool has(flecs::id_t second) const;
 
    bool has(flecs::id_t first, flecs::id_t second) const;
 
    template <typename T>
    void add() const;
 
    template <typename First, typename Second>
    void add() const;
 
    template <typename First>
    void add(flecs::entity_t second) const;
 
    void add(flecs::entity_t first, flecs::entity_t second) const;
 
    template <typename T>
    void remove() const;
 
    template <typename First, typename Second>
    void remove() const;
 
    template <typename First>
    void remove(flecs::entity_t second) const;
 
    void remove(flecs::entity_t first, flecs::entity_t second) const;
 
    template <typename Func>
    void children(Func&& f) const;
 
    template <typename T>
    flecs::entity singleton() const;
 
    template<typename First>
    flecs::entity target(int32_t index = 0) const;
 
    template<typename T>
    flecs::entity target(flecs::entity_t first, int32_t index = 0) const;
 
    flecs::entity target(flecs::entity_t first, int32_t index = 0) const;
 
    template <typename T>
    flecs::entity use(const char *alias = nullptr) const;
 
    flecs::entity use(const char *name, const char *alias = nullptr) const;    
 
    void use(flecs::entity entity, const char *alias = nullptr) const;   
 
    int count(flecs::id_t component_id) const {
        return ecs_count_id(m_world, component_id);
    }
 
    int count(flecs::entity_t first, flecs::entity_t second) const {
        return ecs_count_id(m_world, ecs_pair(first, second));
    }
 
    template <typename T>
    int count() const {
        return count(_::cpp_type<T>::id(m_world));
    }
 
    template <typename First>
    int count(flecs::entity_t second) const {
        return count(_::cpp_type<First>::id(m_world), second);
    }
 
    template <typename First, typename Second>
    int count() const {
        return count( 
            _::cpp_type<First>::id(m_world),
            _::cpp_type<Second>::id(m_world));
    }
 
    template <typename Func>
    void with(id_t with_id, const Func& func) const {
        ecs_id_t prev = ecs_set_with(m_world, with_id);
        func();
        ecs_set_with(m_world, prev);    
    }
 
    template <typename T, typename Func>
    void with(const Func& func) const {
        with(this->id<T>(), func);
    }
 
    template <typename First, typename Second, typename Func>
    void with(const Func& func) const {
        with(ecs_pair(this->id<First>(), this->id<Second>()), func);
    }
 
    template <typename First, typename Func>
    void with(id_t second, const Func& func) const {
        with(ecs_pair(this->id<First>(), second), func);
    } 
 
    template <typename Func>
    void with(id_t first, id_t second, const Func& func) const {
        with(ecs_pair(first, second), func);
    }
 
    template <typename Func>
    void scope(id_t parent, const Func& func) const {
        ecs_entity_t prev = ecs_set_scope(m_world, parent);
        func();
        ecs_set_scope(m_world, prev);
    }
    
    template <typename T, typename Func>
    void scope(const Func& func) const {
        flecs::id_t parent = _::cpp_type<T>::id(m_world);
        scope(parent, func);
    }
 
    flecs::scoped_world scope(id_t parent) const;
 
    template <typename T>
    flecs::scoped_world scope() const;
 
    flecs::scoped_world scope(const char* name) const;
 
    void delete_with(id_t the_id) const {
        ecs_delete_with(m_world, the_id);
    }
 
    void delete_with(entity_t first, entity_t second) const {
        delete_with(ecs_pair(first, second));
    }
 
    template <typename T>
    void delete_with() const {
        delete_with(_::cpp_type<T>::id(m_world));
    }
 
    template <typename First, typename Second>
    void delete_with() const {
        delete_with(_::cpp_type<First>::id(m_world), _::cpp_type<Second>::id(m_world));
    }
 
    void remove_all(id_t the_id) const {
        ecs_remove_all(m_world, the_id);
    }
 
    void remove_all(entity_t first, entity_t second) const {
        remove_all(ecs_pair(first, second));
    }
 
    template <typename T>
    void remove_all() const {
        remove_all(_::cpp_type<T>::id(m_world));
    }
 
    template <typename First, typename Second>
    void remove_all() const {
        remove_all(_::cpp_type<First>::id(m_world), _::cpp_type<Second>::id(m_world));
    }
 
    template <typename Func>
    void defer(const Func& func) const {
        ecs_defer_begin(m_world);
        func();
        ecs_defer_end(m_world);
    }
 
    void defer_suspend() const {
        ecs_defer_suspend(m_world);
    }
 
    void defer_resume() const {
        ecs_defer_resume(m_world);
    }
 
    bool exists(flecs::entity_t e) const {
        return ecs_exists(m_world, e);
    }
 
    bool is_alive(flecs::entity_t e) const {
        return ecs_is_alive(m_world, e);
    }
 
    bool is_valid(flecs::entity_t e) const {
        return ecs_is_valid(m_world, e);
    }
 
    flecs::entity get_alive(flecs::entity_t e) const;
 
/* Prevent clashing with Unreal define. Unreal applications will have to use
 *  ecs_ensure. */
#ifndef ensure
    flecs::entity ensure(flecs::entity_t e) const;
#endif
 
    /* Run callback after completing frame */
    void run_post_frame(ecs_fini_action_t action, void *ctx) const {
        ecs_run_post_frame(m_world, action, ctx);
    }
 
    const flecs::world_info_t* get_info() const{
        return ecs_get_world_info(m_world);
    }
 
#   include "mixins/id/mixin.inl"
#   include "mixins/component/mixin.inl"
#   include "mixins/entity/mixin.inl"
#   include "mixins/event/mixin.inl"
#   include "mixins/term/mixin.inl"
#   include "mixins/filter/mixin.inl"
#   include "mixins/observer/mixin.inl"
#   include "mixins/query/mixin.inl"
#   include "mixins/enum/mixin.inl"
 
#   ifdef FLECS_MODULE
#   include "mixins/module/mixin.inl"
#   endif
#   ifdef FLECS_PIPELINE
#   include "mixins/pipeline/mixin.inl"
#   endif
#   ifdef FLECS_SNAPSHOT
#   include "mixins/snapshot/mixin.inl"
#   endif
#   ifdef FLECS_SYSTEM
#   include "mixins/system/mixin.inl"
#   endif
#   ifdef FLECS_TIMER
#   include "mixins/timer/mixin.inl"
#   endif
#   ifdef FLECS_RULES
#   include "mixins/rule/mixin.inl"
#   endif
#   ifdef FLECS_PLECS
#   include "mixins/plecs/mixin.inl"
#   endif
#   ifdef FLECS_META
#   include "mixins/meta/world.inl"
#   endif
#   ifdef FLECS_JSON
#   include "mixins/json/world.inl"
#   endif
#   ifdef FLECS_APP
#   include "mixins/app/mixin.inl"
#   endif
#   ifdef FLECS_METRICS
#   include "mixins/metrics/mixin.inl"
#   endif
#   ifdef FLECS_ALERTS
#   include "mixins/alerts/mixin.inl"
#   endif
 
public:
    void init_builtin_components();
 
    world_t *m_world;
    bool m_owned;
};
 
struct scoped_world : world {
    scoped_world(
        flecs::world_t *w, 
        flecs::entity_t s) : world(nullptr)
    {
        m_prev_scope = ecs_set_scope(w, s);
        m_world = w;
        m_owned = false;
    }
 
    ~scoped_world() {
        ecs_set_scope(m_world, m_prev_scope);
    }
 
    scoped_world(const scoped_world& obj) : world(nullptr) {
        m_prev_scope = obj.m_prev_scope;
        m_world = obj.m_world;
        m_owned = obj.m_owned;
    }
 
    flecs::entity_t m_prev_scope;
};
 
} // namespace flecs