world.hpp

Go to the documentation of this file.

 
#pragma once
 
namespace flecs
{
 
/* Static helper functions to assign a component value */
 
// set(T&&)
template <typename T>
inline void set(world_t *world, flecs::entity_t entity, T&& value, flecs::id_t id) {
    ecs_assert(_::type<T>::size() != 0, ECS_INVALID_PARAMETER,
            "operation invalid for empty type");
 
    ecs_cpp_get_mut_t res = ecs_cpp_set(world, entity, id, &value, sizeof(T));
 
    T& dst = *static_cast<remove_reference_t<T>*>(res.ptr);
    if constexpr (std::is_copy_assignable_v<T>) {
        dst = FLECS_FWD(value);
    } else {
        dst = FLECS_MOV(value);
    }
 
    if (res.stage) {
        flecs_defer_end(res.world, res.stage);
    }
 
    if (res.call_modified) {
        ecs_modified_id(world, entity, id);
    }
}
 
// set(const T&)
template <typename T>
inline void set(world_t *world, flecs::entity_t entity, const T& value, flecs::id_t id) {
    ecs_assert(_::type<T>::size() != 0, ECS_INVALID_PARAMETER,
            "operation invalid for empty type");
 
    ecs_cpp_get_mut_t res = ecs_cpp_set(world, entity, id, &value, sizeof(T));
 
    T& dst = *static_cast<remove_reference_t<T>*>(res.ptr);
    dst = value;
 
    if (res.stage) {
        flecs_defer_end(res.world, res.stage);
    }
 
    if (res.call_modified) {
        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 = _::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 = _::type<T>::id(world);
    flecs::set(world, entity, value, id);
}
 
// assign(T&&)
template <typename T>
inline void assign(world_t *world, flecs::entity_t entity, T&& value, flecs::id_t id) {
    ecs_assert(_::type<remove_reference_t<T>>::size() != 0, 
        ECS_INVALID_PARAMETER, "operation invalid for empty type");
 
    ecs_cpp_get_mut_t res = ecs_cpp_assign(
        world, entity, id, &value, sizeof(T));
 
    T& dst = *static_cast<remove_reference_t<T>*>(res.ptr);
    if constexpr (std::is_copy_assignable_v<T>) {
        dst = FLECS_FWD(value);
    } else {
        dst = FLECS_MOV(value);
    }
 
    if (res.stage) {
        flecs_defer_end(res.world, res.stage);
    }
 
    if (res.call_modified) {
        ecs_modified_id(world, entity, id);
    }
}
 
// assign(const T&)
template <typename T>
inline void assign(world_t *world, flecs::entity_t entity, const T& value, flecs::id_t id) {
    ecs_assert(_::type<remove_reference_t<T>>::size() != 0, 
        ECS_INVALID_PARAMETER, "operation invalid for empty type");
 
    ecs_cpp_get_mut_t res = ecs_cpp_assign(
        world, entity, id, &value, sizeof(T));
 
    T& dst = *static_cast<remove_reference_t<T>*>(res.ptr);
    dst = value;
 
    if (res.stage) {
        flecs_defer_end(res.world, res.stage);
    }
 
    if (res.call_modified) {
        ecs_modified_id(world, entity, id);
    }
}
 
// set(T&&)
template <typename T, typename A>
inline void assign(world_t *world, entity_t entity, A&& value) {
    id_t id = _::type<T>::id(world);
    flecs::assign(world, entity, FLECS_FWD(value), id);
}
 
// set(const T&)
template <typename T, typename A>
inline void assign(world_t *world, entity_t entity, const A& value) {
    id_t id = _::type<T>::id(world);
    flecs::assign(world, entity, value, id);
}
 
 
// 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(_::type<T>::size() != 0, ECS_INVALID_PARAMETER,
            "operation invalid for empty type");
    T& dst = *static_cast<T*>(ecs_emplace_id(world, entity, id, sizeof(T), nullptr));
 
    FLECS_PLACEMENT_NEW(&dst, T{FLECS_FWD(args)...});
 
