15inline void set(world_t *world, flecs::entity_t entity, T&& value, flecs::id_t
id) {
16 ecs_assert(_::type<T>::size() != 0, ECS_INVALID_PARAMETER,
17 "operation invalid for empty type");
20 T& dst = *
static_cast<remove_reference_t<T>*
>(
ecs_ensure_id(world, entity,
id));
21 dst = FLECS_MOV(value);
26 dst = FLECS_MOV(value);
32inline void set(world_t *world, flecs::entity_t entity,
const T& value, flecs::id_t
id) {
33 ecs_assert(_::type<T>::size() != 0, ECS_INVALID_PARAMETER,
34 "operation invalid for empty type");
37 T& dst = *
static_cast<remove_reference_t<T>*
>(
ecs_ensure_id(world, entity,
id));
38 dst = FLECS_MOV(value);
43 dst = FLECS_MOV(value);
48template <
typename T,
typename A>
49inline void set(world_t *world, entity_t entity, A&& value) {
50 id_t
id = _::type<T>::id(world);
51 flecs::set(world, entity, FLECS_FWD(value),
id);
55template <
typename T,
typename A>
56inline void set(world_t *world, entity_t entity,
const A& value) {
57 id_t
id = _::type<T>::id(world);
58 flecs::set(world, entity, value,
id);
63inline void assign(world_t *world, flecs::entity_t entity, T&& value, flecs::id_t
id) {
64 using ActualType = remove_reference_t<T>;
66 ecs_assert(_::type<ActualType>::size() != 0, ECS_INVALID_PARAMETER,
67 "operation invalid for empty type");
70 ActualType *dst_ptr =
static_cast<ActualType*
>(
ecs_get_mut_id(world, entity,
id));
71 ecs_assert(dst_ptr !=
nullptr, ECS_INVALID_OPERATION,
72 "entity does not have component, use set() instead");
74 ActualType& dst = *dst_ptr;
75 dst = FLECS_MOV(value);
80 ecs_assert(dst_ptr !=
nullptr, ECS_INVALID_OPERATION,
81 "entity does not have component, use set() instead");
83 ActualType& dst = *dst_ptr;
84 dst = FLECS_MOV(value);
90inline void assign(world_t *world, flecs::entity_t entity,
const T& value, flecs::id_t
id) {
91 using ActualType = remove_reference_t<T>;
93 ecs_assert(_::type<ActualType>::size() != 0, ECS_INVALID_PARAMETER,
94 "operation invalid for empty type");
97 ActualType *dst_ptr =
static_cast<ActualType*
>(
ecs_get_mut_id(world, entity,
id));
98 ecs_assert(dst_ptr !=
nullptr, ECS_INVALID_OPERATION,
99 "entity does not have component, use set() instead");
101 ActualType& dst = *dst_ptr;
102 dst = FLECS_MOV(value);
107 ecs_assert(dst_ptr !=
nullptr, ECS_INVALID_OPERATION,
108 "entity does not have component, use set() instead");
110 ActualType& dst = *dst_ptr;
111 dst = FLECS_MOV(value);
116template <
typename T,
typename A>
117inline void assign(world_t *world, entity_t entity, A&& value) {
118 id_t
id = _::type<T>::id(world);
119 flecs::assign(world, entity, FLECS_FWD(value),
id);
123template <
typename T,
typename A>
124inline void assign(world_t *world, entity_t entity,
const A& value) {
125 id_t
id = _::type<T>::id(world);
126 flecs::assign(world, entity, value,
id);
131template <
typename T,
typename ... Args, if_t<
132 std::is_constructible<actual_type_t<T>, Args...>::value ||
133 std::is_default_constructible<actual_type_t<T>>::value > = 0>
134inline void emplace(world_t *world, flecs::entity_t entity, flecs::id_t
id, Args&&... args) {
135 ecs_assert(_::type<T>::size() != 0, ECS_INVALID_PARAMETER,
136 "operation invalid for empty type");
137 T& dst = *
static_cast<T*
>(
ecs_emplace_id(world, entity,
id,
nullptr));
139 FLECS_PLACEMENT_NEW(&dst, T{FLECS_FWD(args)...});
155 return ECS_GENERATION(e);
177 init_builtin_components();
184 explicit world(
int argc,
char *argv[])
186 init_builtin_components();
201 this->world_ = obj.world_;
202 flecs_poly_claim(this->world_);
207 this->world_ = obj.world_;
208 flecs_poly_claim(this->world_);
214 obj.world_ =
nullptr;
220 obj.world_ =
nullptr;
228 if (!flecs_poly_release(world_)) {
235 flecs_poly_claim(world_);
248 operator world_t*()
const {
return world_; }
258 flecs_poly_release(world_);
264 ecs_assert(flecs_poly_refcount(world_) == 1, ECS_INVALID_OPERATION,
265 "reset would invalidate other handles");
460 ECS_INVALID_PARAMETER,
461 "flecs::world instance contains invalid reference to world or stage");
514 flecs_poly_release(as);
527 world_ ?
const_cast<flecs::world_t*
>(
ecs_get_world(world_)) :
nullptr);
607 void dim(int32_t entity_count)
const {
661 template <
typename T>
679 flecs::entity lookup(
const char *name,
const char *sep =
"::",
const char *root_sep =
"::",
bool recursive =
true)
const;
683 template <typename T, if_t< !is_callable<T>::value > = 0>
684 void set(
const T& value)
const {
690 template <typename T, if_t< !is_callable<T>::value > = 0>
691 void set(T&& value)
const {
698 template <
typename First,
typename Second,
typename P = flecs::pair<First, Second>,
699 typename A = actual_type_t<P>, if_not_t< flecs::is_pair<First>::value> = 0>
700 void set(
const A& value)
const {
706 template <
typename First,
typename Second,
typename P = flecs::pair<First, Second>,
707 typename A = actual_type_t<P>, if_not_t< flecs::is_pair<First>::value> = 0>
708 void set(A&& value)
const {
714 template <
typename First,
typename Second>
715 void set(Second second,
const First& value)
const;
719 template <
typename First,
typename Second>
720 void set(Second second, First&& value)
const;
724 template <typename Func, if_t< is_callable<Func>::value > = 0 >
725 void set(
const Func& func)
const;
727 template <
typename T,
typename ... Args>
728 void emplace(Args&&... args)
const {
730 flecs::emplace<T>(world_, component_id, component_id, FLECS_FWD(args)...);
736 template <
typename T>
742 template <
typename T>
747 template <
typename T>
755 const void*
try_get(flecs::id_t
id)
const;
759 const void*
try_get(flecs::entity_t r, flecs::entity_t t)
const;
763 template <
typename T>
768 template <
typename First,
typename Second,
typename P = flecs::pair<First, Second>,
769 typename A = actual_type_t<P>>
774 template <
typename First,
typename Second>
775 const First*
try_get(Second second)
const;
782 const void* get(flecs::id_t
id)
const;
786 const void* get(flecs::entity_t r, flecs::entity_t t)
const;
788 template <
typename T>
789 const T& get()
const;
793 template <
typename First,
typename Second,
typename P = flecs::pair<First, Second>,
794 typename A = actual_type_t<P>>
795 const A& get()
const;
799 template <
typename First,
typename Second>
800 const First& get(Second second)
const;
804 template <typename Func, if_t< is_callable<Func>::value > = 0 >
805 void get(
const Func& func)
const;
812 void* try_get_mut(flecs::id_t
id)
const;
816 void* try_get_mut(flecs::entity_t r, flecs::entity_t t)
const;
818 template <
typename T>
819 T* try_get_mut()
const;
823 template <
typename First,
typename Second,
typename P = flecs::pair<First, Second>,
824 typename A = actual_type_t<P>>
825 A* try_get_mut()
const;
829 template <
typename First,
typename Second>
830 First* try_get_mut(Second second)
const;
837 void* get_mut(flecs::id_t
id)
const;
841 void* get_mut(flecs::entity_t r, flecs::entity_t t)
const;
843 template <
typename T>
848 template <
typename First,
typename Second,
typename P = flecs::pair<First, Second>,
849 typename A = actual_type_t<P>>
854 template <
typename First,
typename Second>
855 First& get_mut(Second second)
const;
860 template <
typename T>
868 template <
typename First,
typename Second>
876 template <
typename First>
877 bool has(flecs::id_t second)
const;
884 bool has(flecs::id_t first, flecs::id_t second)
const;
888 template <
typename T>
896 template <
typename First,
typename Second>
904 template <
typename First>
905 void add(flecs::entity_t second)
const;
912 void add(flecs::entity_t first, flecs::entity_t second)
const;
916 template <
typename T>
924 template <
typename First,
typename Second>
932 template <
typename First>
933 void remove(flecs::entity_t second)
const;
940 void remove(flecs::entity_t first, flecs::entity_t second)
const;
949 template <
typename Func>
954 template <
typename T>
965 template<
typename First>
995 template <
typename T>
1016 int count(flecs::id_t component_id)
const {
1025 int count(flecs::entity_t first, flecs::entity_t second)
const {
1033 template <
typename T>
1043 template <
typename First>
1044 int count(flecs::entity_t second)
const {
1053 template <
typename First,
typename Second>
1062 template <
typename Func>
1063 void with(id_t with_id,
const Func& func)
const {
1071 template <
typename T,
typename Func>
1072 void with(
const Func& func)
const {
1078 template <
typename First,
typename Second,
typename Func>
1079 void with(
const Func& func)
const {
1085 template <
typename First,
typename Func>
1086 void with(id_t second,
const Func& func)
const {
1092 template <
typename Func>
1093 void with(id_t first, id_t second,
const Func& func)
const {
1094 with(ecs_pair(first, second), func);
1100 template <
typename Func>
1101 void scope(id_t parent,
const Func& func)
const {
1109 template <
typename T,
typename Func>
1112 scope(parent, func);
1120 template <
typename T>
1136 template <
typename T>
1142 template <
typename First,
typename Second>
1148 template <
typename First>
1164 template <
typename T>
1170 template <
typename First,
typename Second>
1176 template <
typename First>
1189 template <
typename Func>
1329# ifdef FLECS_PIPELINE
1350# ifdef FLECS_METRICS
1351# include "mixins/metrics/mixin.inl"
1354# include "mixins/alerts/mixin.inl"
1358 void init_builtin_components();
1369 flecs::entity_t s) :
world(w)
1379 prev_scope_ = obj.prev_scope_;
1380 world_ = obj.world_;
1381 flecs_poly_claim(world_);
1384 flecs::entity_t prev_scope_;
ecs_entity_t ecs_set_with(ecs_world_t *world, ecs_id_t id)
Set current with id.
void ecs_remove_all(ecs_world_t *world, ecs_id_t id)
Remove all instances of the specified (component) id.
#define ecs_assert(condition, error_code,...)
Assert.
ecs_world_t * ecs_stage_new(ecs_world_t *world)
Create unmanaged stage.
bool ecs_defer_end(ecs_world_t *world)
End block of operations to defer.
bool ecs_readonly_begin(ecs_world_t *world, bool multi_threaded)
Begin readonly mode.
void ecs_defer_resume(ecs_world_t *world)
Resume deferring.
bool ecs_defer_begin(ecs_world_t *world)
Defer operations until end of frame.
void ecs_defer_suspend(ecs_world_t *world)
Suspend deferring but do not flush queue.
bool ecs_is_deferred(const ecs_world_t *world)
Test if deferring is enabled for current stage.
void ecs_stage_free(ecs_world_t *stage)
Free unmanaged stage.
void ecs_merge(ecs_world_t *world)
Merge world or stage.
int32_t ecs_stage_get_id(const ecs_world_t *world)
Get stage id.
bool ecs_stage_is_readonly(const ecs_world_t *world)
Test whether the current world is readonly.
int32_t ecs_get_stage_count(const ecs_world_t *world)
Get number of configured stages.
ecs_world_t * ecs_get_stage(const ecs_world_t *world, int32_t stage_id)
Get stage-specific world pointer.
void ecs_set_stage_count(ecs_world_t *world, int32_t stages)
Configure world to have N stages.
void ecs_readonly_end(ecs_world_t *world)
End readonly mode.
struct ecs_stage_t ecs_stage_t
A stage enables modification while iterating and from multiple threads.
ecs_id_t ecs_entity_t
An entity identifier.
struct ecs_world_t ecs_world_t
A world is the container for all ECS data and supporting features.
uint64_t ecs_id_t
Ids are the things that can be added to an entity.
flecs::entity entity(Args &&... args) const
Create an entity.
void ecs_delete_with(ecs_world_t *world, ecs_id_t id)
Delete all entities with the specified id.
int32_t ecs_count_id(const ecs_world_t *world, ecs_id_t entity)
Count entities that have the specified id.
void(* ecs_fini_action_t)(ecs_world_t *world, void *ctx)
Action callback on world exit.
void(* ecs_ctx_free_t)(void *ctx)
Function to cleanup context data.
void * ecs_get_mut_id(const ecs_world_t *world, ecs_entity_t entity, ecs_id_t id)
Get a mutable pointer to a component.
void * ecs_emplace_id(ecs_world_t *world, ecs_entity_t entity, ecs_id_t id, bool *is_new)
Emplace a component.
void * ecs_ensure_id(ecs_world_t *world, ecs_entity_t entity, ecs_id_t id)
Get a mutable pointer to a component.
void * ecs_ensure_modified_id(ecs_world_t *world, ecs_entity_t entity, ecs_id_t id)
Combines ensure + modified in single operation.
void ecs_modified_id(ecs_world_t *world, ecs_entity_t entity, ecs_id_t id)
Signal that a component has been modified.
void * ecs_get_mut_modified_id(ecs_world_t *world, ecs_entity_t entity, ecs_id_t id)
Combines get_mut + modified in single operation.
ecs_id_t ecs_strip_generation(ecs_entity_t e)
Remove generation from entity id.
bool ecs_is_valid(const ecs_world_t *world, ecs_entity_t e)
Test whether an entity is valid.
bool ecs_exists(const ecs_world_t *world, ecs_entity_t entity)
Test whether an entity exists.
bool ecs_is_alive(const ecs_world_t *world, ecs_entity_t e)
Test whether an entity is alive.
void ecs_set_version(ecs_world_t *world, ecs_entity_t entity)
Override the generation of an entity.
#define ecs_ftime_t
Customizable precision for scalar time values.
ecs_entity_t * ecs_set_lookup_path(ecs_world_t *world, const ecs_entity_t *lookup_path)
Set search path for lookup operations.
ecs_entity_t ecs_set_scope(ecs_world_t *world, ecs_entity_t scope)
Set the current scope.
void ecs_atfini(ecs_world_t *world, ecs_fini_action_t action, void *ctx)
Register action to be executed when world is destroyed.
int ecs_fini(ecs_world_t *world)
Delete a world.
ecs_world_t * ecs_init(void)
Create a new world.
ecs_world_t * ecs_init_w_args(int argc, char *argv[])
Create a new world with arguments.
float ecs_frame_begin(ecs_world_t *world, float delta_time)
Begin frame.
void ecs_run_post_frame(ecs_world_t *world, ecs_fini_action_t action, void *ctx)
Register action to be executed once after frame.
bool ecs_should_quit(const ecs_world_t *world)
Return whether a quit has been requested.
void ecs_quit(ecs_world_t *world)
Signal exit This operation signals that the application should quit.
void ecs_frame_end(ecs_world_t *world)
End frame.
void * ecs_get_binding_ctx(const ecs_world_t *world)
Get the world binding context.
void ecs_shrink(ecs_world_t *world)
Free unused memory.
void ecs_dim(ecs_world_t *world, int32_t entity_count)
Dimension the world for a specified number of entities.
void ecs_set_entity_range(ecs_world_t *world, ecs_entity_t id_start, ecs_entity_t id_end)
Set a range for issuing new entity ids.
const ecs_world_info_t * ecs_get_world_info(const ecs_world_t *world)
Get world info.
const ecs_world_t * ecs_get_world(const ecs_poly_t *poly)
Get world from poly.
void ecs_set_ctx(ecs_world_t *world, void *ctx, ecs_ctx_free_t ctx_free)
Set a world context.
void ecs_exclusive_access_begin(ecs_world_t *world, const char *thread_name)
Begin exclusive thread access.
void ecs_set_binding_ctx(ecs_world_t *world, void *ctx, ecs_ctx_free_t ctx_free)
Set a world binding context.
#define flecs_poly_is(object, type)
Test if pointer is of specified type.
bool ecs_enable_range_check(ecs_world_t *world, bool enable)
Enable/disable range limits.
void ecs_exclusive_access_end(ecs_world_t *world, bool lock_world)
End exclusive thread access.
void * ecs_get_ctx(const ecs_world_t *world)
Get the world context.
Type that contains information about the world.
float delta_time
Time passed to or computed by ecs_progress()
Class that wraps around a flecs::id_t.
bool is_stage() const
Test if is a stage.
void shrink() const
Free unused memory.
void delete_with() const
Delete all entities with specified component.
void remove_all(id_t the_id) const
Remove all instances of specified id.
void delete_with(entity_t second) const
Delete all entities with specified pair.
void merge() const
Merge world or stage.
void delete_with(id_t the_id) const
Delete all entities with specified id.
const flecs::world_info_t * get_info() const
Get the world info.
flecs::entity get_scope() const
Get current scope.
void remove() const
Remove singleton component.
flecs::entity lookup(const char *name, const char *sep="::", const char *root_sep="::", bool recursive=true) const
Lookup entity by name.
void set(A &&value) const
Set singleton pair.
ecs_ftime_t delta_time() const
Get delta_time.
void quit() const
Signal application should quit.
flecs::entity get_alive(flecs::entity_t e) const
Get alive entity for id.
void set_entity_range(entity_t min, entity_t max) const
Set entity range.
void readonly_end() const
End readonly mode.
void with(const Func &func) const
All entities created in function are created with pair.
flecs::entity make_alive(flecs::entity_t e) const
int count() const
Count entities matching a component.
void exclusive_access_begin(const char *thread_name=nullptr)
Begin exclusive access.
flecs::entity target(int32_t index=0) const
Get target for a given pair from a singleton entity.
void defer(const Func &func) const
Defer all operations called in function.
bool should_quit() const
Test if quit() has been called.
bool is_alive(flecs::entity_t e) const
Check if entity id exists in the world.
world_t * c_ptr() const
Obtain pointer to C world object.
const T * try_get() const
Get singleton component.
bool defer_begin() const
Defer operations until end of frame.
void reset()
Deletes and recreates the world.
flecs::entity_t * set_lookup_path(const flecs::entity_t *search_path) const
Set search path.
void defer_suspend() const
Suspend deferring operations.
void set(const A &value) const
Set singleton pair.
void make_owner()
Make current world object owner of the world.
bool is_valid(flecs::entity_t e) const
Check if entity id is valid.
flecs::world async_stage() const
Create asynchronous stage.
bool is_deferred() const
Test whether deferring is enabled.
void * get_binding_ctx() const
Get world binding context.
int32_t get_stage_id() const
Get current stage id.
world(const world &obj)
Not allowed to copy a world.
void scope(const Func &func) const
Same as scope(parent, func), but with T as parent.
void defer_resume() const
Resume deferring operations.
flecs::entity set_scope() const
Same as set_scope but with type.
void dim(int32_t entity_count) const
Preallocate memory for number of entities.
void set_version(flecs::entity_t e) const
Set version of entity to provided.
void set_stage_count(int32_t stages) const
Configure world to have N stages.
void with(id_t with_id, const Func &func) const
All entities created in function are created with id.
void * get_ctx() const
Get world context.
int count() const
Count entities matching a pair.
void remove_all() const
Remove all instances of specified pair.
bool defer_end() const
End block of operations to defer.
int count(flecs::entity_t first, flecs::entity_t second) const
Count entities matching a pair.
void remove_all(entity_t second) const
Remove all instances of specified pair.
world(world_t *w)
Create world from C world.
void children(Func &&f) const
Iterate entities in root of world Accepts a callback with the following signature:
flecs::world get_world() const
Get actual world.
void scope(id_t parent, const Func &func) const
All entities created in function are created in scope.
void with(const Func &func) const
All entities created in function are created with type.
void remove_all(entity_t first, entity_t second) const
Remove all instances of specified pair.
void modified() const
Mark singleton component as modified.
void enable_range_check(bool enabled=true) const
Enforce that operations cannot modify entities outside of range.
int count(flecs::entity_t second) const
Count entities matching a pair.
ecs_ftime_t frame_begin(float delta_time=0) const
Begin frame.
flecs::entity use(const char *alias=nullptr) const
Create alias for component.
bool is_readonly() const
Test whether the current world object is readonly.
void add() const
Add singleton component.
T & ensure() const
Ensure singleton component.
bool readonly_begin(bool multi_threaded=false) const
Begin readonly mode.
void set(const T &value) const
Set singleton component.
void with(id_t first, id_t second, const Func &func) const
All entities created in function are created with pair.
flecs::world get_stage(int32_t stage_id) const
Get stage-specific world pointer.
void set(T &&value) const
Set singleton component.
bool has() const
Test if world has singleton component.
bool exists(flecs::entity_t e) const
Check if entity id exists in the world.
void frame_end() const
End frame.
void set_binding_ctx(void *ctx, ecs_ctx_free_t ctx_free=nullptr) const
Set world binding context.
void atfini(ecs_fini_action_t action, void *ctx=nullptr) const
Register action to be executed when world is destroyed.
int32_t get_stage_count() const
Get number of configured stages.
void delete_with(entity_t first, entity_t second) const
Delete all entities with specified pair.
void delete_with() const
Delete all entities with specified pair.
flecs::entity singleton() const
Get singleton entity for type.
void exclusive_access_end(bool lock_world=false)
End exclusive access.
void with(id_t second, const Func &func) const
All entities created in function are created with pair.
void set_ctx(void *ctx, ecs_ctx_free_t ctx_free=nullptr) const
Set world context.
world(int argc, char *argv[])
Create world with command line arguments.
int count(flecs::id_t component_id) const
Count entities matching a component.
void remove_all() const
Remove all instances of specified component.
ref< T > get_ref() const
Get ref singleton component.
System module world mixin.
flecs::id_t strip_generation(flecs::entity_t e)
Return id without generation.
uint32_t get_generation(flecs::entity_t e)
Return entity generation.