Flecs v4.0
A fast entity component system (ECS) for C & C++
Loading...
Searching...
No Matches
world.hpp
Go to the documentation of this file.
1
6#pragma once
7
8namespace flecs
9{
10
11/* Static helper functions to assign a component value */
12
13// set(T&&), T = constructible
14template <typename T, if_t< is_flecs_constructible<T>::value > = 0>
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");
18
19 if (!ecs_is_deferred(world)) {
20 T& dst = *static_cast<T*>(ecs_ensure_id(world, entity, id));
21 dst = FLECS_MOV(value);
22
23 ecs_modified_id(world, entity, id);
24 } else {
25 T& dst = *static_cast<T*>(ecs_ensure_modified_id(world, entity, id));
26 dst = FLECS_MOV(value);
27 }
28}
29
30// set(const T&), T = constructible
31template <typename T, if_t< is_flecs_constructible<T>::value > = 0>
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");
35
36 if (!ecs_is_deferred(world)) {
37 T& dst = *static_cast<T*>(ecs_ensure_id(world, entity, id));
38 dst = FLECS_MOV(value);
39
40 ecs_modified_id(world, entity, id);
41 } else {
42 T& dst = *static_cast<T*>(ecs_ensure_modified_id(world, entity, id));
43 dst = FLECS_MOV(value);
44 }
45}
46
47// set(T&&), T = not constructible
48template <typename T, if_not_t< is_flecs_constructible<T>::value > = 0>
49inline void set(world_t *world, flecs::entity_t entity, T&& value, flecs::id_t id) {
50 ecs_assert(_::type<T>::size() != 0, ECS_INVALID_PARAMETER,
51 "operation invalid for empty type");
52
53 if (!ecs_is_deferred(world)) {
54 T& dst = *static_cast<remove_reference_t<T>*>(ecs_ensure_id(world, entity, id));
55 dst = FLECS_MOV(value);
56
57 ecs_modified_id(world, entity, id);
58 } else {
59 T& dst = *static_cast<remove_reference_t<T>*>(ecs_ensure_modified_id(world, entity, id));
60 dst = FLECS_MOV(value);
61 }
62}
63
64// set(const T&), T = not constructible
65template <typename T, if_not_t< is_flecs_constructible<T>::value > = 0>
66inline void set(world_t *world, flecs::entity_t entity, const T& value, flecs::id_t id) {
67 ecs_assert(_::type<T>::size() != 0, ECS_INVALID_PARAMETER,
68 "operation invalid for empty type");
69
70 if (!ecs_is_deferred(world)) {
71 T& dst = *static_cast<remove_reference_t<T>*>(ecs_ensure_id(world, entity, id));
72 dst = FLECS_MOV(value);
73
74 ecs_modified_id(world, entity, id);
75 } else {
76 T& dst = *static_cast<remove_reference_t<T>*>(ecs_ensure_modified_id(world, entity, id));
77 dst = FLECS_MOV(value);
78 }
79}
80
81// emplace for T(Args...)
82template <typename T, typename ... Args, if_t<
83 std::is_constructible<actual_type_t<T>, Args...>::value ||
84 std::is_default_constructible<actual_type_t<T>>::value > = 0>
85inline void emplace(world_t *world, flecs::entity_t entity, flecs::id_t id, Args&&... args) {
86 ecs_assert(_::type<T>::size() != 0, ECS_INVALID_PARAMETER,
87 "operation invalid for empty type");
88 T& dst = *static_cast<T*>(ecs_emplace_id(world, entity, id, nullptr));
89
90 FLECS_PLACEMENT_NEW(&dst, T{FLECS_FWD(args)...});
91
92 ecs_modified_id(world, entity, id);
93}
94
95// set(T&&)
96template <typename T, typename A>
97inline void set(world_t *world, entity_t entity, A&& value) {
98 id_t id = _::type<T>::id(world);
99 flecs::set(world, entity, FLECS_FWD(value), id);
100}
101
102// set(const T&)
103template <typename T, typename A>
104inline void set(world_t *world, entity_t entity, const A& value) {
105 id_t id = _::type<T>::id(world);
106 flecs::set(world, entity, value, id);
107}
108
113inline flecs::id_t strip_generation(flecs::entity_t e) {
114 return ecs_strip_generation(e);
115}
116
119inline uint32_t get_generation(flecs::entity_t e) {
120 return ECS_GENERATION(e);
121}
122
123struct scoped_world;
124
137struct world {
140 explicit world()
141 : world_( ecs_init() ) {
142 init_builtin_components();
143 }
144
149 explicit world(int argc, char *argv[])
150 : world_( ecs_init_w_args(argc, argv) ) {
151 init_builtin_components();
152 }
153
156 explicit world(world_t *w)
157 : world_( w ) {
158 if (w) {
159 flecs_poly_claim(w);
160 }
161 }
162
165 world(const world& obj) {
166 this->world_ = obj.world_;
167 flecs_poly_claim(this->world_);
168 }
169
170 world& operator=(const world& obj) noexcept {
171 this->world_ = obj.world_;
172 flecs_poly_claim(this->world_);
173 return *this;
174 }
175
176 world(world&& obj) noexcept {
177 world_ = obj.world_;
178 obj.world_ = nullptr;
179 }
180
181 world& operator=(world&& obj) noexcept {
182 world_ = obj.world_;
183 obj.world_ = nullptr;
184 return *this;
185 }
186
187 ~world() {
188 if (world_) {
189 if (!flecs_poly_release(world_)) {
190 if (ecs_stage_get_id(world_) == -1) {
191 ecs_stage_free(world_);
192 } else {
193 ecs_fini(world_);
194 }
195 }
196 }
197 }
198
199 /* Implicit conversion to world_t* */
200 operator world_t*() const { return world_; }
201
209 void make_owner() {
210 flecs_poly_release(world_);
211 }
212
214 void reset() {
215 /* Make sure there's only one reference to the world */
216 ecs_assert(flecs_poly_refcount(world_) == 1, ECS_INVALID_OPERATION,
217 "reset would invalidate other handles");
218 ecs_fini(world_);
219 world_ = ecs_init();
220 }
221
224 world_t* c_ptr() const {
225 return world_;
226 }
227
231 void quit() const {
232 ecs_quit(world_);
233 }
234
237 void atfini(ecs_fini_action_t action, void *ctx = nullptr) const {
238 ecs_atfini(world_, action, ctx);
239 }
240
243 bool should_quit() const {
244 return ecs_should_quit(world_);
245 }
246
269 return ecs_frame_begin(world_, delta_time);
270 }
271
281 void frame_end() const {
282 ecs_frame_end(world_);
283 }
284
295 bool readonly_begin(bool multi_threaded = false) const {
296 return ecs_readonly_begin(world_, multi_threaded);
297 }
298
305 void readonly_end() const {
306 ecs_readonly_end(world_);
307 }
308
324 bool defer_begin() const {
325 return ecs_defer_begin(world_);
326 }
327
342 bool defer_end() const {
343 return ecs_defer_end(world_);
344 }
345
357 bool is_deferred() const {
358 return ecs_is_deferred(world_);
359 }
360
376 void set_stage_count(int32_t stages) const {
377 ecs_set_stage_count(world_, stages);
378 }
379
388 int32_t get_stage_count() const {
389 return ecs_get_stage_count(world_);
390 }
391
398 int32_t get_stage_id() const {
399 return ecs_stage_get_id(world_);
400 }
401
408 bool is_stage() const {
410 flecs_poly_is(world_, ecs_world_t) ||
411 flecs_poly_is(world_, ecs_stage_t),
412 ECS_INVALID_PARAMETER,
413 "flecs::world instance contains invalid reference to world or stage");
414 return flecs_poly_is(world_, ecs_stage_t);
415 }
416
427 void merge() const {
428 ecs_merge(world_);
429 }
430
445 flecs::world get_stage(int32_t stage_id) const {
446 return flecs::world(ecs_get_stage(world_, stage_id));
447 }
448
465 ecs_world_t *as = ecs_stage_new(world_);
466 flecs_poly_release(as); // world object will claim
467 return flecs::world(as);
468 }
469
477 /* Safe cast, mutability is checked */
478 return flecs::world(
479 world_ ? const_cast<flecs::world_t*>(ecs_get_world(world_)) : nullptr);
480 }
481
492 bool is_readonly() const {
493 return ecs_stage_is_readonly(world_);
494 }
495
507 void set_ctx(void* ctx, ecs_ctx_free_t ctx_free = nullptr) const {
508 ecs_set_ctx(world_, ctx, ctx_free);
509 }
510
520 void* get_ctx() const {
521 return ecs_get_ctx(world_);
522 }
523
535 void set_binding_ctx(void* ctx, ecs_ctx_free_t ctx_free = nullptr) const {
536 ecs_set_binding_ctx(world_, ctx, ctx_free);
537 }
538
548 void* get_binding_ctx() const {
549 return ecs_get_binding_ctx(world_);
550 }
551
559 void dim(int32_t entity_count) const {
560 ecs_dim(world_, entity_count);
561 }
562
571 void set_entity_range(entity_t min, entity_t max) const {
572 ecs_set_entity_range(world_, min, max);
573 }
574
585 void enable_range_check(bool enabled = true) const {
586 ecs_enable_range_check(world_, enabled);
587 }
588
597 flecs::entity set_scope(const flecs::entity_t scope) const;
598
606 flecs::entity get_scope() const;
607
613 template <typename T>
614 flecs::entity set_scope() const;
615
621 flecs::entity_t* set_lookup_path(const flecs::entity_t *search_path) const {
622 return ecs_set_lookup_path(world_, search_path);
623 }
624
631 flecs::entity lookup(const char *name, const char *sep = "::", const char *root_sep = "::", bool recursive = true) const;
632
635 template <typename T, if_t< !is_callable<T>::value > = 0>
636 void set(const T& value) const {
637 flecs::set<T>(world_, _::type<T>::id(world_), value);
638 }
639
642 template <typename T, if_t< !is_callable<T>::value > = 0>
643 void set(T&& value) const {
644 flecs::set<T>(world_, _::type<T>::id(world_),
645 FLECS_FWD(value));
646 }
647
650 template <typename First, typename Second, typename P = flecs::pair<First, Second>,
651 typename A = actual_type_t<P>, if_not_t< flecs::is_pair<First>::value> = 0>
652 void set(const A& value) const {
653 flecs::set<P>(world_, _::type<First>::id(world_), value);
654 }
655
658 template <typename First, typename Second, typename P = flecs::pair<First, Second>,
659 typename A = actual_type_t<P>, if_not_t< flecs::is_pair<First>::value> = 0>
660 void set(A&& value) const {
661 flecs::set<P>(world_, _::type<First>::id(world_), FLECS_FWD(value));
662 }
663
666 template <typename First, typename Second>
667 void set(Second second, const First& value) const;
668
671 template <typename First, typename Second>
672 void set(Second second, First&& value) const;
673
676 template <typename Func, if_t< is_callable<Func>::value > = 0 >
677 void set(const Func& func) const;
678
679 template <typename T, typename ... Args>
680 void emplace(Args&&... args) const {
681 flecs::id_t component_id = _::type<T>::id(world_);
682 flecs::emplace<T>(world_, component_id, component_id, FLECS_FWD(args)...);
683 }
684
687 #ifndef ensure
688 template <typename T>
689 T& ensure() const;
690 #endif
691
694 template <typename T>
695 void modified() const;
696
699 template <typename T>
700 ref<T> get_ref() const;
701
704 template <typename T>
705 const T* get() const;
706
709 template <typename First, typename Second, typename P = flecs::pair<First, Second>,
710 typename A = actual_type_t<P>>
711 const A* get() const;
712
715 template <typename First, typename Second>
716 const First* get(Second second) const;
717
720 template <typename Func, if_t< is_callable<Func>::value > = 0 >
721 void get(const Func& func) const;
722
725 template <typename T>
726 T* get_mut() const;
727
730 template <typename First, typename Second, typename P = flecs::pair<First, Second>,
731 typename A = actual_type_t<P>>
732 A* get_mut() const;
733
736 template <typename First, typename Second>
737 First* get_mut(Second second) const;
738
741 template <typename T>
742 bool has() const;
743
749 template <typename First, typename Second>
750 bool has() const;
751
757 template <typename First>
758 bool has(flecs::id_t second) const;
759
765 bool has(flecs::id_t first, flecs::id_t second) const;
766
769 template <typename T>
770 void add() const;
771
777 template <typename First, typename Second>
778 void add() const;
779
785 template <typename First>
786 void add(flecs::entity_t second) const;
787
793 void add(flecs::entity_t first, flecs::entity_t second) const;
794
797 template <typename T>
798 void remove() const;
799
805 template <typename First, typename Second>
806 void remove() const;
807
813 template <typename First>
814 void remove(flecs::entity_t second) const;
815
821 void remove(flecs::entity_t first, flecs::entity_t second) const;
822
830 template <typename Func>
831 void children(Func&& f) const;
832
835 template <typename T>
836 flecs::entity singleton() const;
837
846 template<typename First>
847 flecs::entity target(int32_t index = 0) const;
848
857 template<typename T>
858 flecs::entity target(flecs::entity_t first, int32_t index = 0) const;
859
868 flecs::entity target(flecs::entity_t first, int32_t index = 0) const;
869
876 template <typename T>
877 flecs::entity use(const char *alias = nullptr) const;
878
884 flecs::entity use(const char *name, const char *alias = nullptr) const;
885
891 void use(flecs::entity entity, const char *alias = nullptr) const;
892
897 int count(flecs::id_t component_id) const {
898 return ecs_count_id(world_, component_id);
899 }
900
906 int count(flecs::entity_t first, flecs::entity_t second) const {
907 return ecs_count_id(world_, ecs_pair(first, second));
908 }
909
914 template <typename T>
915 int count() const {
916 return count(_::type<T>::id(world_));
917 }
918
924 template <typename First>
925 int count(flecs::entity_t second) const {
926 return count(_::type<First>::id(world_), second);
927 }
928
934 template <typename First, typename Second>
935 int count() const {
936 return count(
937 _::type<First>::id(world_),
938 _::type<Second>::id(world_));
939 }
940
943 template <typename Func>
944 void with(id_t with_id, const Func& func) const {
945 ecs_id_t prev = ecs_set_with(world_, with_id);
946 func();
947 ecs_set_with(world_, prev);
948 }
949
952 template <typename T, typename Func>
953 void with(const Func& func) const {
954 with(this->id<T>(), func);
955 }
956
959 template <typename First, typename Second, typename Func>
960 void with(const Func& func) const {
961 with(ecs_pair(this->id<First>(), this->id<Second>()), func);
962 }
963
966 template <typename First, typename Func>
967 void with(id_t second, const Func& func) const {
968 with(ecs_pair(this->id<First>(), second), func);
969 }
970
973 template <typename Func>
974 void with(id_t first, id_t second, const Func& func) const {
975 with(ecs_pair(first, second), func);
976 }
977
981 template <typename Func>
982 void scope(id_t parent, const Func& func) const {
983 ecs_entity_t prev = ecs_set_scope(world_, parent);
984 func();
985 ecs_set_scope(world_, prev);
986 }
987
990 template <typename T, typename Func>
991 void scope(const Func& func) const {
992 flecs::id_t parent = _::type<T>::id(world_);
993 scope(parent, func);
994 }
995
999 flecs::scoped_world scope(id_t parent) const;
1000
1001 template <typename T>
1002 flecs::scoped_world scope() const;
1003
1004 flecs::scoped_world scope(const char* name) const;
1005
1007 void delete_with(id_t the_id) const {
1008 ecs_delete_with(world_, the_id);
1009 }
1010
1012 void delete_with(entity_t first, entity_t second) const {
1013 delete_with(ecs_pair(first, second));
1014 }
1015
1017 template <typename T>
1018 void delete_with() const {
1019 delete_with(_::type<T>::id(world_));
1020 }
1021
1023 template <typename First, typename Second>
1024 void delete_with() const {
1026 }
1027
1029 template <typename First>
1030 void delete_with(entity_t second) const {
1031 delete_with(_::type<First>::id(world_), second);
1032 }
1033
1035 void remove_all(id_t the_id) const {
1036 ecs_remove_all(world_, the_id);
1037 }
1038
1040 void remove_all(entity_t first, entity_t second) const {
1041 remove_all(ecs_pair(first, second));
1042 }
1043
1045 template <typename T>
1046 void remove_all() const {
1047 remove_all(_::type<T>::id(world_));
1048 }
1049
1051 template <typename First, typename Second>
1052 void remove_all() const {
1054 }
1055
1057 template <typename First>
1058 void remove_all(entity_t second) const {
1059 remove_all(_::type<First>::id(world_), second);
1060 }
1061
1070 template <typename Func>
1071 void defer(const Func& func) const {
1072 ecs_defer_begin(world_);
1073 func();
1074 ecs_defer_end(world_);
1075 }
1076
1086 void defer_suspend() const {
1087 ecs_defer_suspend(world_);
1088 }
1089
1099 void defer_resume() const {
1100 ecs_defer_resume(world_);
1101 }
1102
1109 bool exists(flecs::entity_t e) const {
1110 return ecs_exists(world_, e);
1111 }
1112
1119 bool is_alive(flecs::entity_t e) const {
1120 return ecs_is_alive(world_, e);
1121 }
1122
1130 bool is_valid(flecs::entity_t e) const {
1131 return ecs_is_valid(world_, e);
1132 }
1133
1139 flecs::entity get_alive(flecs::entity_t e) const;
1140
1144 flecs::entity make_alive(flecs::entity_t e) const;
1145
1146 /* Run callback after completing frame */
1147 void run_post_frame(ecs_fini_action_t action, void *ctx) const {
1148 ecs_run_post_frame(world_, action, ctx);
1149 }
1150
1156 return ecs_get_world_info(world_);
1157 }
1158
1161 return get_info()->delta_time;
1162 }
1163
1164# include "mixins/id/mixin.inl"
1166# include "mixins/entity/mixin.inl"
1167# include "mixins/event/mixin.inl"
1168# include "mixins/term/mixin.inl"
1169# include "mixins/observer/mixin.inl"
1170# include "mixins/query/mixin.inl"
1171# include "mixins/enum/mixin.inl"
1172
1173# ifdef FLECS_MODULE
1174# include "mixins/module/mixin.inl"
1175# endif
1176# ifdef FLECS_PIPELINE
1177# include "mixins/pipeline/mixin.inl"
1178# endif
1179# ifdef FLECS_SYSTEM
1180# include "mixins/system/mixin.inl"
1181# endif
1182# ifdef FLECS_TIMER
1183# include "mixins/timer/mixin.inl"
1184# endif
1185# ifdef FLECS_SCRIPT
1186# include "mixins/script/mixin.inl"
1187# endif
1188# ifdef FLECS_META
1189# include "mixins/meta/world.inl"
1190# endif
1191# ifdef FLECS_JSON
1192# include "mixins/json/world.inl"
1193# endif
1194# ifdef FLECS_APP
1195# include "mixins/app/mixin.inl"
1196# endif
1197# ifdef FLECS_METRICS
1198# include "mixins/metrics/mixin.inl"
1199# endif
1200# ifdef FLECS_ALERTS
1201# include "mixins/alerts/mixin.inl"
1202# endif
1203
1204public:
1205 void init_builtin_components();
1206
1207 world_t *world_;
1208};
1209
1215 flecs::world_t *w,
1216 flecs::entity_t s) : world(w)
1217 {
1218 prev_scope_ = ecs_set_scope(w, s);
1219 }
1220
1221 ~scoped_world() {
1222 ecs_set_scope(world_, prev_scope_);
1223 }
1224
1225 scoped_world(const scoped_world& obj) : world(nullptr) {
1226 prev_scope_ = obj.prev_scope_;
1227 world_ = obj.world_;
1228 flecs_poly_claim(world_);
1229 }
1230
1231 flecs::entity_t prev_scope_;
1232};
1233
1236} // namespace flecs
App world addon mixin.
Component mixin.
Entity world mixin.
Enum world mixin.
Event world mixin.
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.
Definition log.h:352
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.
Definition flecs.h:386
ecs_id_t ecs_entity_t
An entity identifier.
Definition flecs.h:339
struct ecs_world_t ecs_world_t
A world is the container for all ECS data and supporting features.
Definition flecs.h:383
uint64_t ecs_id_t
Ids are the things that can be added to an entity.
Definition flecs.h:332
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.
Definition flecs.h:579
void(* ecs_ctx_free_t)(void *ctx)
Function to cleanup context data.
Definition flecs.h:584
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.
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.
#define ecs_ftime_t
Customizable precision for scalar time values.
Definition flecs.h:59
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_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_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.
Definition flecs.h:2577
bool ecs_enable_range_check(ecs_world_t *world, bool enable)
Enable/disable range limits.
void * ecs_get_ctx(const ecs_world_t *world)
Get the world context.
Id world mixin.
JSON world mixin.
Meta world mixin.
Module world mixin.
Observer world mixin.
Pipeline world mixin.
Query world mixin.
Script world mixin.
Type that contains information about the world.
Definition flecs.h:1341
float delta_time
Time passed to or computed by ecs_progress()
Definition flecs.h:1347
Entity.
Definition entity.hpp:30
Class that wraps around a flecs::id_t.
Definition decl.hpp:27
Scoped world.
Definition world.hpp:1213
The world.
Definition world.hpp:137
bool is_stage() const
Test if is a stage.
Definition world.hpp:408
void delete_with() const
Delete all entities with specified component.
Definition world.hpp:1018
void remove_all(id_t the_id) const
Remove all instances of specified id.
Definition world.hpp:1035
void delete_with(entity_t second) const
Delete all entities with specified pair.
Definition world.hpp:1030
void merge() const
Merge world or stage.
Definition world.hpp:427
void delete_with(id_t the_id) const
Delete all entities with specified id.
Definition world.hpp:1007
const flecs::world_info_t * get_info() const
Get the world info.
Definition world.hpp:1155
flecs::entity get_scope() const
Get current scope.
Definition world.hpp:67
T * get_mut() const
Get mutable singleton component.
Definition world.hpp:132
void remove() const
Remove singleton component.
Definition world.hpp:196
flecs::entity lookup(const char *name, const char *sep="::", const char *root_sep="::", bool recursive=true) const
Lookup entity by name.
Definition world.hpp:76
void set(A &&value) const
Set singleton pair.
Definition world.hpp:660
ecs_ftime_t delta_time() const
Get delta_time.
Definition world.hpp:1160
void quit() const
Signal application should quit.
Definition world.hpp:231
flecs::entity get_alive(flecs::entity_t e) const
Get alive entity for id.
Definition world.hpp:266
void set_entity_range(entity_t min, entity_t max) const
Set entity range.
Definition world.hpp:571
void readonly_end() const
End readonly mode.
Definition world.hpp:305
void with(const Func &func) const
All entities created in function are created with pair.
Definition world.hpp:960
flecs::entity make_alive(flecs::entity_t e) const
Definition world.hpp:271
int count() const
Count entities matching a component.
Definition world.hpp:915
flecs::entity target(int32_t index=0) const
Get target for a given pair from a singleton entity.
Definition world.hpp:229
const T * get() const
Get singleton component.
Definition world.hpp:114
void defer(const Func &func) const
Defer all operations called in function.
Definition world.hpp:1071
bool should_quit() const
Test if quit() has been called.
Definition world.hpp:243
bool is_alive(flecs::entity_t e) const
Check if entity id exists in the world.
Definition world.hpp:1119
world_t * c_ptr() const
Obtain pointer to C world object.
Definition world.hpp:224
bool defer_begin() const
Defer operations until end of frame.
Definition world.hpp:324
void reset()
Deletes and recreates the world.
Definition world.hpp:214
flecs::entity_t * set_lookup_path(const flecs::entity_t *search_path) const
Set search path.
Definition world.hpp:621
void defer_suspend() const
Suspend deferring operations.
Definition world.hpp:1086
void set(const A &value) const
Set singleton pair.
Definition world.hpp:652
void make_owner()
Make current world object owner of the world.
Definition world.hpp:209
bool is_valid(flecs::entity_t e) const
Check if entity id is valid.
Definition world.hpp:1130
flecs::world async_stage() const
Create asynchronous stage.
Definition world.hpp:464
bool is_deferred() const
Test whether deferring is enabled.
Definition world.hpp:357
void * get_binding_ctx() const
Get world binding context.
Definition world.hpp:548
int32_t get_stage_id() const
Get current stage id.
Definition world.hpp:398
world(const world &obj)
Not allowed to copy a world.
Definition world.hpp:165
void scope(const Func &func) const
Same as scope(parent, func), but with T as parent.
Definition world.hpp:991
void defer_resume() const
Resume deferring operations.
Definition world.hpp:1099
flecs::entity set_scope() const
Same as set_scope but with type.
Definition world.hpp:72
void dim(int32_t entity_count) const
Preallocate memory for number of entities.
Definition world.hpp:559
void set_stage_count(int32_t stages) const
Configure world to have N stages.
Definition world.hpp:376
void with(id_t with_id, const Func &func) const
All entities created in function are created with id.
Definition world.hpp:944
void * get_ctx() const
Get world context.
Definition world.hpp:520
int count() const
Count entities matching a pair.
Definition world.hpp:935
void remove_all() const
Remove all instances of specified pair.
Definition world.hpp:1052
bool defer_end() const
End block of operations to defer.
Definition world.hpp:342
int count(flecs::entity_t first, flecs::entity_t second) const
Count entities matching a pair.
Definition world.hpp:906
void remove_all(entity_t second) const
Remove all instances of specified pair.
Definition world.hpp:1058
world(world_t *w)
Create world from C world.
Definition world.hpp:156
void children(Func &&f) const
Iterate entities in root of world Accepts a callback with the following signature:
Definition world.hpp:219
flecs::world get_world() const
Get actual world.
Definition world.hpp:476
void scope(id_t parent, const Func &func) const
All entities created in function are created in scope.
Definition world.hpp:982
void with(const Func &func) const
All entities created in function are created with type.
Definition world.hpp:953
void remove_all(entity_t first, entity_t second) const
Remove all instances of specified pair.
Definition world.hpp:1040
void modified() const
Mark singleton component as modified.
Definition world.hpp:90
void enable_range_check(bool enabled=true) const
Enforce that operations cannot modify entities outside of range.
Definition world.hpp:585
int count(flecs::entity_t second) const
Count entities matching a pair.
Definition world.hpp:925
ecs_ftime_t frame_begin(float delta_time=0) const
Begin frame.
Definition world.hpp:268
flecs::entity use(const char *alias=nullptr) const
Create alias for component.
Definition world.hpp:34
bool is_readonly() const
Test whether the current world object is readonly.
Definition world.hpp:492
void add() const
Add singleton component.
Definition world.hpp:173
T & ensure() const
Ensure singleton component.
Definition world.hpp:83
bool readonly_begin(bool multi_threaded=false) const
Begin readonly mode.
Definition world.hpp:295
void set(const T &value) const
Set singleton component.
Definition world.hpp:636
void with(id_t first, id_t second, const Func &func) const
All entities created in function are created with pair.
Definition world.hpp:974
flecs::world get_stage(int32_t stage_id) const
Get stage-specific world pointer.
Definition world.hpp:445
void set(T &&value) const
Set singleton component.
Definition world.hpp:643
bool has() const
Test if world has singleton component.
Definition world.hpp:150
bool exists(flecs::entity_t e) const
Check if entity id exists in the world.
Definition world.hpp:1109
world()
Create world.
Definition world.hpp:140
void frame_end() const
End frame.
Definition world.hpp:281
void set_binding_ctx(void *ctx, ecs_ctx_free_t ctx_free=nullptr) const
Set world binding context.
Definition world.hpp:535
void atfini(ecs_fini_action_t action, void *ctx=nullptr) const
Register action to be executed when world is destroyed.
Definition world.hpp:237
int32_t get_stage_count() const
Get number of configured stages.
Definition world.hpp:388
void delete_with(entity_t first, entity_t second) const
Delete all entities with specified pair.
Definition world.hpp:1012
void delete_with() const
Delete all entities with specified pair.
Definition world.hpp:1024
flecs::entity singleton() const
Get singleton entity for type.
Definition world.hpp:224
void with(id_t second, const Func &func) const
All entities created in function are created with pair.
Definition world.hpp:967
void set_ctx(void *ctx, ecs_ctx_free_t ctx_free=nullptr) const
Set world context.
Definition world.hpp:507
world(int argc, char *argv[])
Create world with command line arguments.
Definition world.hpp:149
int count(flecs::id_t component_id) const
Count entities matching a component.
Definition world.hpp:897
void remove_all() const
Remove all instances of specified component.
Definition world.hpp:1046
ref< T > get_ref() const
Get ref singleton component.
Definition world.hpp:108
System module world mixin.
Term world mixin.
Timer module mixin.
flecs::id_t strip_generation(flecs::entity_t e)
Return id without generation.
Definition world.hpp:113
uint32_t get_generation(flecs::entity_t e)
Return entity generation.
Definition world.hpp:119