    ecs_modified_id(world, entity, 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()
        : world_( ecs_init() ) { 
            init_builtin_components(); 
        }
 
    explicit world(int argc, char *argv[])
        : world_( ecs_init_w_args(argc, argv) ) { 
            init_builtin_components(); 
        }
 
    explicit world(world_t *w)
        : world_( w ) { 
            if (w) {
                flecs_poly_claim(w);
            }
        }
 
    world(const world& obj) {
        this->world_ = obj.world_;
        flecs_poly_claim(this->world_);
    }
 
    world& operator=(const world& obj) noexcept {
        release();
        this->world_ = obj.world_;
        flecs_poly_claim(this->world_);
        return *this;
    }
 
    world(world&& obj) noexcept {
        world_ = obj.world_;
        obj.world_ = nullptr;
    }
 
    world& operator=(world&& obj) noexcept {
        release();
        world_ = obj.world_;
        obj.world_ = nullptr;
        return *this;
    }
 
    /* Releases the underlying world object. If this is the last handle, the world
       will be finalized. */
    void release() {
        if (world_) {
            if (!flecs_poly_release(world_)) {
                if (ecs_stage_get_id(world_) == -1) {
                    ecs_stage_free(world_);
                } else {
                    // before we call ecs_fini(), we increment the reference count back to 1
                    // otherwise, copies of this object created during ecs_fini (e.g. a component on_remove hook)
                    // would call again this destructor and ecs_fini().
                    flecs_poly_claim(world_);
                    ecs_fini(world_);
                }
            }
            world_ = nullptr;
        }        
    }
 
    ~world() {
        release();
    }
 
    /* Implicit conversion to world_t* */
    operator world_t*() const { return world_; }
 
    void make_owner() {
        flecs_poly_release(world_);
    }
 
    void reset() {
        /* Make sure there's only one reference to the world */
        ecs_assert(flecs_poly_refcount(world_) == 1, ECS_INVALID_OPERATION,
            "reset would invalidate other handles");
        ecs_fini(world_);
        world_ = ecs_init();
    }
 
    world_t* c_ptr() const {
        return world_;
    }
 
    void quit() const {
        ecs_quit(world_);
    }
 
    void atfini(ecs_fini_action_t action, void *ctx = nullptr) const {
        ecs_atfini(world_, action, ctx);
    }
 
    bool should_quit() const {
        return ecs_should_quit(world_);
    }
 
    ecs_ftime_t frame_begin(float delta_time = 0) const {
        return ecs_frame_begin(world_, delta_time);
    }
 
    void frame_end() const {
        ecs_frame_end(world_);
    }
 
    bool readonly_begin(bool multi_threaded = false) const {
        return ecs_readonly_begin(world_, multi_threaded);
    }
 
    void readonly_end() const {
        ecs_readonly_end(world_);
    }
 
    bool defer_begin() const {
        return ecs_defer_begin(world_);
    }
 
    bool defer_end() const {
        return ecs_defer_end(world_);
    }
 
    bool is_deferred() const {
        return ecs_is_deferred(world_);
    }
 
    bool is_defer_suspended() const {
        return ecs_is_defer_suspended(world_);
    }
 
    void set_stage_count(int32_t stages) const {
        ecs_set_stage_count(world_, stages);
    }
 
    int32_t get_stage_count() const {
        return ecs_get_stage_count(world_);
    }
 
    int32_t get_stage_id() const {
        return ecs_stage_get_id(world_);
    }
 
    bool is_stage() const {
        ecs_assert(
            flecs_poly_is(world_, ecs_world_t) ||
            flecs_poly_is(world_, ecs_stage_t), 
                ECS_INVALID_PARAMETER, 
                "flecs::world instance contains invalid reference to world or stage");
        return flecs_poly_is(world_, ecs_stage_t);
    }
 
    void merge() const {
        ecs_merge(world_);
    }
 
    flecs::world get_stage(int32_t stage_id) const {
        return flecs::world(ecs_get_stage(world_, stage_id));
    }
 
    flecs::world async_stage() const {
        ecs_world_t *as = ecs_stage_new(world_);
        flecs_poly_release(as); // world object will claim
        return flecs::world(as);
    }
 
    flecs::world get_world() const {
        /* Safe cast, mutability is checked */
        return flecs::world(
            world_ ? const_cast<flecs::world_t*>(ecs_get_world(world_)) : nullptr);
    }
 
    bool is_readonly() const {
        return ecs_stage_is_readonly(world_);
    }
 
    void set_ctx(void* ctx, ecs_ctx_free_t ctx_free = nullptr) const {
        ecs_set_ctx(world_, ctx, ctx_free);
    }
 
    void* get_ctx() const {
        return ecs_get_ctx(world_);
    }
 
    void set_binding_ctx(void* ctx, ecs_ctx_free_t ctx_free = nullptr) const {
        ecs_set_binding_ctx(world_, ctx, ctx_free);
    }
 
    void* get_binding_ctx() const {
        return ecs_get_binding_ctx(world_);
    }
 
    void dim(int32_t entity_count) const {
        ecs_dim(world_, entity_count);
    }
 
    void set_entity_range(entity_t min, entity_t max) const {
        ecs_set_entity_range(world_, min, max);
    }
 
    void enable_range_check(bool enabled = true) const {
        ecs_enable_range_check(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(world_, search_path);
    }
 
    flecs::entity lookup(const char *name, const char *sep = "::", const char *root_sep = "::", bool recursive = true) const;
 
    template <typename T, if_t< !is_callable<T>::value > = 0>
    void set(const T& value) const {
        flecs::set<T>(world_, _::type<T>::id(world_), value);
    }
 
    template <typename T, if_t< !is_callable<T>::value > = 0>
    void set(T&& value) const {
        flecs::set<T>(world_, _::type<T>::id(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>(world_, _::type<First>::id(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>(world_, _::type<First>::id(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 = _::type<T>::id(world_);
        flecs::emplace<T>(world_, component_id, component_id, FLECS_FWD(args)...);
    }
 
    #ifndef ensure
    template <typename T>
    T& ensure() const;
    #endif
 
    template <typename T>
    void modified() const;
 
    template <typename T>
    ref<T> get_ref() const;
 
 
    /* try_get */
 
    const void* try_get(flecs::id_t id) const;
 
    const void* try_get(flecs::entity_t r, flecs::entity_t t) const;
 
    template <typename T>
    const T* try_get() const;
 
    template <typename First, typename Second, typename P = flecs::pair<First, Second>,
        typename A = actual_type_t<P>>
    const A* try_get() const;
 
    template <typename First, typename Second>
    const First* try_get(Second second) const;
 
 
    /* get */
 
    const void* get(flecs::id_t id) const;
 
    const void* get(flecs::entity_t r, flecs::entity_t t) 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;
 
 
    /* try_get_mut */
 
    void* try_get_mut(flecs::id_t id) const;
 
    void* try_get_mut(flecs::entity_t r, flecs::entity_t t) const;
 
    template <typename T>
    T* try_get_mut() const;
 
    template <typename First, typename Second, typename P = flecs::pair<First, Second>,
        typename A = actual_type_t<P>>
    A* try_get_mut() const;
 
    template <typename First, typename Second>
    First* try_get_mut(Second second) const;
 
 
    /* get_mut */
 
    void* get_mut(flecs::id_t id) const;
 
    void* get_mut(flecs::entity_t r, flecs::entity_t t) const;
 
    template <typename T>
    T& get_mut() const;
 
    template <typename First, typename Second, typename P = flecs::pair<First, Second>,
        typename A = actual_type_t<P>>
    A& get_mut() const;
 
    template <typename First, typename Second>
    First& get_mut(Second second) 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 E, if_t< is_enum<E>::value > = 0>
    bool has(E value) 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 E, if_t< is_enum<E>::value > = 0>
    void add(E value) 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(world_, component_id);
    }
 
    int count(flecs::entity_t first, flecs::entity_t second) const {
        return ecs_count_id(world_, ecs_pair(first, second));
    }
 
    template <typename T>
    int count() const {
        return count(_::type<T>::id(world_));
    }
 
    template <typename First>
    int count(flecs::entity_t second) const {
        return count(_::type<First>::id(world_), second);
    }
 
    template <typename First, typename Second>
    int count() const {
        return count(
            _::type<First>::id(world_),
            _::type<Second>::id(world_));
    }
 
    template <typename Func>
    void with(id_t with_id, const Func& func) const {
        ecs_id_t prev = ecs_set_with(world_, with_id);
        func();
        ecs_set_with(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(world_, parent);
        func();
        ecs_set_scope(world_, prev);
    }
 
    template <typename T, typename Func>
    void scope(const Func& func) const {
        flecs::id_t parent = _::type<T>::id(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(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(_::type<T>::id(world_));
    }
 
    template <typename First, typename Second>
    void delete_with() const {
        delete_with(_::type<First>::id(world_), _::type<Second>::id(world_));
    }
 
    template <typename First>
    void delete_with(entity_t second) const {
        delete_with(_::type<First>::id(world_), second);
    }
 
    void remove_all(id_t the_id) const {
        ecs_remove_all(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(_::type<T>::id(world_));
    }
 
    template <typename First, typename Second>
    void remove_all() const {
        remove_all(_::type<First>::id(world_), _::type<Second>::id(world_));
    }
 
    template <typename First>
    void remove_all(entity_t second) const {
        remove_all(_::type<First>::id(world_), second);
    }
 
    template <typename Func>
    void defer(const Func& func) const {
        ecs_defer_begin(world_);
        func();
        ecs_defer_end(world_);
    }
 
    void defer_suspend() const {
        ecs_defer_suspend(world_);
    }
 
    void defer_resume() const {
        ecs_defer_resume(world_);
    }
 
    bool exists(flecs::entity_t e) const {
        return ecs_exists(world_, e);
    }
 
    bool is_alive(flecs::entity_t e) const {
        return ecs_is_alive(world_, e);
    }
 
    bool is_valid(flecs::entity_t e) const {
        return ecs_is_valid(world_, e);
    }
 
    flecs::entity get_alive(flecs::entity_t e) const;
 
    flecs::entity make_alive(flecs::entity_t e) const;
 
    void set_version(flecs::entity_t e) const {
        ecs_set_version(world_, e);
    }
 
    uint32_t get_version(flecs::entity_t e) const {
        return ecs_get_version(e);
    }
 
    /* Run callback after completing frame */
    void run_post_frame(ecs_fini_action_t action, void *ctx) const {
        ecs_run_post_frame(world_, action, ctx);
    }
 
    const flecs::world_info_t* get_info() const{
        return ecs_get_world_info(world_);
    }
 
    ecs_ftime_t delta_time() const {
        return get_info()->delta_time;
    }
 
    void shrink() const {
        ecs_shrink(world_);
    }
 
    void exclusive_access_begin(const char *thread_name = nullptr) {
        ecs_exclusive_access_begin(world_, thread_name);
    }
 
    void exclusive_access_end(bool lock_world = false) {
        ecs_exclusive_access_end(world_, lock_world);
    }
 
    template <typename T>
    flecs::id_t id_if_registered() {
        if (_::type<T>::registered(world_)) {
            return _::type<T>::id(world_);
        }
        else {
            return 0;
        }
    }
 
    const flecs::type_info_t* type_info(flecs::id_t component) {
        return ecs_get_type_info(world_, component);
    }
 
    const flecs::type_info_t* type_info(flecs::entity_t r, flecs::entity_t t) {
        return ecs_get_type_info(world_, ecs_pair(r, t));
    }
 
    template <typename T>
    const flecs::type_info_t* type_info() {
        return ecs_get_type_info(world_, _::type<T>::id(world_));
    }
 
    template <typename R>
    const flecs::type_info_t* type_info(flecs::entity_t t) {
        return type_info(_::type<R>::id(world_), t);
    }
 
    template <typename R, typename T>
    const flecs::type_info_t* type_info() {
        return type_info<R>(_::type<T>::id(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/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_SYSTEM
#   include "mixins/system/mixin.inl"
#   endif
#   ifdef FLECS_TIMER
#   include "mixins/timer/mixin.inl"
#   endif
#   ifdef FLECS_SCRIPT
#   include "mixins/script/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 *world_;
};
 
struct scoped_world : world {
    scoped_world(
        flecs::world_t *w,
        flecs::entity_t s) : world(w)
    {
        prev_scope_ = ecs_set_scope(w, s);
    }
 
    ~scoped_world() {
        ecs_set_scope(world_, prev_scope_);
    }
 
    scoped_world(const scoped_world& obj) : world(nullptr) {
        prev_scope_ = obj.prev_scope_;
        world_ = obj.world_;
        flecs_poly_claim(world_);
    }
 
    flecs::entity_t prev_scope_;
};
 
} // namespace flecs