From 0b1d9b8f02dea6904da7d0ae2b12216676ade0ce Mon Sep 17 00:00:00 2001 From: Michele Caini Date: Thu, 8 Feb 2018 14:59:12 +0100 Subject: [PATCH] API reference v2.4.2 --- README_8md_source.html | 4 +- actor_8hpp_source.html | 23 +- annotated.html | 2 +- bus_8hpp_source.html | 2 +- cache_8hpp_source.html | 4 +- classentt_1_1Bus.html | 2 +- ...01Event_00_01Other_8_8_8_01_4-members.html | 2 +- ...1Sig_00_01Event_00_01Other_8_8_8_01_4.html | 2 +- ..._1Bus_3_01Sig_00_01Event_01_4-members.html | 2 +- classentt_1_1Bus_3_01Sig_00_01Event_01_4.html | 2 +- classentt_1_1Delegate.html | 2 +- ...ate_3_01Ret_07Args_8_8_8_08_4-members.html | 2 +- ...1_1Delegate_3_01Ret_07Args_8_8_8_08_4.html | 2 +- classentt_1_1Dispatcher-members.html | 2 +- classentt_1_1Dispatcher.html | 2 +- classentt_1_1Emitter-members.html | 2 +- classentt_1_1Emitter.html | 2 +- classentt_1_1Family-members.html | 2 +- classentt_1_1Family.html | 2 +- classentt_1_1HashedString-members.html | 2 +- classentt_1_1HashedString.html | 14 +- classentt_1_1PersistentView-members.html | 4 +- classentt_1_1PersistentView.html | 138 ++++++++++-- classentt_1_1Process-members.html | 2 +- classentt_1_1Process.html | 2 +- classentt_1_1Registry-members.html | 4 +- classentt_1_1Registry.html | 202 +++++++++++++----- classentt_1_1ResourceCache-members.html | 2 +- classentt_1_1ResourceCache.html | 2 +- classentt_1_1ResourceHandle-members.html | 2 +- classentt_1_1ResourceHandle.html | 2 +- classentt_1_1ResourceLoader-members.html | 2 +- classentt_1_1ResourceLoader.html | 2 +- classentt_1_1Scheduler-members.html | 2 +- classentt_1_1Scheduler.html | 2 +- classentt_1_1SigH.html | 2 +- ..._8_8_8_08_00_01Collector_01_4-members.html | 2 +- ...t_07Args_8_8_8_08_00_01Collector_01_4.html | 2 +- classentt_1_1Signal.html | 2 +- ...al_3_01void_07Args_8_8_8_08_4-members.html | 2 +- ..._1_1Signal_3_01void_07Args_8_8_8_08_4.html | 2 +- classentt_1_1SparseSet.html | 2 +- ...Set_3_01Entity_00_01Type_01_4-members.html | 2 +- ..._1SparseSet_3_01Entity_00_01Type_01_4.html | 6 +- ..._1_1SparseSet_3_01Entity_01_4-members.html | 2 +- classentt_1_1SparseSet_3_01Entity_01_4.html | 2 +- classentt_1_1View-members.html | 4 +- classentt_1_1View.html | 134 ++++++++++-- ..._01Entity_00_01Component_01_4-members.html | 2 +- ..._1View_3_01Entity_00_01Component_01_4.html | 30 +-- classes.html | 2 +- delegate_8hpp_source.html | 4 +- dir_66e9674e8206a335795995fa32a03c91.html | 2 +- dir_68267d1309a1af8e8297ef4c3efbcdba.html | 2 +- dir_721f6154dba3c88bcdead5f446bce319.html | 2 +- dir_85dbee8884f1b3a817fa7eff8dff73ec.html | 2 +- dir_a53318306f6ac0f7fe657839abd543ab.html | 2 +- dir_b64489a1e8130d5ebf6d86d282f500f0.html | 2 +- dir_de8f4e6ba3f54a2a21309f742e93a373.html | 2 +- dir_e3a7bb56c55e5c2286e2fe96e197d4f5.html | 2 +- dispatcher_8hpp_source.html | 2 +- emitter_8hpp_source.html | 2 +- entt_8hpp_source.html | 4 +- entt__traits_8hpp_source.html | 86 ++++++++ family_8hpp_source.html | 2 +- files.html | 8 +- functions.html | 2 +- functions_0x7e.html | 2 +- functions_b.html | 2 +- functions_c.html | 2 +- functions_d.html | 2 +- functions_e.html | 5 +- functions_f.html | 2 +- functions_func.html | 2 +- functions_func_0x7e.html | 2 +- functions_func_b.html | 2 +- functions_func_c.html | 2 +- functions_func_d.html | 2 +- functions_func_e.html | 2 +- functions_func_f.html | 2 +- functions_func_g.html | 4 +- functions_func_h.html | 2 +- functions_func_l.html | 2 +- functions_func_o.html | 2 +- functions_func_p.html | 2 +- functions_func_r.html | 2 +- functions_func_s.html | 2 +- functions_func_t.html | 2 +- functions_func_u.html | 2 +- functions_func_v.html | 2 +- functions_g.html | 4 +- functions_h.html | 2 +- functions_i.html | 2 +- functions_l.html | 2 +- functions_o.html | 2 +- functions_p.html | 2 +- functions_r.html | 2 +- functions_rela.html | 2 +- functions_s.html | 2 +- functions_t.html | 2 +- functions_type.html | 5 +- functions_u.html | 2 +- functions_v.html | 2 +- functions_vars.html | 2 +- graph_legend.html | 2 +- handle_8hpp_source.html | 2 +- hashed__string_8hpp_source.html | 14 +- hierarchy.html | 2 +- ident_8hpp_source.html | 2 +- index.html | 20 +- inherits.html | 2 +- loader_8hpp_source.html | 2 +- locator_8hpp_source.html | 2 +- namespaceentt.html | 8 +- namespacemembers.html | 2 +- namespacemembers_func.html | 2 +- namespacemembers_type.html | 2 +- namespacemembers_vars.html | 2 +- namespaces.html | 2 +- process_8hpp_source.html | 2 +- registry_8hpp_source.html | 88 ++++---- scheduler_8hpp_source.html | 2 +- search/all_11.js | 4 +- search/all_4.js | 2 +- search/all_6.js | 2 +- search/functions_6.js | 2 +- search/functions_f.js | 2 +- search/typedefs_2.js | 2 +- search/typedefs_e.js | 2 +- sigh_8hpp_source.html | 4 +- signal_8hpp_source.html | 4 +- sparse__set_8hpp_source.html | 12 +- structentt_1_1Actor-members.html | 27 +-- structentt_1_1Actor.html | 22 +- ...entt_1_1Emitter_1_1Connection-members.html | 2 +- structentt_1_1Emitter_1_1Connection.html | 2 +- structentt_1_1ProcessAdaptor-members.html | 2 +- structentt_1_1ProcessAdaptor.html | 2 +- structentt_1_1ServiceLocator-members.html | 2 +- structentt_1_1ServiceLocator.html | 2 +- structentt_1_1entt__traits.html | 8 +- ...its_3_01std_1_1uint16__t_01_4-members.html | 2 +- ...ntt__traits_3_01std_1_1uint16__t_01_4.html | 8 +- ...its_3_01std_1_1uint32__t_01_4-members.html | 2 +- ...ntt__traits_3_01std_1_1uint32__t_01_4.html | 8 +- ...its_3_01std_1_1uint64__t_01_4-members.html | 2 +- ...ntt__traits_3_01std_1_1uint64__t_01_4.html | 8 +- traits_8hpp_source.html | 86 -------- view_8hpp_source.html | 74 +++---- 149 files changed, 822 insertions(+), 486 deletions(-) create mode 100644 entt__traits_8hpp_source.html delete mode 100644 traits_8hpp_source.html diff --git a/README_8md_source.html b/README_8md_source.html index 2b8b05ed9..b56cba27f 100644 --- a/README_8md_source.html +++ b/README_8md_source.html @@ -22,7 +22,7 @@
entt -  2.4.1 +  2.4.2
@@ -63,7 +63,7 @@ $(function() {
README.md
-
1 # EnTT Framework
2 
3 [![Build Status](https://travis-ci.org/skypjack/entt.svg?branch=master)](https://travis-ci.org/skypjack/entt)
4 [![Build status](https://ci.appveyor.com/api/projects/status/rvhaabjmghg715ck?svg=true)](https://ci.appveyor.com/project/skypjack/entt)
5 [![Coverage Status](https://coveralls.io/repos/github/skypjack/entt/badge.svg?branch=master)](https://coveralls.io/github/skypjack/entt?branch=master)
6 [![Donate](https://img.shields.io/badge/Donate-PayPal-green.svg)](https://www.paypal.com/cgi-bin/webscr?cmd=_donations&business=W2HF9FESD5LJY&lc=IT&item_name=Michele%20Caini&currency_code=EUR&bn=PP%2dDonationsBF%3abtn_donateCC_LG%2egif%3aNonHosted)
7 
8 # Introduction
9 
10 `EnTT` is a header-only, tiny and easy to use framework written in modern
11 C++.<br/>
12 It was originally designed entirely around an architectural pattern called _ECS_
13 that is used mostly in game development. For further details:
14 
15 * [Entity Systems Wiki](http://entity-systems.wikidot.com/)
16 * [Evolve Your Hierarchy](http://cowboyprogramming.com/2007/01/05/evolve-your-heirachy/)
17 * [ECS on Wikipedia](https://en.wikipedia.org/wiki/Entity%E2%80%93component%E2%80%93system)
18 
19 A long time ago, the sole entity-component system was part of the project. After
20 a while the codebase has grown and more and more classes have become part
21 of the repository.<br/>
22 That's why today it's called _the EnTT Framework_.
23 
24 Currently, `EnTT` is tested on Linux, Microsoft Windows and OS X. It has proven
25 to work also on both Android and iOS.<br/>
26 Most likely it will not be problematic on other systems as well, but has not
27 been sufficiently tested so far.
28 
29 ## The framework
30 
31 `EnTT` was written initially as a faster alternative to other well known and
32 open source entity-component systems. Nowadays the `EnTT` framework is moving
33 its first steps. Much more will come in the future and hopefully I'm going to
34 work on it for a long time.<br/>
35 Requests for feature, PR, suggestions ad feedback are highly appreciated.
36 
37 If you find you can help me and want to contribute to the `EnTT` framework with
38 your experience or you do want to get part of the project for some other
39 reason, feel free to contact me directly (you can find the mail in the
40 [profile](https://github.com/skypjack)).<br/>
41 I can't promise that each and every contribution will be accepted, but I can
42 assure that I'll do my best to take them all seriously.
43 
44 ### State of the art
45 
46 Here is a brief list of what it offers today:
47 
48 * Statically generated integer identifiers for types (assigned either at
49 compile-time or at runtime).
50 * A constexpr utility for human readable resource identifiers.
51 * An incredibly fast entity-component system based on sparse sets, with its own
52 views and a _pay for what you use_ policy to adjust performance and memory
53 pressure according to the users' requirements.
54 * Actor class for those who aren't confident with entity-component systems.
55 * The smallest and most basic implementation of a service locator ever seen.
56 * A cooperative scheduler for processes of any type.
57 * All what is needed for resource management (cache, loaders, handles).
58 * Signal handlers of any type, delegates and an event bus.
59 * A general purpose event emitter, that is a CRTP idiom based class template.
60 * An event dispatcher for immediate and delayed events to integrate in loops.
61 * ...
62 * Any other business.
63 
64 Consider it a work in progress. For more details and an updated list, please
65 refer to the [online documentation](https://skypjack.github.io/entt/).
66 
67 ### A note about the README
68 
69 The README file stays true to the original project and it describes only the
70 entity-component system. However, the whole API is fully documented in-code and
71 the [online documentation](https://skypjack.github.io/entt/) contains much
72 more.<br/>
73 Continue reading to know how the core part of the project works or follow the
74 link above to take a look at the API reference for all other available classes.
75 
76 ## Code Example
77 
78 ```cpp
79 #include <entt/entt.hpp>
80 #include <cstdint>
81 
82 struct Position {
83  float x;
84  float y;
85 };
86 
87 struct Velocity {
88  float dx;
89  float dy;
90 };
91 
92 void update(entt::DefaultRegistry &registry) {
93  auto view = registry.view<Position, Velocity>();
94 
95  for(auto entity: view) {
96  // gets only the components that are going to be used ...
97 
98  auto &velocity = view.get<Velocity>(entity);
99 
100  velocity.dx = 0.;
101  velocity.dy = 0.;
102 
103  // ...
104  }
105 }
106 
107 void update(std::uint64_t dt, entt::DefaultRegistry &registry) {
108  registry.view<Position, Velocity>().each([dt](auto entity, auto &position, auto &velocity) {
109  // gets all the components of the view at once ...
110 
111  position.x += velocity.dx * dt;
112  position.y += velocity.dy * dt;
113 
114  // ...
115  });
116 }
117 
118 int main() {
119  entt::DefaultRegistry registry;
120  std::uint64_t dt = 16;
121 
122  for(auto i = 0; i < 10; ++i) {
123  auto entity = registry.create(Position{i * 1.f, i * 1.f});
124  if(i % 2 == 0) { registry.assign<Velocity>(entity, i * .1f, i * .1f); }
125  }
126 
127  update(dt, registry);
128  update(registry);
129 
130  // ...
131 }
132 ```
133 
134 ## Motivation
135 
136 I started working on `EnTT` because of the wrong reason: my goal was to design
137 an entity-component system that beated another well known open source solution
138 in terms of performance.<br/>
139 In the end, I did it, but it wasn't much satisfying. Actually it wasn't
140 satisfying at all. The fastest and nothing more, fairly little indeed. When I
141 realized it, I tried hard to keep intact the great performance of `EnTT` and to
142 add all the features I wanted to see in *my* entity-component system at the same
143 time.
144 
145 Today `EnTT` is finally what I was looking for: still faster than its
146 _competitors_, a really good API and an amazing set of features. And even more,
147 of course.
148 
149 ## Performance
150 
151 As it stands right now, `EnTT` is just fast enough for my requirements if
152 compared to my first choice (it was already amazingly fast actually).<br/>
153 Here is a comparision between the two (both of them compiled with GCC 7.2.0 on a
154 Dell XPS 13 out of the mid 2014):
155 
156 | Benchmark | EntityX (compile-time) | EnTT |
157 |-----------|-------------|-------------|
158 | Create 10M entities | 0.1289s | **0.0409s** |
159 | Destroy 10M entities | **0.0531s** | 0.0546s |
160 | Standard view, 10M entities, one component | 0.0107s | **1.6e-07s** |
161 | Standard view, 10M entities, two components | **0.0113s** | 0.0295s |
162 | Standard view, 10M entities, two components<br/>Half of the entities have all the components | **0.0078s** | 0.0150s |
163 | Standard view, 10M entities, two components<br/>One of the entities has all the components | 0.0071s | **8.8e-07s** |
164 | Persistent view, 10M entities, two components | 0.0113s | **5.7e-07s** |
165 | Standard view, 10M entities, five components | **0.0091s** | 0.0688s |
166 | Persistent view, 10M entities, five components | 0.0091s | **2.9e-07s** |
167 | Standard view, 10M entities, ten components | **0.0105s** | 0.1403s |
168 | Standard view, 10M entities, ten components<br/>Half of the entities have all the components | **0.0090s** | 0.0620s |
169 | Standard view, 10M entities, ten components<br/>One of the entities has all the components | 0.0070s | **1.3e-06s** |
170 | Persistent view, 10M entities, ten components | 0.0105s | **6.2e-07s** |
171 | Sort 150k entities, one component<br/>Arrays are in reverse order | - | **0.0043s** |
172 | Sort 150k entities, enforce permutation<br/>Arrays are in reverse order | - | **0.0006s** |
173 
174 `EnTT` includes its own tests and benchmarks. See
175 [benchmark.cpp](https://github.com/skypjack/entt/blob/master/test/benchmark.cpp)
176 for further details.<br/>
177 On Github users can find also a
178 [benchmark suite](https://github.com/abeimler/ecs_benchmark) that compares a
179 bunch of different projects, one of which is `EnTT`.
180 
181 Probably I'll try to get out of `EnTT` more features and better performance in
182 the future, mainly for fun.<br/>
183 If you want to contribute and/or have any suggestion, feel free to make a PR or
184 open an issue to discuss your idea.
185 
186 # Build Instructions
187 
188 ## Requirements
189 
190 To be able to use `EnTT`, users must provide a full-featured compiler that
191 supports at least C++14.<br/>
192 The requirements below are mandatory to compile the tests and to extract the
193 documentation:
194 
195 * CMake version 3.2 or later.
196 * Doxygen version 1.8 or later.
197 
198 ## Library
199 
200 `EnTT` is a header-only library. This means that including the `entt.hpp`
201 header is enough to include the whole framework and use it. For those who are
202 interested only in the entity-component system, consider to include the sole
203 `entity/registry.hpp` header instead.<br/>
204 It's a matter of adding the following line to the top of a file:
205 
206 ```cpp
207 #include <entt/entt.hpp>
208 ```
209 
210 Use the line below to include only the entity-component system instead:
211 
212 ```cpp
213 #include <entt/entity/registry.hpp>
214 ```
215 
216 Then pass the proper `-I` argument to the compiler to add the `src` directory to
217 the include paths.
218 
219 ## Documentation
220 
221 The documentation is based on [doxygen](http://www.stack.nl/~dimitri/doxygen/).
222 To build it:
223 
224  $ cd build
225  $ cmake ..
226  $ make docs
227 
228 The API reference will be created in HTML format within the directory
229 `build/docs/html`. To navigate it with your favorite browser:
230 
231  $ cd build
232  $ your_favorite_browser docs/html/index.html
233 
234 The API reference is also available [online](https://skypjack.github.io/entt/)
235 for the latest version.
236 
237 ## Tests
238 
239 To compile and run the tests, `EnTT` requires *googletest*.<br/>
240 `cmake` will download and compile the library before to compile anything else.
241 
242 To build the tests:
243 
244 * `$ cd build`
245 * `$ cmake ..`
246 * `$ make`
247 * `$ make test`
248 
249 To build the benchmarks, use the following line instead:
250 
251 * `$ cmake -DCMAKE_BUILD_TYPE=Release ..`
252 
253 Benchmarks are compiled only in release mode currently.
254 
255 # Crash Course
256 
257 ## Design choices
258 
259 ### A bitset-free entity-component system
260 
261 `EnTT` is a _bitset-free_ entity-component system that doesn't require users to
262 specify the component set at compile-time.<br/>
263 This is why users can instantiate the core class simply like:
264 
265 ```cpp
266 entt::DefaultRegistry registry;
267 ```
268 
269 In place of its more annoying and error-prone counterpart:
270 
271 ```cpp
272 entt::DefaultRegistry<Comp0, Comp1, ..., CompN> registry;
273 ```
274 
275 ### Pay per use
276 
277 `EnTT` is entirely designed around the principle that users have to pay only for
278 what they want.
279 
280 When it comes to using an entity-componet system, the tradeoff is usually
281 between performance and memory usage. The faster it is, the more memory it uses.
282 However, slightly worse performance along non-critical paths are the right price
283 to pay to reduce memory usage and I've always wondered why this kind of tools do
284 not leave me the choice.<br/>
285 `EnTT` follows a completely different approach. It squezees the best from the
286 basic data structures and gives users the possibility to pay more for higher
287 performance where needed.<br/>
288 The disadvantage of this approach is that users need to know the systems they
289 are working on and the tools they are using. Otherwise, the risk to ruin the
290 performance along critical paths is high.
291 
292 So far, this choice has proven to be a good one and I really hope it can be for
293 many others besides me.
294 
295 ## Vademecum
296 
297 The `Registry` to store, the `View`s to iterate. That's all.
298 
299 An entity (the _E_ of an _ECS_) is an opaque identifier that users should just
300 use as-is and store around if needed. Do not try to inspect an entity
301 identifier, its type can change in future and a registry offers all the
302 functionalities to query them out-of-the-box. The underlying type of an entity
303 (either `std::uint16_t`, `std::uint32_t` or `std::uint64_t`) can be specified
304 when defining a registry (actually the DefaultRegistry is nothing more than a
305 Registry where the type of the entities is `std::uint32_t`).<br/>
306 Components (the _C_ of an _ECS_) should be plain old data structures or more
307 complex and moveable data structures with a proper constructor. Actually, the
308 sole requirement of a component type is that it must be both move constructible
309 and move assignable. They are list initialized by using the parameters provided
310 to construct the component itself. No need to register components or their types
311 neither with the registry nor with the entity-component system at all.<br/>
312 Systems (the _S_ of an _ECS_) are just plain functions, functors, lambdas or
313 whatever the users want. They can accept a Registry, a View or a PersistentView
314 and use them the way they prefer. No need to register systems or their types
315 neither with the registry nor with the entity-component system at all.
316 
317 The following sections will explain in short how to use the entity-component
318 system, the core part of the whole framework.<br/>
319 In fact, the framework is composed of many other classes in addition to those
320 describe below. For more details, please refer to the
321 [online documentation](https://skypjack.github.io/entt/).
322 
323 ## The Registry, the Entity and the Component
324 
325 A registry is used to store and manage entities as well as to create views to
326 iterate the underlying data structures.<br/>
327 Registry is a class template that lets the users decide what's the preferred
328 type to represent an entity. Because `std::uint32_t` is large enough for almost
329 all the cases, there exists also an alias named DefaultRegistry for
330 `Registry<std::uint32_t>`.
331 
332 Entities are represented by _entitiy identifiers_. An entity identifier is an
333 opaque type that users should not inspect or modify in any way. It carries
334 information about the entity itself and its version.
335 
336 A registry can be used both to construct and to destroy entities:
337 
338 ```cpp
339 // constructs a naked entity with no components ad returns its identifier
340 auto entity = registry.create();
341 
342 // constructs an entity and assigns it default-initialized components
343 auto another = registry.create<Position, Velocity>();
344 
345 // destroys an entity and all its components
346 registry.destroy(entity);
347 ```
348 
349 Once an entity is deleted, the registry can freely reuse it internally with a
350 slightly different identifier. In particular, the version of an entity is
351 increased each and every time it's destroyed.<br/>
352 In case entity identifiers are stored around, the registry offers all the
353 functionalities required to test them and get out of the them all the
354 information they carry:
355 
356 ```cpp
357 // returns true if the entity is still valid, false otherwise
358 bool b = registry.valid(entity);
359 
360 // gets the version contained in the entity identifier
361 auto version = registry.version(entity);
362 
363 // gets the actual version for the given entity
364 auto curr = registry.current(entity);
365 ```
366 
367 Components can be assigned to or removed from entities at any time with a few
368 calls to member functions of the registry. As for the entities, the registry
369 offers also a set of functionalities users can use to work with the components.
370 
371 The `assign` member function template creates, initializes and assigns to an
372 entity the given component. It accepts a variable number of arguments that are
373 used to construct the component itself if present:
374 
375 ```cpp
376 registry.assign<Position>(entity, 0., 0.);
377 
378 // ...
379 
380 auto &velocity = registry.assign<Velocity>(entity);
381 velocity.dx = 0.;
382 velocity.dy = 0.;
383 ```
384 
385 If the entity already has the given component, the `replace` member function
386 template can be used to replace it:
387 
388 ```cpp
389 registry.replace<Position>(entity, 0., 0.);
390 
391 // ...
392 
393 auto &velocity = registry.replace<Velocity>(entity);
394 velocity.dx = 0.;
395 velocity.dy = 0.;
396 ```
397 
398 In case users want to assign a component to an entity, but it's unknown whether
399 the entity already has it or not, `accomodate` does the work in a single call
400 (there is a performance penalty to pay for this mainly due to the fact that it
401 has to check if `entity` already has the given component or not):
402 
403 ```cpp
404 registry.accomodate<Position>(entity, 0., 0.);
405 
406 // ...
407 
408 auto &velocity = registry.accomodate<Velocity>(entity);
409 velocity.dx = 0.;
410 velocity.dy = 0.;
411 ```
412 
413 Note that `accomodate` is a sliglhty faster alternative for the following
414 `if`/`else` statement and nothing more:
415 
416 ```cpp
417 if(registry.has<Comp>(entity)) {
418  registry.replace<Comp>(entity, arg1, argN);
419 } else {
420  registry.assign<Comp>(entity, arg1, argN);
421 }
422 ```
423 
424 As already shown, if in doubt about whether or not an entity has one or more
425 components, the `has` member function template may be useful:
426 
427 ```cpp
428 bool b = registry.has<Position, Velocity>(entity);
429 ```
430 
431 On the other side, if the goal is to delete a single component, the `remove`
432 member function template is the way to go when it's certain that the entity owns
433 a copy of the component:
434 
435 ```cpp
436 registry.remove<Position>(entity);
437 ```
438 
439 Otherwise consider to use the `reset` member function. It behaves similarly to
440 `remove` but with a strictly defined behaviour (and a performance penalty is the
441 price to pay for this). In particular it removes the component if and only if it
442 exists, otherwise it returns safely to the caller:
443 
444 ```cpp
445 registry.reset<Position>(entity);
446 ```
447 
448 There exist also two other _versions_ of the `reset` member function:
449 
450 * If no entity is passed to it, `reset` will remove the given component from
451 each entity that has it:
452 
453  ```cpp
454  registry.reset<Position>();
455  ```
456 
457 * If neither the entity nor the component are specified, all the entities and
458 their components are destroyed:
459 
460  ```cpp
461  registry.reset();
462  ```
463 
464 Finally, references to components can be retrieved simply by doing this:
465 
466 ```cpp
467 // either a non-const reference ...
468 entt::DefaultRegistry registry;
469 auto &position = registry.get<Position>(entity);
470 
471 // ... or a const one
472 const auto &cregistry = registry;
473 const auto &position = cregistry.get<Position>(entity);
474 ```
475 
476 The `get` member function template gives direct access to the component of an
477 entity stored in the underlying data structures of the registry.
478 
479 ### Single instance components
480 
481 In those cases where all what is needed is a single instance component, tags are
482 the right tool to achieve the purpose.<br/>
483 Tags undergo the same requirements of components. They can be either plain old
484 data structures or more complex and moveable data structures with a proper
485 constructor.<br/>
486 Actually, the same type can be used both as a tag and as a component and the
487 registry will not complain about it. It is up to the users to properly manage
488 their own types.
489 
490 Attaching tags to entities and removing them is trivial:
491 
492 ```cpp
493 auto player = registry.create();
494 auto camera = registry.create();
495 
496 // attaches a default-initialized tag to an entity
497 registry.attach<PlayingCharacter>(player);
498 
499 // attaches a tag to an entity and initializes it
500 registry.attach<Camera>(camera, player);
501 
502 // removes tags from their owners
503 registry.remove<PlayingCharacter>();
504 registry.remove<Camera>();
505 ```
506 
507 If in doubt about whether or not a tag has already an owner, the `has` member
508 function template may be useful:
509 
510 ```cpp
511 bool b = registry.has<PlayingCharacter>();
512 ```
513 
514 References to tags can be retrieved simply by doing this:
515 
516 ```cpp
517 // either a non-const reference ...
518 entt::DefaultRegistry registry;
519 auto &player = registry.get<PlayingCharacter>();
520 
521 // ... or a const one
522 const auto &cregistry = registry;
523 const auto &camera = cregistry.get<Camera>();
524 ```
525 
526 The `get` member function template gives direct access to the tag as stored in
527 the underlying data structures of the registry.
528 
529 As shown above, in almost all the cases the entity identifier isn't required,
530 since a single instance component can have only one associated entity and
531 therefore it doesn't make much sense to mention it explicitly.<br/>
532 To find out who the owner is, just do the following:
533 
534 ```cpp
535 auto player = registry.attachee<PlayingCharacter>();
536 ```
537 
538 Note that iterating tags isn't possible for obvious reasons. Tags give direct
539 access to single entities and nothing more.
540 
541 ### Runtime components
542 
543 Defining components at runtime is useful to support plugins and mods in general.
544 However, it seems impossible with a tool designed around a bunch of templates.
545 Indeed it's not that difficult.<br/>
546 Of course, some features cannot be easily exported into a runtime
547 environment. As an example, sorting a group of components defined at runtime
548 isn't for free if compared to most of the other operations. However, the basic
549 functionalities of an entity-component system such as `EnTT` fit the problem
550 perfectly and can also be used to manage runtime components if required.<br/>
551 All that is necessary to do it is to know the identifiers of the components. An
552 identifier is nothing more than a number or similar that can be used at runtime
553 to work with the type system.
554 
555 In `EnTT`, identifiers are easily accessible:
556 
557 ```cpp
558 entt::DefaultRegistry registry;
559 
560 // standard component identifier
561 auto ctype = registry.component<Position>();
562 
563 // single instance component identifier
564 auto ttype = registry.tag<PlayingCharacter>();
565 ```
566 
567 Once the identifiers are made available, almost everything becomes pretty
568 simple.
569 
570 #### A journey through a plugin
571 
572 `EnTT` comes with an example (actually a test) that shows how to integrate
573 compile-time and runtime components in a stack based JavaScript environment. It
574 uses [`duktape`](https://github.com/svaarala/duktape) under the hood, mainly
575 because I wanted to learn how it works at the time I was writing the code.
576 
577 It's not production-ready and overall performance can be highly improved.
578 However, I sacrificed optimizations in favor of a more readable piece of
579 code. I hope I succeeded.<br/>
580 Note also that this isn't neither the only nor (probably) the best way to do it.
581 In fact, the right way depends on the scripting language and the problem one is
582 facing in general.
583 
584 The basic idea is that of creating a compile-time component aimed to map all the
585 runtime components assigned to an entity.<br/>
586 Identifiers come in use to address the right function from a map when invoked
587 from the runtime environment and to filter entities when iterating.<br/>
588 With a bit of gymnastic, one can narrow views and improve the performance to
589 some extent but it was not the goal of the example.
590 
591 ### Sorting: is it possible?
592 
593 It goes without saying that sorting entities and components is possible with
594 `EnTT`.<br/>
595 In fact, there are two functions that respond to slightly different needs:
596 
597 * Components can be sorted directly:
598 
599  ```cpp
600  registry.sort<Renderable>([](const auto &lhs, const auto &rhs) {
601  return lhs.z < rhs.z;
602  });
603  ```
604 
605 * Components can be sorted according to the order imposed by another component:
606 
607  ```cpp
608  registry.sort<Movement, Physics>();
609  ```
610 
611  In this case, instances of `Movement` are arranged in memory so that cache
612  misses are minimized when the two components are iterated together.
613 
614 ## View: to persist or not to persist?
615 
616 There are mainly two kinds of views: standard (also known as View) and
617 persistent (alsa known as PersistentView).<br/>
618 Both of them have pros and cons to take in consideration. In particular:
619 
620 * Standard views:
621 
622  Pros:
623  * They work out-of-the-box and don't require any dedicated data
624  structure.
625  * Creating and destroying them isn't expensive at all because they don't
626  have any type of initialization.
627  * They are the best tool to iterate single components.
628  * They are the best tool to iterate multiple components at once when
629  tags are involved or one of the component is assigned to a
630  significantly low number of entities.
631  * They don't affect any other operations of the registry.
632 
633  Cons:
634  * Their performance tend to degenerate when the number of components
635  to iterate grows up and the most of the entities have all of them.
636 
637 * Persistent views:
638 
639  Pros:
640  * Once prepared, creating and destroying them isn't expensive at all
641  because they don't have any type of initialization.
642  * They are the best tool to iterate multiple components at once when
643  the most of the entities have all of them.
644 
645  Cons:
646  * They have dedicated data structures and thus affect the memory
647  pressure to a minimal extent.
648  * If not previously prepared, the first time they are used they go
649  through an initialization step that could take a while.
650  * They affect to a minimum the creation and destruction of entities and
651  components. In other terms: the more persistent views there will be,
652  the less performing will be creating and destroying entities and
653  components.
654 
655 To sum up and as a rule of thumb, use a standard view:
656 * To iterate entities for a single component.
657 * To iterate entities for multiple components when a significantly low
658  number of entities have one of the components.
659 * In all those cases where a persistent view would give a boost to
660  performance but the iteration isn't performed frequently.
661 
662 Use a persistent view in all the other cases.
663 
664 To easily iterate entities, all the views offer the common `begin` and `end`
665 member functions that allow users to use a view in a typical range-for
666 loop.<br/>
667 Continue reading for more details or refer to the
668 [official documentation](https://skypjack.github.io/entt/).
669 
670 ### Standard View
671 
672 A standard view behaves differently if it's constructed for a single component
673 or if it has been requested to iterate multiple components. Even the API is
674 different in the two cases.<br/>
675 All that they share is the way they are created by means of a registry:
676 
677 ```cpp
678 // single component standard view
679 auto single = registry.view<Position>();
680 
681 // multi component standard view
682 auto multi = registry.view<Position, Velocity>();
683 ```
684 
685 For all that remains, it's worth discussing them separately.<br/>
686 
687 #### Single component standard view
688 
689 Single component standard views are specialized in order to give a boost in
690 terms of performance in all the situation. This kind of views can access the
691 underlying data structures directly and avoid superflous checks.<br/>
692 They offer a bunch of functionalities to get the number of entities they are
693 going to return and a raw access to the entity list as well as to the component
694 list.<br/>
695 Refer to the [official documentation](https://skypjack.github.io/entt/) for all
696 the details.
697 
698 There is no need to store views around for they are extremely cheap to
699 construct, even though they can be copied without problems and reused
700 freely. In fact, they return newly created and correctly initialized iterators
701 whenever `begin` or `end` are invoked.<br/>
702 To iterate a single component standard view, either use it in range-for loop:
703 
704 ```cpp
705 auto view = registry.view<Renderable>();
706 
707 for(auto entity: view) {
708  auto &renderable = view.get(entity);
709 
710  // ...
711 }
712 ```
713 
714 Or rely on the `each` member function to iterate entities and get all their
715 components at once:
716 
717 ```cpp
718 registry.view<Renderable>().each([](auto entity, auto &renderable) {
719  // ...
720 });
721 ```
722 
723 Performance are more or less the same. The best approach depends mainly on
724 whether all the components have to be accessed or not.
725 
726 **Note**: prefer the `get` member function of a view instead of the `get` member
727 function template of a registry during iterations, if possible. However, keep in
728 mind that it works only with the components of the view itself.
729 
730 #### Multi component standard view
731 
732 Multi component standard views iterate entities that have at least all the given
733 components in their bags. During construction, these views look at the number
734 of entities available for each component and pick up a reference to the smallest
735 set of candidates in order to speed up iterations.<br/>
736 They offer fewer functionalities than their companion views for single
737 component, the most important of which can be used to reset the view and refresh
738 the reference to the set of candidate entities to iterate.<br/>
739 Refer to the [official documentation](https://skypjack.github.io/entt/) for all
740 the details.
741 
742 There is no need to store views around for they are extremely cheap to
743 construct, even though they can be copied without problems and reused
744 freely. In fact, they return newly created and correctly initialized iterators
745 whenever `begin` or `end` are invoked.<br/>
746 To iterate a multi component standard view, either use it in range-for loop:
747 
748 ```cpp
749 auto view = registry.view<Position, Velocity>();
750 
751 for(auto entity: view) {
752  auto &position = view.get<Position>(entity);
753  auto &velocity = view.get<Velocity>(entity);
754 
755  // ...
756 }
757 ```
758 
759 Or rely on the `each` member function to iterate entities and get all their
760 components at once:
761 
762 ```cpp
763 registry.view<Position, Velocity>().each([](auto entity, auto &position, auto &velocity) {
764  // ...
765 });
766 ```
767 
768 Performance are more or less the same. The best approach depends mainly on
769 whether all the components have to be accessed or not.
770 
771 **Note**: prefer the `get` member function of a view instead of the `get` member
772 function template of a registry during iterations, if possible. However, keep in
773 mind that it works only with the components of the view itself.
774 
775 ### Persistent View
776 
777 A persistent view returns all the entities and only the entities that have at
778 least the given components. Moreover, it's guaranteed that the entity list is
779 thightly packed in memory for fast iterations.<br/>
780 In general, persistent views don't stay true to the order of any set of
781 components unless users explicitly sort them.
782 
783 Persistent views can be used only to iterate multiple components. Create them
784 as it follows:
785 
786 ```cpp
787 auto view = registry.persistent<Position, Velocity>();
788 ```
789 
790 There is no need to store views around for they are extremely cheap to
791 construct, even though they can be copied without problems and reused
792 freely. In fact, they return newly created and correctly initialized iterators
793 whenever `begin` or `end` are invoked.<br/>
794 That being said, persistent views perform an initialization step the very first
795 time they are constructed and this could be quite costly. To avoid it, consider
796 asking to the registry to _prepare_ them when no entities have been created yet:
797 
798 ```cpp
799 registry.prepare<Position, Velocity>();
800 ```
801 
802 If the registry is empty, preparation is extremely fast. Moreover the `prepare`
803 member function template is idempotent. Feel free to invoke it even more than
804 once: if the view has been alreadt prepared before, the function returns
805 immediately and does nothing.
806 
807 A persistent view offers a bunch of functionalities to get the number of
808 entities it's going to return, a raw access to the entity list and the
809 possibility to sort the underlying data structures according to the order of one
810 of the components for which it has been constructed.<br/>
811 Refer to the [official documentation](https://skypjack.github.io/entt/) for all
812 the details.
813 
814 To iterate a persistent view, either use it in range-for loop:
815 
816 ```cpp
817 auto view = registry.persistent<Position, Velocity>();
818 
819 for(auto entity: view) {
820  auto &position = view.get<Position>(entity);
821  auto &velocity = view.get<Velocity>(entity);
822 
823  // ...
824 }
825 ```
826 
827 Or rely on the `each` member function to iterate entities and get all their
828 components at once:
829 
830 ```cpp
831 registry.persistent<Position, Velocity>().each([](auto entity, auto &position, auto &velocity) {
832  // ...
833 });
834 ```
835 
836 Performance are more or less the same. The best approach depends mainly on
837 whether all the components have to be accessed or not.
838 
839 **Note**: prefer the `get` member function of a view instead of the `get` member
840 function template of a registry during iterations, if possible. However, keep in
841 mind that it works only with the components of the view itself.
842 
843 ### Give me everything
844 
845 Views are narrow windows on the entire list of entities. They work by filtering
846 entities according to their components.<br/>
847 In some cases there may be the need to iterate all the entities regardless of
848 their components. The registry offers a specific member function to do that:
849 
850 ```cpp
851 registry.each([](auto entity) {
852  // ...
853 });
854 ```
855 
856 Each entity ever created is returned, no matter if it's in use or not.<br/>
857 Usually, filtering entities that aren't currently in use is more expensive than
858 iterating them all and filtering out those in which one isn't interested.
859 
860 As a rule of thumb, consider using a view if the goal is to iterate entities
861 that have a determinate set of components. A view is usually faster than
862 combining this function with a bunch of custom tests.<br/>
863 In all the other cases, this is the way to go.
864 
865 ## Side notes
866 
867 * Entity identifiers are numbers and nothing more. They are not classes and they
868  have no member functions at all. As already mentioned, do no try to inspect or
869  modify an entity descriptor in any way.
870 
871 * As shown in the examples above, the preferred way to get references to the
872  components while iterating a view is by using the view itself. It's a faster
873  alternative to the `get` member function template that is part of the API of
874  the Registry. This is because the registry must ensure that a pool for the
875  given component exists before to use it; on the other side, views force the
876  construction of the pools for all their components and access them directly,
877  thus avoiding all the checks.
878 
879 * Most of the _ECS_ available out there have an annoying limitation (at least
880  from my point of view): entities and components cannot be created and/or
881  deleted during iterations.<br/>
882  `EnTT` partially solves the problem with a few limitations:
883 
884  * Creating entities and components is allowed during iterations.
885  * Deleting an entity or removing its components is allowed during
886  iterations if it's the one currently returned by a view. For all the
887  other entities, destroying them or removing their components isn't
888  allowed and it can result in undefined behavior.
889 
890  Iterators are invalidated and the behaviour is undefined if an entity is
891  modified or destroyed and it's not the one currently returned by the
892  view.<br/>
893  To work around it, possible approaches are:
894 
895  * Store aside the entities and the components to be removed and perform the
896  operations at the end of the iteration.
897  * Mark entities and components with a proper tag component that indicates
898  they must be purged, then perform a second iteration to clean them up one
899  by one.
900 
901 * Views and thus their iterators aren't thread safe. Do no try to iterate a set
902  of components and modify the same set concurrently.<br/>
903  That being said, as long as a thread iterates the entities that have the
904  component `X` or assign and removes that component from a set of entities,
905  another thread can safely do the same with components `Y` and `Z` and
906  everything will work like a charm.<br/>
907  As an example, users can freely execute the rendering system and iterate the
908  renderable entities while updating a physic component concurrently on a
909  separate thread if needed.
910 
911 # Contributors
912 
913 If you want to contribute, please send patches as pull requests against the
914 branch `master`.<br/>
915 Check the
916 [contributors list](https://github.com/skypjack/entt/blob/master/AUTHORS) to see
917 who has partecipated so far.
918 
919 # License
920 
921 Code and documentation Copyright (c) 2017 Michele Caini.<br/>
922 Code released under
923 [the MIT license](https://github.com/skypjack/entt/blob/master/LICENSE).
924 Docs released under
925 [Creative Commons](https://github.com/skypjack/entt/blob/master/docs/LICENSE).
926 
927 # Donation
928 
929 Developing and maintaining `EnTT` takes some time and lots of coffee. I'd like
930 to add more and more functionalities in future and turn it in a full-featured
931 framework.<br/>
932 If you want to support this project, you can offer me an espresso. I'm from
933 Italy, we're used to turning the best coffee ever in code. If you find that
934 it's not enough, feel free to support me the way you prefer.<br/>
935 Take a look at the donation button at the top of the page for more details or
936 just click [here](https://www.paypal.com/cgi-bin/webscr?cmd=_donations&business=W2HF9FESD5LJY&lc=IT&item_name=Michele%20Caini&currency_code=EUR&bn=PP%2dDonationsBF%3abtn_donateCC_LG%2egif%3aNonHosted).
+
1 # EnTT Framework
2 
3 [![Build Status](https://travis-ci.org/skypjack/entt.svg?branch=master)](https://travis-ci.org/skypjack/entt)
4 [![Build status](https://ci.appveyor.com/api/projects/status/rvhaabjmghg715ck?svg=true)](https://ci.appveyor.com/project/skypjack/entt)
5 [![Coverage Status](https://coveralls.io/repos/github/skypjack/entt/badge.svg?branch=master)](https://coveralls.io/github/skypjack/entt?branch=master)
6 [![Donate](https://img.shields.io/badge/Donate-PayPal-green.svg)](https://www.paypal.com/cgi-bin/webscr?cmd=_donations&business=W2HF9FESD5LJY&lc=IT&item_name=Michele%20Caini&currency_code=EUR&bn=PP%2dDonationsBF%3abtn_donateCC_LG%2egif%3aNonHosted)
7 
8 # Introduction
9 
10 `EnTT` is a header-only, tiny and easy to use framework written in modern
11 C++.<br/>
12 It was originally designed entirely around an architectural pattern called _ECS_
13 that is used mostly in game development. For further details:
14 
15 * [Entity Systems Wiki](http://entity-systems.wikidot.com/)
16 * [Evolve Your Hierarchy](http://cowboyprogramming.com/2007/01/05/evolve-your-heirachy/)
17 * [ECS on Wikipedia](https://en.wikipedia.org/wiki/Entity%E2%80%93component%E2%80%93system)
18 
19 A long time ago, the sole entity-component system was part of the project. After
20 a while the codebase has grown and more and more classes have become part
21 of the repository.<br/>
22 That's why today it's called _the EnTT Framework_.
23 
24 Currently, `EnTT` is tested on Linux, Microsoft Windows and OS X. It has proven
25 to work also on both Android and iOS.<br/>
26 Most likely it will not be problematic on other systems as well, but has not
27 been sufficiently tested so far.
28 
29 ## The framework
30 
31 `EnTT` was written initially as a faster alternative to other well known and
32 open source entity-component systems. Nowadays the `EnTT` framework is moving
33 its first steps. Much more will come in the future and hopefully I'm going to
34 work on it for a long time.<br/>
35 Requests for feature, PR, suggestions ad feedback are highly appreciated.
36 
37 If you find you can help me and want to contribute to the `EnTT` framework with
38 your experience or you do want to get part of the project for some other
39 reason, feel free to contact me directly (you can find the mail in the
40 [profile](https://github.com/skypjack)).<br/>
41 I can't promise that each and every contribution will be accepted, but I can
42 assure that I'll do my best to take them all seriously.
43 
44 ### State of the art
45 
46 Here is a brief list of what it offers today:
47 
48 * Statically generated integer identifiers for types (assigned either at
49 compile-time or at runtime).
50 * A constexpr utility for human readable resource identifiers.
51 * An incredibly fast entity-component system based on sparse sets, with its own
52 views and a _pay for what you use_ policy to adjust performance and memory
53 pressure according to the users' requirements.
54 * Actor class for those who aren't confident with entity-component systems.
55 * The smallest and most basic implementation of a service locator ever seen.
56 * A cooperative scheduler for processes of any type.
57 * All what is needed for resource management (cache, loaders, handles).
58 * Signal handlers of any type, delegates and an event bus.
59 * A general purpose event emitter, that is a CRTP idiom based class template.
60 * An event dispatcher for immediate and delayed events to integrate in loops.
61 * ...
62 * Any other business.
63 
64 Consider it a work in progress. For more details and an updated list, please
65 refer to the [online documentation](https://skypjack.github.io/entt/).
66 
67 ### A note about the README
68 
69 The README file stays true to the original project and it describes only the
70 entity-component system. However, the whole API is fully documented in-code and
71 the [online documentation](https://skypjack.github.io/entt/) contains much
72 more.<br/>
73 Continue reading to know how the core part of the project works or follow the
74 link above to take a look at the API reference for all other available classes.
75 
76 ## Code Example
77 
78 ```cpp
79 #include <entt/entt.hpp>
80 #include <cstdint>
81 
82 struct Position {
83  float x;
84  float y;
85 };
86 
87 struct Velocity {
88  float dx;
89  float dy;
90 };
91 
92 void update(entt::DefaultRegistry &registry) {
93  auto view = registry.view<Position, Velocity>();
94 
95  for(auto entity: view) {
96  // gets only the components that are going to be used ...
97 
98  auto &velocity = view.get<Velocity>(entity);
99 
100  velocity.dx = 0.;
101  velocity.dy = 0.;
102 
103  // ...
104  }
105 }
106 
107 void update(std::uint64_t dt, entt::DefaultRegistry &registry) {
108  registry.view<Position, Velocity>().each([dt](auto entity, auto &position, auto &velocity) {
109  // gets all the components of the view at once ...
110 
111  position.x += velocity.dx * dt;
112  position.y += velocity.dy * dt;
113 
114  // ...
115  });
116 }
117 
118 int main() {
119  entt::DefaultRegistry registry;
120  std::uint64_t dt = 16;
121 
122  for(auto i = 0; i < 10; ++i) {
123  auto entity = registry.create(Position{i * 1.f, i * 1.f});
124  if(i % 2 == 0) { registry.assign<Velocity>(entity, i * .1f, i * .1f); }
125  }
126 
127  update(dt, registry);
128  update(registry);
129 
130  // ...
131 }
132 ```
133 
134 ## Motivation
135 
136 I started working on `EnTT` because of the wrong reason: my goal was to design
137 an entity-component system that beated another well known open source solution
138 in terms of performance.<br/>
139 In the end, I did it, but it wasn't much satisfying. Actually it wasn't
140 satisfying at all. The fastest and nothing more, fairly little indeed. When I
141 realized it, I tried hard to keep intact the great performance of `EnTT` and to
142 add all the features I wanted to see in *my* entity-component system at the same
143 time.
144 
145 Today `EnTT` is finally what I was looking for: still faster than its
146 _competitors_, a really good API and an amazing set of features. And even more,
147 of course.
148 
149 ## Performance
150 
151 As it stands right now, `EnTT` is just fast enough for my requirements if
152 compared to my first choice (it was already amazingly fast actually).<br/>
153 Here is a comparision between the two (both of them compiled with GCC 7.2.0 on a
154 Dell XPS 13 out of the mid 2014):
155 
156 | Benchmark | EntityX (compile-time) | EnTT |
157 |-----------|-------------|-------------|
158 | Create 10M entities | 0.1289s | **0.0409s** |
159 | Destroy 10M entities | **0.0531s** | 0.0546s |
160 | Standard view, 10M entities, one component | 0.0107s | **1.6e-07s** |
161 | Standard view, 10M entities, two components | **0.0113s** | 0.0295s |
162 | Standard view, 10M entities, two components<br/>Half of the entities have all the components | **0.0078s** | 0.0150s |
163 | Standard view, 10M entities, two components<br/>One of the entities has all the components | 0.0071s | **8.8e-07s** |
164 | Persistent view, 10M entities, two components | 0.0113s | **5.7e-07s** |
165 | Standard view, 10M entities, five components | **0.0091s** | 0.0688s |
166 | Persistent view, 10M entities, five components | 0.0091s | **2.9e-07s** |
167 | Standard view, 10M entities, ten components | **0.0105s** | 0.1403s |
168 | Standard view, 10M entities, ten components<br/>Half of the entities have all the components | **0.0090s** | 0.0620s |
169 | Standard view, 10M entities, ten components<br/>One of the entities has all the components | 0.0070s | **1.3e-06s** |
170 | Persistent view, 10M entities, ten components | 0.0105s | **6.2e-07s** |
171 | Sort 150k entities, one component<br/>Arrays are in reverse order | - | **0.0043s** |
172 | Sort 150k entities, enforce permutation<br/>Arrays are in reverse order | - | **0.0006s** |
173 
174 `EnTT` includes its own tests and benchmarks. See
175 [benchmark.cpp](https://github.com/skypjack/entt/blob/master/test/benchmark.cpp)
176 for further details.<br/>
177 On Github users can find also a
178 [benchmark suite](https://github.com/abeimler/ecs_benchmark) that compares a
179 bunch of different projects, one of which is `EnTT`.
180 
181 Probably I'll try to get out of `EnTT` more features and better performance in
182 the future, mainly for fun.<br/>
183 If you want to contribute and/or have any suggestion, feel free to make a PR or
184 open an issue to discuss your idea.
185 
186 # Build Instructions
187 
188 ## Requirements
189 
190 To be able to use `EnTT`, users must provide a full-featured compiler that
191 supports at least C++14.<br/>
192 The requirements below are mandatory to compile the tests and to extract the
193 documentation:
194 
195 * CMake version 3.2 or later.
196 * Doxygen version 1.8 or later.
197 
198 ## Library
199 
200 `EnTT` is a header-only library. This means that including the `entt.hpp`
201 header is enough to include the whole framework and use it. For those who are
202 interested only in the entity-component system, consider to include the sole
203 `entity/registry.hpp` header instead.<br/>
204 It's a matter of adding the following line to the top of a file:
205 
206 ```cpp
207 #include <entt/entt.hpp>
208 ```
209 
210 Use the line below to include only the entity-component system instead:
211 
212 ```cpp
213 #include <entt/entity/registry.hpp>
214 ```
215 
216 Then pass the proper `-I` argument to the compiler to add the `src` directory to
217 the include paths.
218 
219 ## Documentation
220 
221 The documentation is based on [doxygen](http://www.stack.nl/~dimitri/doxygen/).
222 To build it:
223 
224  $ cd build
225  $ cmake ..
226  $ make docs
227 
228 The API reference will be created in HTML format within the directory
229 `build/docs/html`. To navigate it with your favorite browser:
230 
231  $ cd build
232  $ your_favorite_browser docs/html/index.html
233 
234 The API reference is also available [online](https://skypjack.github.io/entt/)
235 for the latest version.
236 
237 ## Tests
238 
239 To compile and run the tests, `EnTT` requires *googletest*.<br/>
240 `cmake` will download and compile the library before to compile anything else.
241 
242 To build the tests:
243 
244 * `$ cd build`
245 * `$ cmake ..`
246 * `$ make`
247 * `$ make test`
248 
249 To build the benchmarks, use the following line instead:
250 
251 * `$ cmake -DCMAKE_BUILD_TYPE=Release ..`
252 
253 Benchmarks are compiled only in release mode currently.
254 
255 # Crash Course
256 
257 ## Design choices
258 
259 ### A bitset-free entity-component system
260 
261 `EnTT` is a _bitset-free_ entity-component system that doesn't require users to
262 specify the component set at compile-time.<br/>
263 This is why users can instantiate the core class simply like:
264 
265 ```cpp
266 entt::DefaultRegistry registry;
267 ```
268 
269 In place of its more annoying and error-prone counterpart:
270 
271 ```cpp
272 entt::DefaultRegistry<Comp0, Comp1, ..., CompN> registry;
273 ```
274 
275 ### Pay per use
276 
277 `EnTT` is entirely designed around the principle that users have to pay only for
278 what they want.
279 
280 When it comes to using an entity-componet system, the tradeoff is usually
281 between performance and memory usage. The faster it is, the more memory it uses.
282 However, slightly worse performance along non-critical paths are the right price
283 to pay to reduce memory usage and I've always wondered why this kind of tools do
284 not leave me the choice.<br/>
285 `EnTT` follows a completely different approach. It squezees the best from the
286 basic data structures and gives users the possibility to pay more for higher
287 performance where needed.<br/>
288 The disadvantage of this approach is that users need to know the systems they
289 are working on and the tools they are using. Otherwise, the risk to ruin the
290 performance along critical paths is high.
291 
292 So far, this choice has proven to be a good one and I really hope it can be for
293 many others besides me.
294 
295 ## Vademecum
296 
297 The `Registry` to store, the `View`s to iterate. That's all.
298 
299 An entity (the _E_ of an _ECS_) is an opaque identifier that users should just
300 use as-is and store around if needed. Do not try to inspect an entity
301 identifier, its type can change in future and a registry offers all the
302 functionalities to query them out-of-the-box. The underlying type of an entity
303 (either `std::uint16_t`, `std::uint32_t` or `std::uint64_t`) can be specified
304 when defining a registry (actually the DefaultRegistry is nothing more than a
305 Registry where the type of the entities is `std::uint32_t`).<br/>
306 Components (the _C_ of an _ECS_) should be plain old data structures or more
307 complex and moveable data structures with a proper constructor. Actually, the
308 sole requirement of a component type is that it must be both move constructible
309 and move assignable. They are list initialized by using the parameters provided
310 to construct the component itself. No need to register components or their types
311 neither with the registry nor with the entity-component system at all.<br/>
312 Systems (the _S_ of an _ECS_) are just plain functions, functors, lambdas or
313 whatever the users want. They can accept a Registry, a View or a PersistentView
314 and use them the way they prefer. No need to register systems or their types
315 neither with the registry nor with the entity-component system at all.
316 
317 The following sections will explain in short how to use the entity-component
318 system, the core part of the whole framework.<br/>
319 In fact, the framework is composed of many other classes in addition to those
320 describe below. For more details, please refer to the
321 [online documentation](https://skypjack.github.io/entt/).
322 
323 ## The Registry, the Entity and the Component
324 
325 A registry is used to store and manage entities as well as to create views to
326 iterate the underlying data structures.<br/>
327 Registry is a class template that lets the users decide what's the preferred
328 type to represent an entity. Because `std::uint32_t` is large enough for almost
329 all the cases, there exists also an alias named DefaultRegistry for
330 `Registry<std::uint32_t>`.
331 
332 Entities are represented by _entitiy identifiers_. An entity identifier is an
333 opaque type that users should not inspect or modify in any way. It carries
334 information about the entity itself and its version.
335 
336 A registry can be used both to construct and to destroy entities:
337 
338 ```cpp
339 // constructs a naked entity with no components ad returns its identifier
340 auto entity = registry.create();
341 
342 // constructs an entity and assigns it default-initialized components
343 auto another = registry.create<Position, Velocity>();
344 
345 // destroys an entity and all its components
346 registry.destroy(entity);
347 ```
348 
349 Once an entity is deleted, the registry can freely reuse it internally with a
350 slightly different identifier. In particular, the version of an entity is
351 increased each and every time it's destroyed.<br/>
352 In case entity identifiers are stored around, the registry offers all the
353 functionalities required to test them and get out of the them all the
354 information they carry:
355 
356 ```cpp
357 // returns true if the entity is still valid, false otherwise
358 bool b = registry.valid(entity);
359 
360 // gets the version contained in the entity identifier
361 auto version = registry.version(entity);
362 
363 // gets the actual version for the given entity
364 auto curr = registry.current(entity);
365 ```
366 
367 Components can be assigned to or removed from entities at any time with a few
368 calls to member functions of the registry. As for the entities, the registry
369 offers also a set of functionalities users can use to work with the components.
370 
371 The `assign` member function template creates, initializes and assigns to an
372 entity the given component. It accepts a variable number of arguments that are
373 used to construct the component itself if present:
374 
375 ```cpp
376 registry.assign<Position>(entity, 0., 0.);
377 
378 // ...
379 
380 Velocity &velocity = registry.assign<Velocity>(entity);
381 velocity.dx = 0.;
382 velocity.dy = 0.;
383 ```
384 
385 If the entity already has the given component, the `replace` member function
386 template can be used to replace it:
387 
388 ```cpp
389 registry.replace<Position>(entity, 0., 0.);
390 
391 // ...
392 
393 Velocity &velocity = registry.replace<Velocity>(entity);
394 velocity.dx = 0.;
395 velocity.dy = 0.;
396 ```
397 
398 In case users want to assign a component to an entity, but it's unknown whether
399 the entity already has it or not, `accomodate` does the work in a single call
400 (there is a performance penalty to pay for this mainly due to the fact that it
401 has to check if `entity` already has the given component or not):
402 
403 ```cpp
404 registry.accomodate<Position>(entity, 0., 0.);
405 
406 // ...
407 
408 Velocity &velocity = registry.accomodate<Velocity>(entity);
409 velocity.dx = 0.;
410 velocity.dy = 0.;
411 ```
412 
413 Note that `accomodate` is a sliglhty faster alternative for the following
414 `if`/`else` statement and nothing more:
415 
416 ```cpp
417 if(registry.has<Comp>(entity)) {
418  registry.replace<Comp>(entity, arg1, argN);
419 } else {
420  registry.assign<Comp>(entity, arg1, argN);
421 }
422 ```
423 
424 As already shown, if in doubt about whether or not an entity has one or more
425 components, the `has` member function template may be useful:
426 
427 ```cpp
428 bool b = registry.has<Position, Velocity>(entity);
429 ```
430 
431 On the other side, if the goal is to delete a single component, the `remove`
432 member function template is the way to go when it's certain that the entity owns
433 a copy of the component:
434 
435 ```cpp
436 registry.remove<Position>(entity);
437 ```
438 
439 Otherwise consider to use the `reset` member function. It behaves similarly to
440 `remove` but with a strictly defined behaviour (and a performance penalty is the
441 price to pay for this). In particular it removes the component if and only if it
442 exists, otherwise it returns safely to the caller:
443 
444 ```cpp
445 registry.reset<Position>(entity);
446 ```
447 
448 There exist also two other _versions_ of the `reset` member function:
449 
450 * If no entity is passed to it, `reset` will remove the given component from
451 each entity that has it:
452 
453  ```cpp
454  registry.reset<Position>();
455  ```
456 
457 * If neither the entity nor the component are specified, all the entities and
458 their components are destroyed:
459 
460  ```cpp
461  registry.reset();
462  ```
463 
464 Finally, references to components can be retrieved simply by doing this:
465 
466 ```cpp
467 entt::DefaultRegistry registry;
468 const auto &cregistry = registry;
469 
470 // const and non-const reference
471 const Position &position = cregistry.get<Position>(entity);
472 Position &position = registry.get<Position>(entity);
473 
474 // const and non-const references
475 std::tuple<const Position &, const Velocity &> tup = cregistry.get<Position, Velocity>(entity);
476 std::tuple<Position &, Velocity &> tup = registry.get<Position, Velocity>(entity);
477 ```
478 
479 The `get` member function template gives direct access to the component of an
480 entity stored in the underlying data structures of the registry.
481 
482 ### Single instance components
483 
484 In those cases where all what is needed is a single instance component, tags are
485 the right tool to achieve the purpose.<br/>
486 Tags undergo the same requirements of components. They can be either plain old
487 data structures or more complex and moveable data structures with a proper
488 constructor.<br/>
489 Actually, the same type can be used both as a tag and as a component and the
490 registry will not complain about it. It is up to the users to properly manage
491 their own types.
492 
493 Attaching tags to entities and removing them is trivial:
494 
495 ```cpp
496 auto player = registry.create();
497 auto camera = registry.create();
498 
499 // attaches a default-initialized tag to an entity
500 registry.attach<PlayingCharacter>(player);
501 
502 // attaches a tag to an entity and initializes it
503 registry.attach<Camera>(camera, player);
504 
505 // removes tags from their owners
506 registry.remove<PlayingCharacter>();
507 registry.remove<Camera>();
508 ```
509 
510 If in doubt about whether or not a tag has already an owner, the `has` member
511 function template may be useful:
512 
513 ```cpp
514 bool b = registry.has<PlayingCharacter>();
515 ```
516 
517 References to tags can be retrieved simply by doing this:
518 
519 ```cpp
520 // either a non-const reference ...
521 entt::DefaultRegistry registry;
522 PlayingCharacter &player = registry.get<PlayingCharacter>();
523 
524 // ... or a const one
525 const auto &cregistry = registry;
526 const Camera &camera = cregistry.get<Camera>();
527 ```
528 
529 The `get` member function template gives direct access to the tag as stored in
530 the underlying data structures of the registry.
531 
532 As shown above, in almost all the cases the entity identifier isn't required,
533 since a single instance component can have only one associated entity and
534 therefore it doesn't make much sense to mention it explicitly.<br/>
535 To find out who the owner is, just do the following:
536 
537 ```cpp
538 auto player = registry.attachee<PlayingCharacter>();
539 ```
540 
541 Note that iterating tags isn't possible for obvious reasons. Tags give direct
542 access to single entities and nothing more.
543 
544 ### Runtime components
545 
546 Defining components at runtime is useful to support plugins and mods in general.
547 However, it seems impossible with a tool designed around a bunch of templates.
548 Indeed it's not that difficult.<br/>
549 Of course, some features cannot be easily exported into a runtime
550 environment. As an example, sorting a group of components defined at runtime
551 isn't for free if compared to most of the other operations. However, the basic
552 functionalities of an entity-component system such as `EnTT` fit the problem
553 perfectly and can also be used to manage runtime components if required.<br/>
554 All that is necessary to do it is to know the identifiers of the components. An
555 identifier is nothing more than a number or similar that can be used at runtime
556 to work with the type system.
557 
558 In `EnTT`, identifiers are easily accessible:
559 
560 ```cpp
561 entt::DefaultRegistry registry;
562 
563 // standard component identifier
564 auto ctype = registry.component<Position>();
565 
566 // single instance component identifier
567 auto ttype = registry.tag<PlayingCharacter>();
568 ```
569 
570 Once the identifiers are made available, almost everything becomes pretty
571 simple.
572 
573 #### A journey through a plugin
574 
575 `EnTT` comes with an example (actually a test) that shows how to integrate
576 compile-time and runtime components in a stack based JavaScript environment. It
577 uses [`duktape`](https://github.com/svaarala/duktape) under the hood, mainly
578 because I wanted to learn how it works at the time I was writing the code.
579 
580 It's not production-ready and overall performance can be highly improved.
581 However, I sacrificed optimizations in favor of a more readable piece of
582 code. I hope I succeeded.<br/>
583 Note also that this isn't neither the only nor (probably) the best way to do it.
584 In fact, the right way depends on the scripting language and the problem one is
585 facing in general.
586 
587 The basic idea is that of creating a compile-time component aimed to map all the
588 runtime components assigned to an entity.<br/>
589 Identifiers come in use to address the right function from a map when invoked
590 from the runtime environment and to filter entities when iterating.<br/>
591 With a bit of gymnastic, one can narrow views and improve the performance to
592 some extent but it was not the goal of the example.
593 
594 ### Sorting: is it possible?
595 
596 It goes without saying that sorting entities and components is possible with
597 `EnTT`.<br/>
598 In fact, there are two functions that respond to slightly different needs:
599 
600 * Components can be sorted directly:
601 
602  ```cpp
603  registry.sort<Renderable>([](const auto &lhs, const auto &rhs) {
604  return lhs.z < rhs.z;
605  });
606  ```
607 
608 * Components can be sorted according to the order imposed by another component:
609 
610  ```cpp
611  registry.sort<Movement, Physics>();
612  ```
613 
614  In this case, instances of `Movement` are arranged in memory so that cache
615  misses are minimized when the two components are iterated together.
616 
617 ## View: to persist or not to persist?
618 
619 There are mainly two kinds of views: standard (also known as View) and
620 persistent (alsa known as PersistentView).<br/>
621 Both of them have pros and cons to take in consideration. In particular:
622 
623 * Standard views:
624 
625  Pros:
626  * They work out-of-the-box and don't require any dedicated data
627  structure.
628  * Creating and destroying them isn't expensive at all because they don't
629  have any type of initialization.
630  * They are the best tool to iterate single components.
631  * They are the best tool to iterate multiple components at once when
632  tags are involved or one of the component is assigned to a
633  significantly low number of entities.
634  * They don't affect any other operations of the registry.
635 
636  Cons:
637  * Their performance tend to degenerate when the number of components
638  to iterate grows up and the most of the entities have all of them.
639 
640 * Persistent views:
641 
642  Pros:
643  * Once prepared, creating and destroying them isn't expensive at all
644  because they don't have any type of initialization.
645  * They are the best tool to iterate multiple components at once when
646  the most of the entities have all of them.
647 
648  Cons:
649  * They have dedicated data structures and thus affect the memory
650  pressure to a minimal extent.
651  * If not previously prepared, the first time they are used they go
652  through an initialization step that could take a while.
653  * They affect to a minimum the creation and destruction of entities and
654  components. In other terms: the more persistent views there will be,
655  the less performing will be creating and destroying entities and
656  components.
657 
658 To sum up and as a rule of thumb, use a standard view:
659 * To iterate entities for a single component.
660 * To iterate entities for multiple components when a significantly low
661  number of entities have one of the components.
662 * In all those cases where a persistent view would give a boost to
663  performance but the iteration isn't performed frequently.
664 
665 Use a persistent view in all the other cases.
666 
667 To easily iterate entities, all the views offer the common `begin` and `end`
668 member functions that allow users to use a view in a typical range-for
669 loop.<br/>
670 Continue reading for more details or refer to the
671 [official documentation](https://skypjack.github.io/entt/).
672 
673 ### Standard View
674 
675 A standard view behaves differently if it's constructed for a single component
676 or if it has been requested to iterate multiple components. Even the API is
677 different in the two cases.<br/>
678 All that they share is the way they are created by means of a registry:
679 
680 ```cpp
681 // single component standard view
682 auto single = registry.view<Position>();
683 
684 // multi component standard view
685 auto multi = registry.view<Position, Velocity>();
686 ```
687 
688 For all that remains, it's worth discussing them separately.<br/>
689 
690 #### Single component standard view
691 
692 Single component standard views are specialized in order to give a boost in
693 terms of performance in all the situation. This kind of views can access the
694 underlying data structures directly and avoid superflous checks.<br/>
695 They offer a bunch of functionalities to get the number of entities they are
696 going to return and a raw access to the entity list as well as to the component
697 list.<br/>
698 Refer to the [official documentation](https://skypjack.github.io/entt/) for all
699 the details.
700 
701 There is no need to store views around for they are extremely cheap to
702 construct, even though they can be copied without problems and reused
703 freely. In fact, they return newly created and correctly initialized iterators
704 whenever `begin` or `end` are invoked.<br/>
705 To iterate a single component standard view, either use it in range-for loop:
706 
707 ```cpp
708 auto view = registry.view<Renderable>();
709 
710 for(auto entity: view) {
711  Renderable &renderable = view.get(entity);
712 
713  // ...
714 }
715 ```
716 
717 Or rely on the `each` member function to iterate entities and get all their
718 components at once:
719 
720 ```cpp
721 registry.view<Renderable>().each([](auto entity, auto &renderable) {
722  // ...
723 });
724 ```
725 
726 Performance are more or less the same. The best approach depends mainly on
727 whether all the components have to be accessed or not.
728 
729 **Note**: prefer the `get` member function of a view instead of the `get` member
730 function template of a registry during iterations, if possible. However, keep in
731 mind that it works only with the components of the view itself.
732 
733 #### Multi component standard view
734 
735 Multi component standard views iterate entities that have at least all the given
736 components in their bags. During construction, these views look at the number
737 of entities available for each component and pick up a reference to the smallest
738 set of candidates in order to speed up iterations.<br/>
739 They offer fewer functionalities than their companion views for single
740 component, the most important of which can be used to reset the view and refresh
741 the reference to the set of candidate entities to iterate.<br/>
742 Refer to the [official documentation](https://skypjack.github.io/entt/) for all
743 the details.
744 
745 There is no need to store views around for they are extremely cheap to
746 construct, even though they can be copied without problems and reused
747 freely. In fact, they return newly created and correctly initialized iterators
748 whenever `begin` or `end` are invoked.<br/>
749 To iterate a multi component standard view, either use it in range-for loop:
750 
751 ```cpp
752 auto view = registry.view<Position, Velocity>();
753 
754 for(auto entity: view) {
755  // a component at a time ...
756  Position &position = view.get<Position>(entity);
757  Velocity &velocity = view.get<Velocity>(entity);
758 
759  // ... or multiple components at once
760  std::tuple<Position &, Velocity &> tup = view.get<Position, Velocity>(entity);
761 
762  // ...
763 }
764 ```
765 
766 Or rely on the `each` member function to iterate entities and get all their
767 components at once:
768 
769 ```cpp
770 registry.view<Position, Velocity>().each([](auto entity, auto &position, auto &velocity) {
771  // ...
772 });
773 ```
774 
775 Performance are more or less the same. The best approach depends mainly on
776 whether all the components have to be accessed or not.
777 
778 **Note**: prefer the `get` member function of a view instead of the `get` member
779 function template of a registry during iterations, if possible. However, keep in
780 mind that it works only with the components of the view itself.
781 
782 ### Persistent View
783 
784 A persistent view returns all the entities and only the entities that have at
785 least the given components. Moreover, it's guaranteed that the entity list is
786 thightly packed in memory for fast iterations.<br/>
787 In general, persistent views don't stay true to the order of any set of
788 components unless users explicitly sort them.
789 
790 Persistent views can be used only to iterate multiple components. Create them
791 as it follows:
792 
793 ```cpp
794 auto view = registry.persistent<Position, Velocity>();
795 ```
796 
797 There is no need to store views around for they are extremely cheap to
798 construct, even though they can be copied without problems and reused
799 freely. In fact, they return newly created and correctly initialized iterators
800 whenever `begin` or `end` are invoked.<br/>
801 That being said, persistent views perform an initialization step the very first
802 time they are constructed and this could be quite costly. To avoid it, consider
803 asking to the registry to _prepare_ them when no entities have been created yet:
804 
805 ```cpp
806 registry.prepare<Position, Velocity>();
807 ```
808 
809 If the registry is empty, preparation is extremely fast. Moreover the `prepare`
810 member function template is idempotent. Feel free to invoke it even more than
811 once: if the view has been alreadt prepared before, the function returns
812 immediately and does nothing.
813 
814 A persistent view offers a bunch of functionalities to get the number of
815 entities it's going to return, a raw access to the entity list and the
816 possibility to sort the underlying data structures according to the order of one
817 of the components for which it has been constructed.<br/>
818 Refer to the [official documentation](https://skypjack.github.io/entt/) for all
819 the details.
820 
821 To iterate a persistent view, either use it in range-for loop:
822 
823 ```cpp
824 auto view = registry.persistent<Position, Velocity>();
825 
826 for(auto entity: view) {
827  // a component at a time ...
828  Position &position = view.get<Position>(entity);
829  Velocity &velocity = view.get<Velocity>(entity);
830 
831  // ... or multiple components at once
832  std::tuple<Position &, Velocity &> tup = view.get<Position, Velocity>(entity);
833 
834  // ...
835 }
836 ```
837 
838 Or rely on the `each` member function to iterate entities and get all their
839 components at once:
840 
841 ```cpp
842 registry.persistent<Position, Velocity>().each([](auto entity, auto &position, auto &velocity) {
843  // ...
844 });
845 ```
846 
847 Performance are more or less the same. The best approach depends mainly on
848 whether all the components have to be accessed or not.
849 
850 **Note**: prefer the `get` member function of a view instead of the `get` member
851 function template of a registry during iterations, if possible. However, keep in
852 mind that it works only with the components of the view itself.
853 
854 ### Give me everything
855 
856 Views are narrow windows on the entire list of entities. They work by filtering
857 entities according to their components.<br/>
858 In some cases there may be the need to iterate all the entities regardless of
859 their components. The registry offers a specific member function to do that:
860 
861 ```cpp
862 registry.each([](auto entity) {
863  // ...
864 });
865 ```
866 
867 Each entity ever created is returned, no matter if it's in use or not.<br/>
868 Usually, filtering entities that aren't currently in use is more expensive than
869 iterating them all and filtering out those in which one isn't interested.
870 
871 As a rule of thumb, consider using a view if the goal is to iterate entities
872 that have a determinate set of components. A view is usually faster than
873 combining this function with a bunch of custom tests.<br/>
874 In all the other cases, this is the way to go.
875 
876 ## Side notes
877 
878 * Entity identifiers are numbers and nothing more. They are not classes and they
879  have no member functions at all. As already mentioned, do no try to inspect or
880  modify an entity descriptor in any way.
881 
882 * As shown in the examples above, the preferred way to get references to the
883  components while iterating a view is by using the view itself. It's a faster
884  alternative to the `get` member function template that is part of the API of
885  the Registry. This is because the registry must ensure that a pool for the
886  given component exists before to use it; on the other side, views force the
887  construction of the pools for all their components and access them directly,
888  thus avoiding all the checks.
889 
890 * Most of the _ECS_ available out there have an annoying limitation (at least
891  from my point of view): entities and components cannot be created and/or
892  deleted during iterations.<br/>
893  `EnTT` partially solves the problem with a few limitations:
894 
895  * Creating entities and components is allowed during iterations.
896  * Deleting an entity or removing its components is allowed during
897  iterations if it's the one currently returned by a view. For all the
898  other entities, destroying them or removing their components isn't
899  allowed and it can result in undefined behavior.
900 
901  Iterators are invalidated and the behaviour is undefined if an entity is
902  modified or destroyed and it's not the one currently returned by the
903  view.<br/>
904  To work around it, possible approaches are:
905 
906  * Store aside the entities and the components to be removed and perform the
907  operations at the end of the iteration.
908  * Mark entities and components with a proper tag component that indicates
909  they must be purged, then perform a second iteration to clean them up one
910  by one.
911 
912 * Views and thus their iterators aren't thread safe. Do no try to iterate a set
913  of components and modify the same set concurrently.<br/>
914  That being said, as long as a thread iterates the entities that have the
915  component `X` or assign and removes that component from a set of entities,
916  another thread can safely do the same with components `Y` and `Z` and
917  everything will work like a charm.<br/>
918  As an example, users can freely execute the rendering system and iterate the
919  renderable entities while updating a physic component concurrently on a
920  separate thread if needed.
921 
922 # Contributors
923 
924 If you want to contribute, please send patches as pull requests against the
925 branch `master`.<br/>
926 Check the
927 [contributors list](https://github.com/skypjack/entt/blob/master/AUTHORS) to see
928 who has partecipated so far.
929 
930 # License
931 
932 Code and documentation Copyright (c) 2018 Michele Caini.<br/>
933 Code released under
934 [the MIT license](https://github.com/skypjack/entt/blob/master/LICENSE).
935 Docs released under
936 [Creative Commons](https://github.com/skypjack/entt/blob/master/docs/LICENSE).
937 
938 # Donation
939 
940 Developing and maintaining `EnTT` takes some time and lots of coffee. I'd like
941 to add more and more functionalities in future and turn it in a full-featured
942 framework.<br/>
943 If you want to support this project, you can offer me an espresso. I'm from
944 Italy, we're used to turning the best coffee ever in code. If you find that
945 it's not enough, feel free to support me the way you prefer.<br/>
946 Take a look at the donation button at the top of the page for more details or
947 just click [here](https://www.paypal.com/cgi-bin/webscr?cmd=_donations&business=W2HF9FESD5LJY&lc=IT&item_name=Michele%20Caini&currency_code=EUR&bn=PP%2dDonationsBF%3abtn_donateCC_LG%2egif%3aNonHosted).
Generated by   diff --git a/actor_8hpp_source.html b/actor_8hpp_source.html index e92279e12..e26897325 100644 --- a/actor_8hpp_source.html +++ b/actor_8hpp_source.html @@ -22,7 +22,7 @@
entt -  2.4.1 +  2.4.2
@@ -67,20 +67,21 @@ $(function() {
actor.hpp
-
1 #ifndef ENTT_ENTITY_ACTOR_HPP
2 #define ENTT_ENTITY_ACTOR_HPP
3 
4 
5 #include <utility>
6 #include "registry.hpp"
7 
8 
9 namespace entt {
10 
11 
21 template<typename Entity, typename Delta>
22 struct Actor {
24  using registry_type = Registry<Entity>;
26  using delta_type = Delta;
27 
32  Actor(Registry<Entity> &reg)
33  : reg{reg}, entity{reg.create()}
34  {}
35 
37  virtual ~Actor() {
38  reg.destroy(entity);
39  }
40 
42  Actor(const Actor &) = default;
44  Actor(Actor &&) = default;
45 
47  Actor & operator=(const Actor &) = default;
49  Actor & operator=(Actor &&) = default;
50 
65  template<typename Component, typename... Args>
66  Component & set(Args&&... args) {
67  return reg.template accomodate<Component>(entity, std::forward<Args>(args)...);
68  }
69 
74  template<typename Component>
75  void unset() {
76  reg.template remove<Component>(entity);
77  }
78 
84  template<typename Component>
85  bool has() const noexcept {
86  return reg.template has<Component>(entity);
87  }
88 
94  template<typename Component>
95  const Component & get() const noexcept {
96  return reg.template get<Component>(entity);
97  }
98 
104  template<typename Component>
105  Component & get() noexcept {
106  return const_cast<Component &>(const_cast<const Actor *>(this)->get<Component>());
107  }
108 
113  const registry_type & registry() const noexcept {
114  return reg;
115  }
116 
121  registry_type & registry() noexcept {
122  return const_cast<registry_type &>(const_cast<const Actor *>(this)->registry());
123  }
124 
129  virtual void update(delta_type delta) = 0;
130 
131 private:
132  registry_type &reg;
133  Entity entity;
134 };
135 
136 
145 template<typename Delta>
146 using DefaultActor = Actor<std::uint32_t, Delta>;
147 
148 
149 }
150 
151 
152 #endif // ENTT_ENTITY_ACTOR_HPP
entt::Registry
Fast and reliable entity-component system.
Definition: registry.hpp:32
+
1 #ifndef ENTT_ENTITY_ACTOR_HPP
2 #define ENTT_ENTITY_ACTOR_HPP
3 
4 
5 #include <utility>
6 #include "registry.hpp"
7 
8 
9 namespace entt {
10 
11 
21 template<typename Entity, typename Delta>
22 struct Actor {
24  using registry_type = Registry<Entity>;
26  using entity_type = Entity;
28  using delta_type = Delta;
29 
34  Actor(Registry<Entity> &reg)
35  : reg{reg}, entity{reg.create()}
36  {}
37 
39  virtual ~Actor() {
40  reg.destroy(entity);
41  }
42 
44  Actor(const Actor &) = default;
46  Actor(Actor &&) = default;
47 
49  Actor & operator=(const Actor &) = default;
51  Actor & operator=(Actor &&) = default;
52 
67  template<typename Component, typename... Args>
68  Component & set(Args&&... args) {
69  return reg.template accomodate<Component>(entity, std::forward<Args>(args)...);
70  }
71 
76  template<typename Component>
77  void unset() {
78  reg.template remove<Component>(entity);
79  }
80 
86  template<typename Component>
87  bool has() const noexcept {
88  return reg.template has<Component>(entity);
89  }
90 
96  template<typename Component>
97  const Component & get() const noexcept {
98  return reg.template get<Component>(entity);
99  }
100 
106  template<typename Component>
107  Component & get() noexcept {
108  return const_cast<Component &>(const_cast<const Actor *>(this)->get<Component>());
109  }
110 
115  const registry_type & registry() const noexcept {
116  return reg;
117  }
118 
123  registry_type & registry() noexcept {
124  return const_cast<registry_type &>(const_cast<const Actor *>(this)->registry());
125  }
126 
131  virtual void update(delta_type delta) = 0;
132 
133 private:
134  registry_type &reg;
135  Entity entity;
136 };
137 
138 
147 template<typename Delta>
148 using DefaultActor = Actor<std::uint32_t, Delta>;
149 
150 
151 }
152 
153 
154 #endif // ENTT_ENTITY_ACTOR_HPP
entt::Registry
Fast and reliable entity-component system.
Definition: registry.hpp:34
entt
EnTT default namespace.
Definition: family.hpp:9
entt::Actor::operator=
Actor & operator=(const Actor &)=default
Default copy assignment operator.
entt::Actor::update
virtual void update(delta_type delta)=0
Updates an actor, whatever it means to update it.
-
entt::Actor::Actor
Actor(Registry< Entity > &reg)
Constructs an actor by using the given registry.
Definition: actor.hpp:32
-
entt::Actor::delta_type
Delta delta_type
Type used to provide elapsed time.
Definition: actor.hpp:26
-
entt::Registry::create
entity_type create(Component &&... components) noexcept
Returns a new entity initialized with the given components.
Definition: registry.hpp:354
+
entt::Actor::Actor
Actor(Registry< Entity > &reg)
Constructs an actor by using the given registry.
Definition: actor.hpp:34
+
entt::Actor::delta_type
Delta delta_type
Type used to provide elapsed time.
Definition: actor.hpp:28
+
entt::Registry::create
entity_type create(Component &&... components) noexcept
Returns a new entity initialized with the given components.
Definition: registry.hpp:356
entt::Actor
Dedicated to those who aren&#39;t confident with entity-component systems.
Definition: actor.hpp:22
-
entt::Actor::has
bool has() const noexcept
Checks if an actor has the given component.
Definition: actor.hpp:85
-
entt::Actor::registry
const registry_type & registry() const noexcept
Returns a reference to the underlying registry.
Definition: actor.hpp:113
-
entt::Registry::destroy
void destroy(entity_type entity)
Destroys an entity and lets the registry recycle the identifier.
Definition: registry.hpp:437
-
entt::Actor::~Actor
virtual ~Actor()
Default destructor.
Definition: actor.hpp:37
-
entt::Actor::unset
void unset()
Removes the given component from an actor.
Definition: actor.hpp:75
-
entt::Actor::registry
registry_type & registry() noexcept
Returns a reference to the underlying registry.
Definition: actor.hpp:121
+
entt::Actor::has
bool has() const noexcept
Checks if an actor has the given component.
Definition: actor.hpp:87
+
entt::Actor::registry
const registry_type & registry() const noexcept
Returns a reference to the underlying registry.
Definition: actor.hpp:115
+
entt::Registry::destroy
void destroy(entity_type entity)
Destroys an entity and lets the registry recycle the identifier.
Definition: registry.hpp:439
+
entt::Actor::entity_type
Entity entity_type
Underlying entity identifier.
Definition: actor.hpp:26
+
entt::Actor::~Actor
virtual ~Actor()
Default destructor.
Definition: actor.hpp:39
+
entt::Actor::unset
void unset()
Removes the given component from an actor.
Definition: actor.hpp:77
+
entt::Actor::registry
registry_type & registry() noexcept
Returns a reference to the underlying registry.
Definition: actor.hpp:123
diff --git a/annotated.html b/annotated.html index 09267029c..00b3cd2f8 100644 --- a/annotated.html +++ b/annotated.html @@ -22,7 +22,7 @@
entt -  2.4.1 +  2.4.2
diff --git a/bus_8hpp_source.html b/bus_8hpp_source.html index fdff02c03..1e7e2ff78 100644 --- a/bus_8hpp_source.html +++ b/bus_8hpp_source.html @@ -22,7 +22,7 @@
entt -  2.4.1 +  2.4.2
diff --git a/cache_8hpp_source.html b/cache_8hpp_source.html index c0e7ab02b..0ded6006f 100644 --- a/cache_8hpp_source.html +++ b/cache_8hpp_source.html @@ -22,7 +22,7 @@
entt -  2.4.1 +  2.4.2
@@ -76,7 +76,7 @@ $(function() {
entt::ResourceCache::discard
void discard(resource_type id) noexcept
Discards the resource that corresponds to a given identifier.
Definition: cache.hpp:184
entt::ResourceCache::ResourceCache
ResourceCache()=default
Default constructor.
entt::ResourceCache::handle
ResourceHandle< Resource > handle(resource_type id) const
Creates a handle for a given resource identifier.
Definition: cache.hpp:162
-
entt::HashedString
Zero overhead resource identifier.
Definition: hashed_string.hpp:20
+
entt::HashedString
Zero overhead resource identifier.
Definition: hashed_string.hpp:21
entt::ResourceCache::reload
void reload(resource_type id, Args &&... args)
Reloads a resource or loads it for the first time if not present.
Definition: cache.hpp:128
entt::ResourceLoader
Base class for resource loaders.
Definition: loader.hpp:48
entt::ResourceCache::size
size_type size() const noexcept
Number of resources managed by a cache.
Definition: cache.hpp:54
diff --git a/classentt_1_1Bus.html b/classentt_1_1Bus.html index ad661c52b..882cb4542 100644 --- a/classentt_1_1Bus.html +++ b/classentt_1_1Bus.html @@ -22,7 +22,7 @@
entt -  2.4.1 +  2.4.2
diff --git a/classentt_1_1Bus_3_01Sig_00_01Event_00_01Other_8_8_8_01_4-members.html b/classentt_1_1Bus_3_01Sig_00_01Event_00_01Other_8_8_8_01_4-members.html index 0b9c652c2..c98ed48ba 100644 --- a/classentt_1_1Bus_3_01Sig_00_01Event_00_01Other_8_8_8_01_4-members.html +++ b/classentt_1_1Bus_3_01Sig_00_01Event_00_01Other_8_8_8_01_4-members.html @@ -22,7 +22,7 @@
entt -  2.4.1 +  2.4.2
diff --git a/classentt_1_1Bus_3_01Sig_00_01Event_00_01Other_8_8_8_01_4.html b/classentt_1_1Bus_3_01Sig_00_01Event_00_01Other_8_8_8_01_4.html index 814ecfdaa..51dcb81ff 100644 --- a/classentt_1_1Bus_3_01Sig_00_01Event_00_01Other_8_8_8_01_4.html +++ b/classentt_1_1Bus_3_01Sig_00_01Event_00_01Other_8_8_8_01_4.html @@ -22,7 +22,7 @@
entt -  2.4.1 +  2.4.2
diff --git a/classentt_1_1Bus_3_01Sig_00_01Event_01_4-members.html b/classentt_1_1Bus_3_01Sig_00_01Event_01_4-members.html index 70f185a23..f62505d31 100644 --- a/classentt_1_1Bus_3_01Sig_00_01Event_01_4-members.html +++ b/classentt_1_1Bus_3_01Sig_00_01Event_01_4-members.html @@ -22,7 +22,7 @@
entt -  2.4.1 +  2.4.2
diff --git a/classentt_1_1Bus_3_01Sig_00_01Event_01_4.html b/classentt_1_1Bus_3_01Sig_00_01Event_01_4.html index af04b0fd5..9eb775140 100644 --- a/classentt_1_1Bus_3_01Sig_00_01Event_01_4.html +++ b/classentt_1_1Bus_3_01Sig_00_01Event_01_4.html @@ -22,7 +22,7 @@
entt -  2.4.1 +  2.4.2
diff --git a/classentt_1_1Delegate.html b/classentt_1_1Delegate.html index 08314d78a..163f4dd3f 100644 --- a/classentt_1_1Delegate.html +++ b/classentt_1_1Delegate.html @@ -22,7 +22,7 @@
entt -  2.4.1 +  2.4.2
diff --git a/classentt_1_1Delegate_3_01Ret_07Args_8_8_8_08_4-members.html b/classentt_1_1Delegate_3_01Ret_07Args_8_8_8_08_4-members.html index 101be0620..15b2f0b52 100644 --- a/classentt_1_1Delegate_3_01Ret_07Args_8_8_8_08_4-members.html +++ b/classentt_1_1Delegate_3_01Ret_07Args_8_8_8_08_4-members.html @@ -22,7 +22,7 @@
entt -  2.4.1 +  2.4.2
diff --git a/classentt_1_1Delegate_3_01Ret_07Args_8_8_8_08_4.html b/classentt_1_1Delegate_3_01Ret_07Args_8_8_8_08_4.html index 3edae5dbf..9cc13ca21 100644 --- a/classentt_1_1Delegate_3_01Ret_07Args_8_8_8_08_4.html +++ b/classentt_1_1Delegate_3_01Ret_07Args_8_8_8_08_4.html @@ -22,7 +22,7 @@
entt -  2.4.1 +  2.4.2
diff --git a/classentt_1_1Dispatcher-members.html b/classentt_1_1Dispatcher-members.html index 31efbc57d..c1bad102b 100644 --- a/classentt_1_1Dispatcher-members.html +++ b/classentt_1_1Dispatcher-members.html @@ -22,7 +22,7 @@
entt -  2.4.1 +  2.4.2
diff --git a/classentt_1_1Dispatcher.html b/classentt_1_1Dispatcher.html index 38cdd7f19..110d43f3b 100644 --- a/classentt_1_1Dispatcher.html +++ b/classentt_1_1Dispatcher.html @@ -22,7 +22,7 @@
entt -  2.4.1 +  2.4.2
diff --git a/classentt_1_1Emitter-members.html b/classentt_1_1Emitter-members.html index b9615258d..7e0f5ba5a 100644 --- a/classentt_1_1Emitter-members.html +++ b/classentt_1_1Emitter-members.html @@ -22,7 +22,7 @@
entt -  2.4.1 +  2.4.2
diff --git a/classentt_1_1Emitter.html b/classentt_1_1Emitter.html index b11ecbd9d..8c037a4b6 100644 --- a/classentt_1_1Emitter.html +++ b/classentt_1_1Emitter.html @@ -22,7 +22,7 @@
entt -  2.4.1 +  2.4.2
diff --git a/classentt_1_1Family-members.html b/classentt_1_1Family-members.html index ee809a80b..ce548fe80 100644 --- a/classentt_1_1Family-members.html +++ b/classentt_1_1Family-members.html @@ -22,7 +22,7 @@
entt -  2.4.1 +  2.4.2
diff --git a/classentt_1_1Family.html b/classentt_1_1Family.html index 1c4530528..a1d42de14 100644 --- a/classentt_1_1Family.html +++ b/classentt_1_1Family.html @@ -22,7 +22,7 @@
entt -  2.4.1 +  2.4.2
diff --git a/classentt_1_1HashedString-members.html b/classentt_1_1HashedString-members.html index 448ddbbce..c5a7dda40 100644 --- a/classentt_1_1HashedString-members.html +++ b/classentt_1_1HashedString-members.html @@ -22,7 +22,7 @@
entt -  2.4.1 +  2.4.2
diff --git a/classentt_1_1HashedString.html b/classentt_1_1HashedString.html index d1e367ae9..e724727aa 100644 --- a/classentt_1_1HashedString.html +++ b/classentt_1_1HashedString.html @@ -22,7 +22,7 @@
entt -  2.4.1 +  2.4.2
@@ -109,7 +109,7 @@ Public Member Functions

A hashed string is a compile-time tool that allows users to use human-readable identifers in the codebase while using their numeric counterparts at runtime.
Because of that, a hashed string can also be used in constant expressions if required.

-

Definition at line 20 of file hashed_string.hpp.

+

Definition at line 21 of file hashed_string.hpp.

Constructor & Destructor Documentation

◆ HashedString() [1/2]

@@ -152,7 +152,7 @@ template<std::size_t N> -

Definition at line 54 of file hashed_string.hpp.

+

Definition at line 55 of file hashed_string.hpp.

@@ -188,7 +188,7 @@ template<std::size_t N> -

Definition at line 64 of file hashed_string.hpp.

+

Definition at line 65 of file hashed_string.hpp.

@@ -219,7 +219,7 @@ template<std::size_t N>

Returns the human-readable representation of a hashed string.

Returns
The string used to initialize the instance.
-

Definition at line 72 of file hashed_string.hpp.

+

Definition at line 73 of file hashed_string.hpp.

@@ -249,7 +249,7 @@ template<std::size_t N>

Returns the numeric representation of a hashed string.

Returns
The numeric representation of the instance.
-

Definition at line 78 of file hashed_string.hpp.

+

Definition at line 79 of file hashed_string.hpp.

@@ -286,7 +286,7 @@ template<std::size_t N>
Returns
True if the two hashed strings are identical, false otherwise.
-

Definition at line 85 of file hashed_string.hpp.

+

Definition at line 86 of file hashed_string.hpp.

diff --git a/classentt_1_1PersistentView-members.html b/classentt_1_1PersistentView-members.html index 6ce00fab6..a9632f2bf 100644 --- a/classentt_1_1PersistentView-members.html +++ b/classentt_1_1PersistentView-members.html @@ -22,7 +22,7 @@
entt -  2.4.1 +  2.4.2
@@ -78,6 +78,8 @@ $(function() { entity_type typedefentt::PersistentView< Entity, Component > get(entity_type entity) const noexceptentt::PersistentView< Entity, Component >inline get(entity_type entity) noexceptentt::PersistentView< Entity, Component >inline + get(entity_type entity) const noexceptentt::PersistentView< Entity, Component >inline + get(entity_type entity) noexceptentt::PersistentView< Entity, Component >inline iterator_type typedefentt::PersistentView< Entity, Component > PersistentView(view_type &view, pool_type< Component > &... pools) noexceptentt::PersistentView< Entity, Component >inline size() const noexceptentt::PersistentView< Entity, Component >inline diff --git a/classentt_1_1PersistentView.html b/classentt_1_1PersistentView.html index f8a930ac6..114994ef0 100644 --- a/classentt_1_1PersistentView.html +++ b/classentt_1_1PersistentView.html @@ -22,7 +22,7 @@
entt -  2.4.1 +  2.4.2
@@ -115,6 +115,14 @@ Public Member Functions Comp & get (entity_type entity) noexcept  Returns the component assigned to the given entity. More...
  +template<typename... Comp> +std::enable_if_t<(sizeof...(Comp) > 1), std::tuple< const Comp &... > > get (entity_type entity) const noexcept + Returns the components assigned to the given entity. More...
+  +template<typename... Comp> +std::enable_if_t<(sizeof...(Comp) > 1), std::tuple< Comp &... > > get (entity_type entity) noexcept + Returns the components assigned to the given entity. More...
+  template<typename Func > void each (Func func) const  Iterate the entities and applies them the given function object. More...
@@ -156,7 +164,7 @@ class entt::PersistentView< Entity, Component > -

Definition at line 54 of file view.hpp.

+

Definition at line 55 of file view.hpp.

Member Typedef Documentation

◆ iterator_type

@@ -173,7 +181,7 @@ template<typename Entity , typename... Component>

Input iterator type.

-

Definition at line 64 of file view.hpp.

+

Definition at line 65 of file view.hpp.

@@ -228,7 +236,7 @@ template<typename Entity , typename... Component> -

Definition at line 82 of file view.hpp.

+

Definition at line 83 of file view.hpp.

@@ -263,7 +271,7 @@ template<typename Entity , typename... Component>
Note
Input iterators stay true to the order imposed to the underlying data structures.
Returns
An iterator to the first entity that has the given components.
-

Definition at line 124 of file view.hpp.

+

Definition at line 125 of file view.hpp.

@@ -297,7 +305,7 @@ template<typename Entity , typename... Component>
Note
There are no guarantees on the order of the entities. Use begin and end if you want to iterate the view in the expected order.
Returns
A pointer to the array of entities.
-

Definition at line 106 of file view.hpp.

+

Definition at line 107 of file view.hpp.

@@ -345,7 +353,7 @@ template<typename Func > -

Definition at line 207 of file view.hpp.

+

Definition at line 254 of file view.hpp.

@@ -393,7 +401,7 @@ template<typename Func > -

Definition at line 229 of file view.hpp.

+

Definition at line 276 of file view.hpp.

@@ -427,12 +435,12 @@ template<typename Entity , typename... Component>
Note
Input iterators stay true to the order imposed to the underlying data structures.
Returns
An iterator to the entity following the last entity that has the given components.
-

Definition at line 143 of file view.hpp.

+

Definition at line 144 of file view.hpp.

-

◆ get() [1/2]

+

◆ get() [1/4]

@@ -477,12 +485,12 @@ template<typename Comp >
Returns
The component assigned to the entity.
-

Definition at line 165 of file view.hpp.

+

Definition at line 166 of file view.hpp.

-

◆ get() [2/2]

+

◆ get() [2/4]

@@ -527,7 +535,107 @@ template<typename Comp >
Returns
The component assigned to the entity.
-

Definition at line 187 of file view.hpp.

+

Definition at line 188 of file view.hpp.

+ +
+ + +

◆ get() [3/4]

+ +
+
+
+template<typename Entity , typename... Component>
+
+template<typename... Comp>
+ + + + + +
+ + + + + + + + +
std::enable_if_t<(sizeof...(Comp) > 1), std::tuple<const Comp &...> > entt::PersistentView< Entity, Component >::get (entity_type entity) const
+ 		+inlinenoexcept
+
+ +

Returns the components assigned to the given entity.

+

Prefer this function instead of Registry::get during iterations. It has far better performance than its companion function.

+
Warning
Attempting to use invalid component types results in a compilation error. Attempting to use an entity that doesn't belong to the view results in undefined behavior.
+ An assertion will abort the execution at runtime in debug mode if the view doesn't contain the given entity.
+
Template Parameters
+ + +
CompTypes of the components to get.
+
+
+
Parameters
+ + +
entityA valid entity identifier.
+
+
+
Returns
The components assigned to the entity.
+ +

Definition at line 211 of file view.hpp.

+ +
+
+ +

◆ get() [4/4]

+ +
+
+
+template<typename Entity , typename... Component>
+
+template<typename... Comp>
+ + + + + +
+ + + + + + + + +
std::enable_if_t<(sizeof...(Comp) > 1), std::tuple<Comp &...> > entt::PersistentView< Entity, Component >::get (entity_type entity)
+ 		+inlinenoexcept
+
+ +

Returns the components assigned to the given entity.

+

Prefer this function instead of Registry::get during iterations. It has far better performance than its companion function.

+
Warning
Attempting to use invalid component types results in a compilation error. Attempting to use an entity that doesn't belong to the view results in undefined behavior.
+ An assertion will abort the execution at runtime in debug mode if the view doesn't contain the given entity.
+
Template Parameters
+ + +
CompTypes of the components to get.
+
+
+
Parameters
+ + +
entityA valid entity identifier.
+
+
+
Returns
The components assigned to the entity.
+ +

Definition at line 234 of file view.hpp.

@@ -559,7 +667,7 @@ template<typename Entity , typename... Component>

Returns the number of entities that have the given components.

Returns
Number of entities that have the given components.
-

Definition at line 90 of file view.hpp.

+

Definition at line 91 of file view.hpp.

@@ -600,7 +708,7 @@ template<typename Comp > -

Definition at line 252 of file view.hpp.

+

Definition at line 299 of file view.hpp.

diff --git a/classentt_1_1Process-members.html b/classentt_1_1Process-members.html index 1704957f9..77e64bc85 100644 --- a/classentt_1_1Process-members.html +++ b/classentt_1_1Process-members.html @@ -22,7 +22,7 @@
entt -  2.4.1 +  2.4.2
diff --git a/classentt_1_1Process.html b/classentt_1_1Process.html index f1d7e8959..91c3020c7 100644 --- a/classentt_1_1Process.html +++ b/classentt_1_1Process.html @@ -22,7 +22,7 @@
entt -  2.4.1 +  2.4.2
diff --git a/classentt_1_1Registry-members.html b/classentt_1_1Registry-members.html index 40f32f12a..b3aa0bad1 100644 --- a/classentt_1_1Registry-members.html +++ b/classentt_1_1Registry-members.html @@ -22,7 +22,7 @@
entt -  2.4.1 +  2.4.2
@@ -92,6 +92,8 @@ $(function() { get() noexceptentt::Registry< Entity >inline get(entity_type entity) const noexceptentt::Registry< Entity >inline get(entity_type entity) noexceptentt::Registry< Entity >inline + get(entity_type entity) const noexceptentt::Registry< Entity >inline + get(entity_type entity) noexceptentt::Registry< Entity >inline has() const noexceptentt::Registry< Entity >inline has(entity_type entity) const noexceptentt::Registry< Entity >inline operator=(const Registry &)=deleteentt::Registry< Entity > diff --git a/classentt_1_1Registry.html b/classentt_1_1Registry.html index 574f3f127..c9537760c 100644 --- a/classentt_1_1Registry.html +++ b/classentt_1_1Registry.html @@ -22,7 +22,7 @@
entt -  2.4.1 +  2.4.2
@@ -220,6 +220,14 @@ Public Member Functions Component & get (entity_type entity) noexcept  Returns a reference to the given component for an entity. More...
  +template<typename... Component> +std::enable_if_t<(sizeof...(Component) > 1), std::tuple< const Component &... > > get (entity_type entity) const noexcept + Returns a reference to the given components for an entity. More...
+  +template<typename... Component> +std::enable_if_t<(sizeof...(Component) > 1), std::tuple< Component &... > > get (entity_type entity) noexcept + Returns a reference to the given components for an entity. More...
+  template<typename Component , typename... Args> Component & replace (entity_type entity, Args &&... args)  Replaces the given component for an entity. More...
@@ -286,7 +294,7 @@ class entt::Registry< Entity > -

Definition at line 32 of file registry.hpp.

+

Definition at line 34 of file registry.hpp.

Member Function Documentation

◆ accomodate()

@@ -347,7 +355,7 @@ template<typename Component , typename... Args>
Returns
A reference to the newly created component.
-

Definition at line 728 of file registry.hpp.

+

Definition at line 770 of file registry.hpp.

@@ -409,7 +417,7 @@ template<typename Component , typename... Args>
Returns
A reference to the newly created component.
-

Definition at line 589 of file registry.hpp.

+

Definition at line 591 of file registry.hpp.

@@ -472,7 +480,7 @@ template<typename Tag , typename... Args>
Returns
A reference to the newly created tag.
-

Definition at line 475 of file registry.hpp.

+

Definition at line 477 of file registry.hpp.

@@ -514,7 +522,7 @@ template<typename Tag >
Returns
A valid entity identifier.
-

Definition at line 563 of file registry.hpp.

+

Definition at line 565 of file registry.hpp.

@@ -546,7 +554,7 @@ template<typename Entity>

Returns the number of entities ever created.

Returns
Number of entities ever created.
-

Definition at line 265 of file registry.hpp.

+

Definition at line 267 of file registry.hpp.

@@ -588,7 +596,7 @@ template<typename Component >
Returns
Runtime numeric identifier of the given type of component.
-

Definition at line 212 of file registry.hpp.

+

Definition at line 214 of file registry.hpp.

@@ -628,7 +636,7 @@ template<typename... Component>
Returns
True if the view has already been prepared, false otherwise.
-

Definition at line 999 of file registry.hpp.

+

Definition at line 1041 of file registry.hpp.

@@ -682,7 +690,7 @@ template<typename... Component>
Returns
A valid entity identifier.
-

Definition at line 354 of file registry.hpp.

+

Definition at line 356 of file registry.hpp.

@@ -729,7 +737,7 @@ template<typename... Component>
Returns
A valid entity identifier.
-

Definition at line 381 of file registry.hpp.

+

Definition at line 383 of file registry.hpp.

@@ -768,7 +776,7 @@ template<typename Entity>

The returned entity has no components assigned.

Returns
A valid entity identifier.
-

Definition at line 406 of file registry.hpp.

+

Definition at line 408 of file registry.hpp.

@@ -810,7 +818,7 @@ template<typename Entity>
Returns
Actual version for the given entity identifier.
-

Definition at line 326 of file registry.hpp.

+

Definition at line 328 of file registry.hpp.

@@ -851,7 +859,7 @@ template<typename Entity> -

Definition at line 437 of file registry.hpp.

+

Definition at line 439 of file registry.hpp.

@@ -893,7 +901,7 @@ template<typename... Component> -

Definition at line 981 of file registry.hpp.

+

Definition at line 1023 of file registry.hpp.

@@ -942,7 +950,7 @@ template<typename Func > -

Definition at line 901 of file registry.hpp.

+

Definition at line 943 of file registry.hpp.

@@ -982,7 +990,7 @@ template<typename Component >
Returns
True if the pool for the given component is empty, false otherwise.
-

Definition at line 276 of file registry.hpp.

+

Definition at line 278 of file registry.hpp.

@@ -1014,12 +1022,12 @@ template<typename Entity>

Checks if there exists at least an entity still in use.

Returns
True if at least an entity is still in use, false otherwise.
-

Definition at line 284 of file registry.hpp.

+

Definition at line 286 of file registry.hpp.

-

◆ get() [1/4]

+

◆ get() [1/6]

@@ -1056,12 +1064,12 @@ template<typename Tag >
Returns
A reference to the tag.
-

Definition at line 528 of file registry.hpp.

+

Definition at line 530 of file registry.hpp.

-

◆ get() [2/4]

+

◆ get() [2/6]

@@ -1098,12 +1106,12 @@ template<typename Tag >
Returns
A reference to the tag.
-

Definition at line 546 of file registry.hpp.

+

Definition at line 548 of file registry.hpp.

-

◆ get() [3/4]

+

◆ get() [3/6]

@@ -1145,14 +1153,14 @@ template<typename Component >
-
Returns
A reference to the instance of the component owned by the entity.
+
Returns
A reference to the component owned by the entity.
-

Definition at line 650 of file registry.hpp.

+

Definition at line 652 of file registry.hpp.

-

◆ get() [4/4]

+

◆ get() [4/6]

@@ -1194,9 +1202,107 @@ template<typename Component >
-
Returns
A reference to the instance of the component owned by the entity.
+
Returns
A reference to the component owned by the entity.
-

Definition at line 670 of file registry.hpp.

+

Definition at line 672 of file registry.hpp.

+ +
+ + +

◆ get() [5/6]

+ +
+
+
+template<typename Entity>
+
+template<typename... Component>
+ + + + + +
+ + + + + + + + +
std::enable_if_t<(sizeof...(Component) > 1), std::tuple<const Component &...> > entt::Registry< Entity >::get (entity_type entity) const
+ 		+inlinenoexcept
+
+ +

Returns a reference to the given components for an entity.

+
Warning
Attempting to use an invalid entity or to get components from an entity that doesn't own them results in undefined behavior.
+ An assertion will abort the execution at runtime in debug mode in case of invalid entity or if the entity doesn't own instances of the given components.
+
Template Parameters
+ + +
ComponentType of components to get.
+
+
+
Parameters
+ + +
entityA valid entity identifier.
+
+
+
Returns
References to the components owned by the entity.
+ +

Definition at line 692 of file registry.hpp.

+ +
+
+ +

◆ get() [6/6]

+ +
+
+
+template<typename Entity>
+
+template<typename... Component>
+ + + + + +
+ + + + + + + + +
std::enable_if_t<(sizeof...(Component) > 1), std::tuple<Component &...> > entt::Registry< Entity >::get (entity_type entity)
+ 		+inlinenoexcept
+
+ +

Returns a reference to the given components for an entity.

+
Warning
Attempting to use an invalid entity or to get components from an entity that doesn't own them results in undefined behavior.
+ An assertion will abort the execution at runtime in debug mode in case of invalid entity or if the entity doesn't own instances of the given components.
+
Template Parameters
+ + +
ComponentType of components to get.
+
+
+
Parameters
+ + +
entityA valid entity identifier.
+
+
+
Returns
References to the components owned by the entity.
+ +

Definition at line 712 of file registry.hpp.

@@ -1236,7 +1342,7 @@ template<typename Tag >
Returns
True if the tag already has an owner, false otherwise.
-

Definition at line 506 of file registry.hpp.

+

Definition at line 508 of file registry.hpp.

@@ -1285,7 +1391,7 @@ template<typename... Component>
Returns
True if the entity has all the components, false otherwise.
-

Definition at line 626 of file registry.hpp.

+

Definition at line 628 of file registry.hpp.

@@ -1403,7 +1509,7 @@ template<typename... Component>
Returns
A newly created persistent view.
-

Definition at line 1043 of file registry.hpp.

+

Definition at line 1085 of file registry.hpp.

@@ -1445,7 +1551,7 @@ template<typename... Component> -

Definition at line 961 of file registry.hpp.

+

Definition at line 1003 of file registry.hpp.

@@ -1484,7 +1590,7 @@ template<typename Tag > -

Definition at line 494 of file registry.hpp.

+

Definition at line 496 of file registry.hpp.

@@ -1532,7 +1638,7 @@ template<typename Component > -

Definition at line 608 of file registry.hpp.

+

Definition at line 610 of file registry.hpp.

@@ -1594,7 +1700,7 @@ template<typename Component , typename... Args>
Returns
A reference to the newly created component.
-

Definition at line 695 of file registry.hpp.

+

Definition at line 737 of file registry.hpp.

@@ -1641,7 +1747,7 @@ template<typename Component > -

Definition at line 244 of file registry.hpp.

+

Definition at line 246 of file registry.hpp.

@@ -1680,7 +1786,7 @@ template<typename Entity> -

Definition at line 256 of file registry.hpp.

+

Definition at line 258 of file registry.hpp.

@@ -1729,7 +1835,7 @@ template<typename Component > -

Definition at line 815 of file registry.hpp.

+

Definition at line 857 of file registry.hpp.

@@ -1769,7 +1875,7 @@ template<typename Component > -

Definition at line 836 of file registry.hpp.

+

Definition at line 878 of file registry.hpp.

@@ -1801,7 +1907,7 @@ template<typename Entity>

Resets a whole registry.

Destroys all the entities. After a call to reset, all the entities previously created are recycled with a new version number. In case entity identifers are stored around, the current member function can be used to know if they are still valid.

-

Definition at line 856 of file registry.hpp.

+

Definition at line 898 of file registry.hpp.

@@ -1841,7 +1947,7 @@ template<typename Component >
Returns
Number of existing components of the given type.
-

Definition at line 222 of file registry.hpp.

+

Definition at line 224 of file registry.hpp.

@@ -1873,7 +1979,7 @@ template<typename Entity>

Returns the number of entities still in use.

Returns
Number of entities still in use.
-

Definition at line 230 of file registry.hpp.

+

Definition at line 232 of file registry.hpp.

@@ -1923,7 +2029,7 @@ template<typename Component , typename Compare > -

Definition at line 761 of file registry.hpp.

+

Definition at line 803 of file registry.hpp.

@@ -1972,7 +2078,7 @@ template<typename To , typename From > -

Definition at line 796 of file registry.hpp.

+

Definition at line 838 of file registry.hpp.

@@ -2014,7 +2120,7 @@ template<typename Tag >
Returns
Runtime numeric identifier of the given type of tag.
-

Definition at line 195 of file registry.hpp.

+

Definition at line 197 of file registry.hpp.

@@ -2053,7 +2159,7 @@ template<typename Entity>
Returns
True if the identifier is still valid, false otherwise.
-

Definition at line 293 of file registry.hpp.

+

Definition at line 295 of file registry.hpp.

@@ -2092,7 +2198,7 @@ template<typename Entity>
Returns
Version stored along with the given entity identifier.
-

Definition at line 305 of file registry.hpp.

+

Definition at line 307 of file registry.hpp.

@@ -2147,7 +2253,7 @@ template<typename... Component>
Returns
A newly created standard view.
-

Definition at line 940 of file registry.hpp.

+

Definition at line 982 of file registry.hpp.

diff --git a/classentt_1_1ResourceCache-members.html b/classentt_1_1ResourceCache-members.html index 3c8d53196..ab1b04717 100644 --- a/classentt_1_1ResourceCache-members.html +++ b/classentt_1_1ResourceCache-members.html @@ -22,7 +22,7 @@
entt -  2.4.1 +  2.4.2
diff --git a/classentt_1_1ResourceCache.html b/classentt_1_1ResourceCache.html index 25f0cf754..68178539e 100644 --- a/classentt_1_1ResourceCache.html +++ b/classentt_1_1ResourceCache.html @@ -22,7 +22,7 @@
entt -  2.4.1 +  2.4.2
diff --git a/classentt_1_1ResourceHandle-members.html b/classentt_1_1ResourceHandle-members.html index a783b1567..e03c41b70 100644 --- a/classentt_1_1ResourceHandle-members.html +++ b/classentt_1_1ResourceHandle-members.html @@ -22,7 +22,7 @@
entt -  2.4.1 +  2.4.2
diff --git a/classentt_1_1ResourceHandle.html b/classentt_1_1ResourceHandle.html index 075f5f2b9..52cc1db51 100644 --- a/classentt_1_1ResourceHandle.html +++ b/classentt_1_1ResourceHandle.html @@ -22,7 +22,7 @@
entt -  2.4.1 +  2.4.2
diff --git a/classentt_1_1ResourceLoader-members.html b/classentt_1_1ResourceLoader-members.html index bb996295c..ad1d0e8e7 100644 --- a/classentt_1_1ResourceLoader-members.html +++ b/classentt_1_1ResourceLoader-members.html @@ -22,7 +22,7 @@
entt -  2.4.1 +  2.4.2
diff --git a/classentt_1_1ResourceLoader.html b/classentt_1_1ResourceLoader.html index b5a9ad80d..09ed7035e 100644 --- a/classentt_1_1ResourceLoader.html +++ b/classentt_1_1ResourceLoader.html @@ -22,7 +22,7 @@
entt -  2.4.1 +  2.4.2
diff --git a/classentt_1_1Scheduler-members.html b/classentt_1_1Scheduler-members.html index 376cab011..81c0ebef0 100644 --- a/classentt_1_1Scheduler-members.html +++ b/classentt_1_1Scheduler-members.html @@ -22,7 +22,7 @@
entt -  2.4.1 +  2.4.2
diff --git a/classentt_1_1Scheduler.html b/classentt_1_1Scheduler.html index 4767f9f30..42b9225b2 100644 --- a/classentt_1_1Scheduler.html +++ b/classentt_1_1Scheduler.html @@ -22,7 +22,7 @@
entt -  2.4.1 +  2.4.2
diff --git a/classentt_1_1SigH.html b/classentt_1_1SigH.html index 4ee3b3e83..826cbbeb1 100644 --- a/classentt_1_1SigH.html +++ b/classentt_1_1SigH.html @@ -22,7 +22,7 @@
entt -  2.4.1 +  2.4.2
diff --git a/classentt_1_1SigH_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4-members.html b/classentt_1_1SigH_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4-members.html index 97d3ec4a1..4043f7eaf 100644 --- a/classentt_1_1SigH_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4-members.html +++ b/classentt_1_1SigH_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4-members.html @@ -22,7 +22,7 @@
entt -  2.4.1 +  2.4.2
diff --git a/classentt_1_1SigH_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4.html b/classentt_1_1SigH_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4.html index a10feb613..062436b7b 100644 --- a/classentt_1_1SigH_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4.html +++ b/classentt_1_1SigH_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4.html @@ -22,7 +22,7 @@
entt -  2.4.1 +  2.4.2
diff --git a/classentt_1_1Signal.html b/classentt_1_1Signal.html index c3580cb50..51a10a0c2 100644 --- a/classentt_1_1Signal.html +++ b/classentt_1_1Signal.html @@ -22,7 +22,7 @@
entt -  2.4.1 +  2.4.2
diff --git a/classentt_1_1Signal_3_01void_07Args_8_8_8_08_4-members.html b/classentt_1_1Signal_3_01void_07Args_8_8_8_08_4-members.html index 8f23c8725..b03b53ea9 100644 --- a/classentt_1_1Signal_3_01void_07Args_8_8_8_08_4-members.html +++ b/classentt_1_1Signal_3_01void_07Args_8_8_8_08_4-members.html @@ -22,7 +22,7 @@
entt -  2.4.1 +  2.4.2
diff --git a/classentt_1_1Signal_3_01void_07Args_8_8_8_08_4.html b/classentt_1_1Signal_3_01void_07Args_8_8_8_08_4.html index 6880e3960..b511c5df1 100644 --- a/classentt_1_1Signal_3_01void_07Args_8_8_8_08_4.html +++ b/classentt_1_1Signal_3_01void_07Args_8_8_8_08_4.html @@ -22,7 +22,7 @@
entt -  2.4.1 +  2.4.2
diff --git a/classentt_1_1SparseSet.html b/classentt_1_1SparseSet.html index 01cac112c..002db7a18 100644 --- a/classentt_1_1SparseSet.html +++ b/classentt_1_1SparseSet.html @@ -22,7 +22,7 @@
entt -  2.4.1 +  2.4.2
diff --git a/classentt_1_1SparseSet_3_01Entity_00_01Type_01_4-members.html b/classentt_1_1SparseSet_3_01Entity_00_01Type_01_4-members.html index 5622186d5..60d48ff83 100644 --- a/classentt_1_1SparseSet_3_01Entity_00_01Type_01_4-members.html +++ b/classentt_1_1SparseSet_3_01Entity_00_01Type_01_4-members.html @@ -22,7 +22,7 @@
entt -  2.4.1 +  2.4.2
diff --git a/classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html b/classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html index 9f255538c..fa161022e 100644 --- a/classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html +++ b/classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html @@ -22,7 +22,7 @@
entt -  2.4.1 +  2.4.2
@@ -653,7 +653,7 @@ template<typename Entity , typename Type >

Reimplemented from entt::SparseSet< Entity >.

-

Definition at line 610 of file sparse_set.hpp.

+

Definition at line 612 of file sparse_set.hpp.

@@ -702,7 +702,7 @@ template<typename Compare > -

Definition at line 564 of file sparse_set.hpp.

+

Definition at line 566 of file sparse_set.hpp.

diff --git a/classentt_1_1SparseSet_3_01Entity_01_4-members.html b/classentt_1_1SparseSet_3_01Entity_01_4-members.html index a29cda1e7..7765f650b 100644 --- a/classentt_1_1SparseSet_3_01Entity_01_4-members.html +++ b/classentt_1_1SparseSet_3_01Entity_01_4-members.html @@ -22,7 +22,7 @@
entt -  2.4.1 +  2.4.2
diff --git a/classentt_1_1SparseSet_3_01Entity_01_4.html b/classentt_1_1SparseSet_3_01Entity_01_4.html index 0ae78d70a..4c8ac1d70 100644 --- a/classentt_1_1SparseSet_3_01Entity_01_4.html +++ b/classentt_1_1SparseSet_3_01Entity_01_4.html @@ -22,7 +22,7 @@
entt -  2.4.1 +  2.4.2
diff --git a/classentt_1_1View-members.html b/classentt_1_1View-members.html index 4cbe52afe..cca64ce24 100644 --- a/classentt_1_1View-members.html +++ b/classentt_1_1View-members.html @@ -22,7 +22,7 @@
entt -  2.4.1 +  2.4.2
@@ -77,6 +77,8 @@ $(function() { entity_type typedefentt::View< Entity, Component > get(entity_type entity) const noexceptentt::View< Entity, Component >inline get(entity_type entity) noexceptentt::View< Entity, Component >inline + get(entity_type entity) const noexceptentt::View< Entity, Component >inline + get(entity_type entity) noexceptentt::View< Entity, Component >inline iterator_type typedefentt::View< Entity, Component > reset()entt::View< Entity, Component >inline size_type typedefentt::View< Entity, Component > diff --git a/classentt_1_1View.html b/classentt_1_1View.html index 79b411c7c..6e040a728 100644 --- a/classentt_1_1View.html +++ b/classentt_1_1View.html @@ -22,7 +22,7 @@
entt -  2.4.1 +  2.4.2
@@ -110,6 +110,14 @@ Public Member Functions Comp & get (entity_type entity) noexcept  Returns the component assigned to the given entity. More...
  +template<typename... Comp> +std::enable_if_t<(sizeof...(Comp) > 1), std::tuple< const Comp &... > > get (entity_type entity) const noexcept + Returns the components assigned to the given entity. More...
+  +template<typename... Comp> +std::enable_if_t<(sizeof...(Comp) > 1), std::tuple< Comp &... > > get (entity_type entity) noexcept + Returns the components assigned to the given entity. More...
+  template<typename Func > void each (Func func) const  Iterate the entities and applies them the given function object. More...
@@ -149,7 +157,7 @@ class entt::View< Entity, Component > -

Definition at line 301 of file view.hpp.

+

Definition at line 348 of file view.hpp.

Member Typedef Documentation

◆ iterator_type

@@ -166,7 +174,7 @@ template<typename Entity , typename... Component>

Input iterator type.

-

Definition at line 363 of file view.hpp.

+

Definition at line 410 of file view.hpp.

@@ -205,7 +213,7 @@ template<typename Entity , typename... Component> -

Definition at line 373 of file view.hpp.

+

Definition at line 420 of file view.hpp.

@@ -240,7 +248,7 @@ template<typename Entity , typename... Component>
Note
Input iterators stay true to the order imposed to the underlying data structures.
Returns
An iterator to the first entity that has the given components.
-

Definition at line 393 of file view.hpp.

+

Definition at line 440 of file view.hpp.

@@ -288,7 +296,7 @@ template<typename Func > -

Definition at line 476 of file view.hpp.

+

Definition at line 569 of file view.hpp.

@@ -336,7 +344,7 @@ template<typename Func > -

Definition at line 498 of file view.hpp.

+

Definition at line 591 of file view.hpp.

@@ -370,12 +378,12 @@ template<typename Entity , typename... Component>
Note
Input iterators stay true to the order imposed to the underlying data structures.
Returns
An iterator to the entity following the last entity that has the given components.
-

Definition at line 412 of file view.hpp.

+

Definition at line 459 of file view.hpp.

-

◆ get() [1/2]

+

◆ get() [1/4]

@@ -420,12 +428,12 @@ template<typename Comp >
Returns
The component assigned to the entity.
-

Definition at line 434 of file view.hpp.

+

Definition at line 481 of file view.hpp.

-

◆ get() [2/2]

+

◆ get() [2/4]

@@ -470,7 +478,107 @@ template<typename Comp >
Returns
The component assigned to the entity.
-

Definition at line 456 of file view.hpp.

+

Definition at line 503 of file view.hpp.

+ +
+ + +

◆ get() [3/4]

+ +
+
+
+template<typename Entity , typename... Component>
+
+template<typename... Comp>
+ + + + + +
+ + + + + + + + +
std::enable_if_t<(sizeof...(Comp) > 1), std::tuple<const Comp &...> > entt::View< Entity, Component >::get (entity_type entity) const
+ 		+inlinenoexcept
+
+ +

Returns the components assigned to the given entity.

+

Prefer this function instead of Registry::get during iterations. It has far better performance than its companion function.

+
Warning
Attempting to use invalid component types results in a compilation error. Attempting to use an entity that doesn't belong to the view results in undefined behavior.
+ An assertion will abort the execution at runtime in debug mode if the view doesn't contain the given entity.
+
Template Parameters
+ + +
CompTypes of the components to get.
+
+
+
Parameters
+ + +
entityA valid entity identifier.
+
+
+
Returns
The components assigned to the entity.
+ +

Definition at line 526 of file view.hpp.

+ +
+
+ +

◆ get() [4/4]

+ +
+
+
+template<typename Entity , typename... Component>
+
+template<typename... Comp>
+ + + + + +
+ + + + + + + + +
std::enable_if_t<(sizeof...(Comp) > 1), std::tuple<Comp &...> > entt::View< Entity, Component >::get (entity_type entity)
+ 		+inlinenoexcept
+
+ +

Returns the components assigned to the given entity.

+

Prefer this function instead of Registry::get during iterations. It has far better performance than its companion function.

+
Warning
Attempting to use invalid component types results in a compilation error. Attempting to use an entity that doesn't belong to the view results in undefined behavior.
+ An assertion will abort the execution at runtime in debug mode if the view doesn't contain the given entity.
+
Template Parameters
+ + +
CompTypes of the components to get.
+
+
+
Parameters
+ + +
entityA valid entity identifier.
+
+
+
Returns
The components assigned to the entity.
+ +

Definition at line 549 of file view.hpp.

@@ -503,7 +611,7 @@ template<typename Entity , typename... Component>

A multi component view keeps a reference to the smallest set of candidate entities to iterate. Resetting a view means querying the underlying data structures and reinitializing the view.
Use it only if copies of views are stored around and there is a possibility that a component has become the best candidate in the meantime.

-

Definition at line 514 of file view.hpp.

+

Definition at line 607 of file view.hpp.

diff --git a/classentt_1_1View_3_01Entity_00_01Component_01_4-members.html b/classentt_1_1View_3_01Entity_00_01Component_01_4-members.html index 59d1c4496..8964c4f3c 100644 --- a/classentt_1_1View_3_01Entity_00_01Component_01_4-members.html +++ b/classentt_1_1View_3_01Entity_00_01Component_01_4-members.html @@ -22,7 +22,7 @@
entt -  2.4.1 +  2.4.2
diff --git a/classentt_1_1View_3_01Entity_00_01Component_01_4.html b/classentt_1_1View_3_01Entity_00_01Component_01_4.html index 0724afa01..f33bc33b2 100644 --- a/classentt_1_1View_3_01Entity_00_01Component_01_4.html +++ b/classentt_1_1View_3_01Entity_00_01Component_01_4.html @@ -22,7 +22,7 @@
entt -  2.4.1 +  2.4.2
@@ -157,7 +157,7 @@ class entt::View< Entity, Component > -

Definition at line 565 of file view.hpp.

+

Definition at line 658 of file view.hpp.

Member Typedef Documentation

◆ iterator_type

@@ -174,7 +174,7 @@ template<typename Entity , typename Component >

Input iterator type.

-

Definition at line 570 of file view.hpp.

+

Definition at line 663 of file view.hpp.

@@ -193,7 +193,7 @@ template<typename Entity , typename Component >

Type of the component iterated by the view.

-

Definition at line 576 of file view.hpp.

+

Definition at line 669 of file view.hpp.

@@ -232,7 +232,7 @@ template<typename Entity , typename Component > -

Definition at line 582 of file view.hpp.

+

Definition at line 675 of file view.hpp.

@@ -267,7 +267,7 @@ template<typename Entity , typename Component >
Note
Input iterators stay true to the order imposed to the underlying data structures.
Returns
An iterator to the first entity that has the given component.
-

Definition at line 656 of file view.hpp.

+

Definition at line 749 of file view.hpp.

@@ -301,7 +301,7 @@ template<typename Entity , typename Component >
Note
There are no guarantees on the order of the entities. Use begin and end if you want to iterate the view in the expected order.
Returns
A pointer to the array of entities.
-

Definition at line 638 of file view.hpp.

+

Definition at line 731 of file view.hpp.

@@ -349,7 +349,7 @@ template<typename Func > -

Definition at line 732 of file view.hpp.

+

Definition at line 825 of file view.hpp.

@@ -397,7 +397,7 @@ template<typename Func > -

Definition at line 753 of file view.hpp.

+

Definition at line 846 of file view.hpp.

@@ -431,7 +431,7 @@ template<typename Entity , typename Component >
Note
Input iterators stay true to the order imposed to the underlying data structures.
Returns
An iterator to the entity following the last entity that has the given component.
-

Definition at line 675 of file view.hpp.

+

Definition at line 768 of file view.hpp.

@@ -473,7 +473,7 @@ template<typename Entity , typename Component >
Returns
The component assigned to the entity.
-

Definition at line 694 of file view.hpp.

+

Definition at line 787 of file view.hpp.

@@ -515,7 +515,7 @@ template<typename Entity , typename Component >
Returns
The component assigned to the entity.
-

Definition at line 713 of file view.hpp.

+

Definition at line 806 of file view.hpp.

@@ -549,7 +549,7 @@ template<typename Entity , typename Component >
Note
There are no guarantees on the order of the components. Use begin and end if you want to iterate the view in the expected order.
Returns
A pointer to the array of components.
-

Definition at line 606 of file view.hpp.

+

Definition at line 699 of file view.hpp.

@@ -583,7 +583,7 @@ template<typename Entity , typename Component >
Note
There are no guarantees on the order of the components. Use begin and end if you want to iterate the view in the expected order.
Returns
A pointer to the array of components.
-

Definition at line 622 of file view.hpp.

+

Definition at line 715 of file view.hpp.

@@ -615,7 +615,7 @@ template<typename Entity , typename Component >

Returns the number of entities that have the given component.

Returns
Number of entities that have the given component.
-

Definition at line 590 of file view.hpp.

+

Definition at line 683 of file view.hpp.

diff --git a/classes.html b/classes.html index 62adb6568..26b009ed4 100644 --- a/classes.html +++ b/classes.html @@ -22,7 +22,7 @@
entt -  2.4.1 +  2.4.2
diff --git a/delegate_8hpp_source.html b/delegate_8hpp_source.html index 56a957932..364e83d29 100644 --- a/delegate_8hpp_source.html +++ b/delegate_8hpp_source.html @@ -22,7 +22,7 @@
entt -  2.4.1 +  2.4.2
@@ -75,7 +75,7 @@ $(function() {
entt::Delegate< Ret(Args...)>::connect
void connect() noexcept
Binds a free function to a delegate.
Definition: delegate.hpp:62
entt::Delegate< Ret(Args...)>::operator()
Ret operator()(Args... args)
Triggers a delegate.
Definition: delegate.hpp:96
entt::Delegate< Ret(Args...)>::reset
void reset() noexcept
Resets a delegate.
Definition: delegate.hpp:87
-
entt::operator!=
constexpr bool operator!=(const HashedString &lhs, const HashedString &rhs) noexcept
Compares two hashed strings.
Definition: hashed_string.hpp:101
+
entt::operator!=
constexpr bool operator!=(const HashedString &lhs, const HashedString &rhs) noexcept
Compares two hashed strings.
Definition: hashed_string.hpp:102
diff --git a/dir_66e9674e8206a335795995fa32a03c91.html b/dir_66e9674e8206a335795995fa32a03c91.html index 9df5280b7..4c3fe2d8a 100644 --- a/dir_66e9674e8206a335795995fa32a03c91.html +++ b/dir_66e9674e8206a335795995fa32a03c91.html @@ -22,7 +22,7 @@
entt -  2.4.1 +  2.4.2
diff --git a/dir_68267d1309a1af8e8297ef4c3efbcdba.html b/dir_68267d1309a1af8e8297ef4c3efbcdba.html index e8c291263..cb2540525 100644 --- a/dir_68267d1309a1af8e8297ef4c3efbcdba.html +++ b/dir_68267d1309a1af8e8297ef4c3efbcdba.html @@ -22,7 +22,7 @@
entt -  2.4.1 +  2.4.2
diff --git a/dir_721f6154dba3c88bcdead5f446bce319.html b/dir_721f6154dba3c88bcdead5f446bce319.html index 6b06501b3..6e629babe 100644 --- a/dir_721f6154dba3c88bcdead5f446bce319.html +++ b/dir_721f6154dba3c88bcdead5f446bce319.html @@ -22,7 +22,7 @@
entt -  2.4.1 +  2.4.2
diff --git a/dir_85dbee8884f1b3a817fa7eff8dff73ec.html b/dir_85dbee8884f1b3a817fa7eff8dff73ec.html index 4046c037d..f692fff52 100644 --- a/dir_85dbee8884f1b3a817fa7eff8dff73ec.html +++ b/dir_85dbee8884f1b3a817fa7eff8dff73ec.html @@ -22,7 +22,7 @@
entt -  2.4.1 +  2.4.2
diff --git a/dir_a53318306f6ac0f7fe657839abd543ab.html b/dir_a53318306f6ac0f7fe657839abd543ab.html index 9e6ca9afc..cdb48a3fa 100644 --- a/dir_a53318306f6ac0f7fe657839abd543ab.html +++ b/dir_a53318306f6ac0f7fe657839abd543ab.html @@ -22,7 +22,7 @@
entt -  2.4.1 +  2.4.2
diff --git a/dir_b64489a1e8130d5ebf6d86d282f500f0.html b/dir_b64489a1e8130d5ebf6d86d282f500f0.html index 0f7e27bc2..68c195ece 100644 --- a/dir_b64489a1e8130d5ebf6d86d282f500f0.html +++ b/dir_b64489a1e8130d5ebf6d86d282f500f0.html @@ -22,7 +22,7 @@
entt -  2.4.1 +  2.4.2
diff --git a/dir_de8f4e6ba3f54a2a21309f742e93a373.html b/dir_de8f4e6ba3f54a2a21309f742e93a373.html index ea4d64270..d952e08fd 100644 --- a/dir_de8f4e6ba3f54a2a21309f742e93a373.html +++ b/dir_de8f4e6ba3f54a2a21309f742e93a373.html @@ -22,7 +22,7 @@
entt -  2.4.1 +  2.4.2
diff --git a/dir_e3a7bb56c55e5c2286e2fe96e197d4f5.html b/dir_e3a7bb56c55e5c2286e2fe96e197d4f5.html index 6453dc984..557ff958c 100644 --- a/dir_e3a7bb56c55e5c2286e2fe96e197d4f5.html +++ b/dir_e3a7bb56c55e5c2286e2fe96e197d4f5.html @@ -22,7 +22,7 @@
entt -  2.4.1 +  2.4.2
diff --git a/dispatcher_8hpp_source.html b/dispatcher_8hpp_source.html index cba233b63..cdc4ef4df 100644 --- a/dispatcher_8hpp_source.html +++ b/dispatcher_8hpp_source.html @@ -22,7 +22,7 @@
entt -  2.4.1 +  2.4.2
diff --git a/emitter_8hpp_source.html b/emitter_8hpp_source.html index e10836d6e..f19fd4ad5 100644 --- a/emitter_8hpp_source.html +++ b/emitter_8hpp_source.html @@ -22,7 +22,7 @@
entt -  2.4.1 +  2.4.2
diff --git a/entt_8hpp_source.html b/entt_8hpp_source.html index 3eff5585d..6b3e4be12 100644 --- a/entt_8hpp_source.html +++ b/entt_8hpp_source.html @@ -22,7 +22,7 @@
entt -  2.4.1 +  2.4.2
@@ -67,7 +67,7 @@ $(function() {
entt.hpp
-
1 #include "core/family.hpp"
2 #include "core/hashed_string.hpp"
3 #include "core/ident.hpp"
4 #include "entity/actor.hpp"
5 #include "entity/registry.hpp"
6 #include "entity/sparse_set.hpp"
7 #include "entity/traits.hpp"
8 #include "entity/view.hpp"
9 #include "locator/locator.hpp"
10 #include "process/process.hpp"
11 #include "process/scheduler.hpp"
12 #include "resource/cache.hpp"
13 #include "resource/handle.hpp"
14 #include "resource/loader.hpp"
15 #include "signal/bus.hpp"
16 #include "signal/delegate.hpp"
17 #include "signal/emitter.hpp"
18 #include "signal/sigh.hpp"
19 #include "signal/signal.hpp"
+
1 #include "core/family.hpp"
2 #include "core/hashed_string.hpp"
3 #include "core/ident.hpp"
4 #include "entity/actor.hpp"
5 #include "entity/entt_traits.hpp"
6 #include "entity/registry.hpp"
7 #include "entity/sparse_set.hpp"
8 #include "entity/view.hpp"
9 #include "locator/locator.hpp"
10 #include "process/process.hpp"
11 #include "process/scheduler.hpp"
12 #include "resource/cache.hpp"
13 #include "resource/handle.hpp"
14 #include "resource/loader.hpp"
15 #include "signal/bus.hpp"
16 #include "signal/delegate.hpp"
17 #include "signal/emitter.hpp"
18 #include "signal/sigh.hpp"
19 #include "signal/signal.hpp"
Generated by   diff --git a/entt__traits_8hpp_source.html b/entt__traits_8hpp_source.html new file mode 100644 index 000000000..4c8d87d81 --- /dev/null +++ b/entt__traits_8hpp_source.html @@ -0,0 +1,86 @@ + + + + + + + +entt: src/entt/entity/entt_traits.hpp Source File + + + + + + + + + + +
+
+
entt_traits.hpp
+
+
+
1 #ifndef ENTT_ENTITY_ENTT_TRAITS_HPP
2 #define ENTT_ENTITY_ENTT_TRAITS_HPP
3 
4 
5 #include <cstdint>
6 
7 
8 namespace entt {
9 
10 
17 template<typename>
18 struct entt_traits;
19 
20 
29 template<>
30 struct entt_traits<std::uint16_t> {
32  using entity_type = std::uint16_t;
34  using version_type = std::uint8_t;
35 
37  static constexpr auto entity_mask = 0xFFF;
39  static constexpr auto version_mask = 0xF;
41  static constexpr auto entity_shift = 12;
42 };
43 
44 
53 template<>
54 struct entt_traits<std::uint32_t> {
56  using entity_type = std::uint32_t;
58  using version_type = std::uint16_t;
59 
61  static constexpr auto entity_mask = 0xFFFFFF;
63  static constexpr auto version_mask = 0xFF;
65  static constexpr auto entity_shift = 24;
66 };
67 
68 
77 template<>
78 struct entt_traits<std::uint64_t> {
80  using entity_type = std::uint64_t;
82  using version_type = std::uint32_t;
83 
85  static constexpr auto entity_mask = 0xFFFFFFFFFF;
87  static constexpr auto version_mask = 0xFFFFFF;
89  static constexpr auto entity_shift = 40;
90 };
91 
92 
93 }
94 
95 
96 #endif // ENTT_ENTITY_ENTT_TRAITS_HPP
entt::entt_traits< std::uint32_t >::entity_type
std::uint32_t entity_type
Underlying entity type.
Definition: entt_traits.hpp:56
+
entt::entt_traits< std::uint64_t >::entity_type
std::uint64_t entity_type
Underlying entity type.
Definition: entt_traits.hpp:80
+
entt
EnTT default namespace.
Definition: family.hpp:9
+
entt::entt_traits< std::uint16_t >::entity_type
std::uint16_t entity_type
Underlying entity type.
Definition: entt_traits.hpp:32
+
entt::entt_traits< std::uint64_t >::version_type
std::uint32_t version_type
Underlying version type.
Definition: entt_traits.hpp:82
+
entt::entt_traits< std::uint16_t >::version_type
std::uint8_t version_type
Underlying version type.
Definition: entt_traits.hpp:34
+
entt::entt_traits< std::uint32_t >::version_type
std::uint16_t version_type
Underlying version type.
Definition: entt_traits.hpp:58
+
entt::entt_traits
Entity traits.
Definition: entt_traits.hpp:18
+
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/family_8hpp_source.html b/family_8hpp_source.html index 500c32662..9de779b58 100644 --- a/family_8hpp_source.html +++ b/family_8hpp_source.html @@ -22,7 +22,7 @@
entt -  2.4.1 +  2.4.2
diff --git a/files.html b/files.html index bb7b43c92..7239d7110 100644 --- a/files.html +++ b/files.html @@ -22,7 +22,7 @@
entt -  2.4.1 +  2.4.2
@@ -73,9 +73,9 @@ $(function() {  ident.hpp  ▼ entity  actor.hpp - registry.hpp - sparse_set.hpp - traits.hpp + entt_traits.hpp + registry.hpp + sparse_set.hpp  view.hpp  ▼ locator  locator.hpp diff --git a/functions.html b/functions.html index db66582d1..9093cea9b 100644 --- a/functions.html +++ b/functions.html @@ -22,7 +22,7 @@
entt -  2.4.1 +  2.4.2
diff --git a/functions_0x7e.html b/functions_0x7e.html index aa8453875..5dc9b1e5c 100644 --- a/functions_0x7e.html +++ b/functions_0x7e.html @@ -22,7 +22,7 @@
entt -  2.4.1 +  2.4.2
diff --git a/functions_b.html b/functions_b.html index 08d0d02fa..3c8ae5e55 100644 --- a/functions_b.html +++ b/functions_b.html @@ -22,7 +22,7 @@
entt -  2.4.1 +  2.4.2
diff --git a/functions_c.html b/functions_c.html index 57ed3f4d3..9416f791a 100644 --- a/functions_c.html +++ b/functions_c.html @@ -22,7 +22,7 @@
entt -  2.4.1 +  2.4.2
diff --git a/functions_d.html b/functions_d.html index 902de17f8..793a530ed 100644 --- a/functions_d.html +++ b/functions_d.html @@ -22,7 +22,7 @@
entt -  2.4.1 +  2.4.2
diff --git a/functions_e.html b/functions_e.html index 1bb0f09f0..f971f79e9 100644 --- a/functions_e.html +++ b/functions_e.html @@ -22,7 +22,7 @@
entt -  2.4.1 +  2.4.2
@@ -102,7 +102,8 @@ $(function() { , entt::entt_traits< std::uint64_t >
  • entity_type -: entt::entt_traits< std::uint16_t > +: entt::Actor< Entity, Delta > +, entt::entt_traits< std::uint16_t > , entt::entt_traits< std::uint32_t > , entt::entt_traits< std::uint64_t > , entt::PersistentView< Entity, Component > diff --git a/functions_f.html b/functions_f.html index 67377b6a7..a5437249e 100644 --- a/functions_f.html +++ b/functions_f.html @@ -22,7 +22,7 @@
    entt -  2.4.1 +  2.4.2
    diff --git a/functions_func.html b/functions_func.html index 21bd79f81..f9eae80c1 100644 --- a/functions_func.html +++ b/functions_func.html @@ -22,7 +22,7 @@
    entt -  2.4.1 +  2.4.2
    diff --git a/functions_func_0x7e.html b/functions_func_0x7e.html index 831519fe6..9adb554aa 100644 --- a/functions_func_0x7e.html +++ b/functions_func_0x7e.html @@ -22,7 +22,7 @@
    entt -  2.4.1 +  2.4.2
    diff --git a/functions_func_b.html b/functions_func_b.html index 1f87c3b32..f5e8a9582 100644 --- a/functions_func_b.html +++ b/functions_func_b.html @@ -22,7 +22,7 @@
    entt -  2.4.1 +  2.4.2
    diff --git a/functions_func_c.html b/functions_func_c.html index 1b95c8eea..961a7c2b3 100644 --- a/functions_func_c.html +++ b/functions_func_c.html @@ -22,7 +22,7 @@
    entt -  2.4.1 +  2.4.2
    diff --git a/functions_func_d.html b/functions_func_d.html index 4fdcaec1a..fe2057988 100644 --- a/functions_func_d.html +++ b/functions_func_d.html @@ -22,7 +22,7 @@
    entt -  2.4.1 +  2.4.2
    diff --git a/functions_func_e.html b/functions_func_e.html index 88f41e554..a105d87c0 100644 --- a/functions_func_e.html +++ b/functions_func_e.html @@ -22,7 +22,7 @@
    entt -  2.4.1 +  2.4.2
    diff --git a/functions_func_f.html b/functions_func_f.html index 83a36988a..647488023 100644 --- a/functions_func_f.html +++ b/functions_func_f.html @@ -22,7 +22,7 @@
    entt -  2.4.1 +  2.4.2
    diff --git a/functions_func_g.html b/functions_func_g.html index d1c22adad..41ac99466 100644 --- a/functions_func_g.html +++ b/functions_func_g.html @@ -22,7 +22,7 @@
    entt -  2.4.1 +  2.4.2
    @@ -69,7 +69,7 @@ $(function() { , entt::ResourceHandle< Resource > , entt::ServiceLocator< Service > , entt::SparseSet< Entity > -, entt::SparseSet< Entity, Type > +, entt::SparseSet< Entity, Type > , entt::View< Entity, Component >
    • diff --git a/functions_func_h.html b/functions_func_h.html index fcfc1ce2a..6ba1ef3e7 100644 --- a/functions_func_h.html +++ b/functions_func_h.html @@ -22,7 +22,7 @@
    entt -  2.4.1 +  2.4.2
    diff --git a/functions_func_l.html b/functions_func_l.html index 476dbeb0c..24242746a 100644 --- a/functions_func_l.html +++ b/functions_func_l.html @@ -22,7 +22,7 @@
    entt -  2.4.1 +  2.4.2
    diff --git a/functions_func_o.html b/functions_func_o.html index e82f4883c..f79dc655d 100644 --- a/functions_func_o.html +++ b/functions_func_o.html @@ -22,7 +22,7 @@
    entt -  2.4.1 +  2.4.2
    diff --git a/functions_func_p.html b/functions_func_p.html index e64d0d74e..da4a3954a 100644 --- a/functions_func_p.html +++ b/functions_func_p.html @@ -22,7 +22,7 @@
    entt -  2.4.1 +  2.4.2
    diff --git a/functions_func_r.html b/functions_func_r.html index 7f138223f..c83af2cfb 100644 --- a/functions_func_r.html +++ b/functions_func_r.html @@ -22,7 +22,7 @@
    entt -  2.4.1 +  2.4.2
    diff --git a/functions_func_s.html b/functions_func_s.html index da864a6db..479595d7f 100644 --- a/functions_func_s.html +++ b/functions_func_s.html @@ -22,7 +22,7 @@
    entt -  2.4.1 +  2.4.2
    diff --git a/functions_func_t.html b/functions_func_t.html index e75f8361b..3f147ddc2 100644 --- a/functions_func_t.html +++ b/functions_func_t.html @@ -22,7 +22,7 @@
    entt -  2.4.1 +  2.4.2
    diff --git a/functions_func_u.html b/functions_func_u.html index 705dc4744..745ccb082 100644 --- a/functions_func_u.html +++ b/functions_func_u.html @@ -22,7 +22,7 @@
    entt -  2.4.1 +  2.4.2
    diff --git a/functions_func_v.html b/functions_func_v.html index c20d244c3..33ec11ae3 100644 --- a/functions_func_v.html +++ b/functions_func_v.html @@ -22,7 +22,7 @@
    entt -  2.4.1 +  2.4.2
    diff --git a/functions_g.html b/functions_g.html index 735736c54..b12d2bd71 100644 --- a/functions_g.html +++ b/functions_g.html @@ -22,7 +22,7 @@
    entt -  2.4.1 +  2.4.2
    @@ -69,7 +69,7 @@ $(function() { , entt::ResourceHandle< Resource > , entt::ServiceLocator< Service > , entt::SparseSet< Entity > -, entt::SparseSet< Entity, Type > +, entt::SparseSet< Entity, Type > , entt::View< Entity, Component > diff --git a/functions_h.html b/functions_h.html index 931364124..f08ce4fc7 100644 --- a/functions_h.html +++ b/functions_h.html @@ -22,7 +22,7 @@
    entt -  2.4.1 +  2.4.2
    diff --git a/functions_i.html b/functions_i.html index 655718c41..ae61a45f6 100644 --- a/functions_i.html +++ b/functions_i.html @@ -22,7 +22,7 @@
    entt -  2.4.1 +  2.4.2
    diff --git a/functions_l.html b/functions_l.html index 6df07eb7d..ee6b8b96f 100644 --- a/functions_l.html +++ b/functions_l.html @@ -22,7 +22,7 @@
    entt -  2.4.1 +  2.4.2
    diff --git a/functions_o.html b/functions_o.html index 93e8dc9a5..3dc36fdc6 100644 --- a/functions_o.html +++ b/functions_o.html @@ -22,7 +22,7 @@
    entt -  2.4.1 +  2.4.2
    diff --git a/functions_p.html b/functions_p.html index 98875150a..fd8ea8638 100644 --- a/functions_p.html +++ b/functions_p.html @@ -22,7 +22,7 @@
    entt -  2.4.1 +  2.4.2
    diff --git a/functions_r.html b/functions_r.html index aa4e6a4a4..e635a0d00 100644 --- a/functions_r.html +++ b/functions_r.html @@ -22,7 +22,7 @@
    entt -  2.4.1 +  2.4.2
    diff --git a/functions_rela.html b/functions_rela.html index e2d457651..91d60d3a2 100644 --- a/functions_rela.html +++ b/functions_rela.html @@ -22,7 +22,7 @@
    entt -  2.4.1 +  2.4.2
    diff --git a/functions_s.html b/functions_s.html index 928da9221..9581bd6cb 100644 --- a/functions_s.html +++ b/functions_s.html @@ -22,7 +22,7 @@
    entt -  2.4.1 +  2.4.2
    diff --git a/functions_t.html b/functions_t.html index a9a974b30..007467ceb 100644 --- a/functions_t.html +++ b/functions_t.html @@ -22,7 +22,7 @@
    entt -  2.4.1 +  2.4.2
    diff --git a/functions_type.html b/functions_type.html index 87a3b230f..b26a8c346 100644 --- a/functions_type.html +++ b/functions_type.html @@ -22,7 +22,7 @@
    entt -  2.4.1 +  2.4.2
    @@ -81,7 +81,8 @@ $(function() {

    - e -

    • entity_type -: entt::entt_traits< std::uint16_t > +: entt::Actor< Entity, Delta > +, entt::entt_traits< std::uint16_t > , entt::entt_traits< std::uint32_t > , entt::entt_traits< std::uint64_t > , entt::PersistentView< Entity, Component > diff --git a/functions_u.html b/functions_u.html index 81cff3a48..047c064c5 100644 --- a/functions_u.html +++ b/functions_u.html @@ -22,7 +22,7 @@
      entt -  2.4.1 +  2.4.2
      diff --git a/functions_v.html b/functions_v.html index fa2edfbd1..05b27be76 100644 --- a/functions_v.html +++ b/functions_v.html @@ -22,7 +22,7 @@
      entt -  2.4.1 +  2.4.2
      diff --git a/functions_vars.html b/functions_vars.html index e71ea9e60..796944f51 100644 --- a/functions_vars.html +++ b/functions_vars.html @@ -22,7 +22,7 @@
      entt -  2.4.1 +  2.4.2
      diff --git a/graph_legend.html b/graph_legend.html index 194a8dcb4..aa3f85509 100644 --- a/graph_legend.html +++ b/graph_legend.html @@ -22,7 +22,7 @@
      entt -  2.4.1 +  2.4.2
      diff --git a/handle_8hpp_source.html b/handle_8hpp_source.html index 9af70b9bb..e300f20bf 100644 --- a/handle_8hpp_source.html +++ b/handle_8hpp_source.html @@ -22,7 +22,7 @@
      entt -  2.4.1 +  2.4.2
      diff --git a/hashed__string_8hpp_source.html b/hashed__string_8hpp_source.html index e891c7596..57f5e30c6 100644 --- a/hashed__string_8hpp_source.html +++ b/hashed__string_8hpp_source.html @@ -22,7 +22,7 @@
      entt -  2.4.1 +  2.4.2
      @@ -67,13 +67,13 @@ $(function() {
      hashed_string.hpp
      -
      1 #ifndef ENTT_CORE_HASHED_STRING_HPP
      2 #define ENTT_CORE_HASHED_STRING_HPP
      3 
      4 
      5 #include <cstdint>
      6 
      7 
      8 namespace entt {
      9 
      10 
      20 class HashedString final {
      21  struct ConstCharWrapper final {
      22  // non-explicit constructor on purpose
      23  constexpr ConstCharWrapper(const char *str) noexcept: str{str} {}
      24  const char *str;
      25  };
      26 
      27  static constexpr std::uint64_t offset = 14695981039346656037ull;
      28  static constexpr std::uint64_t prime = 1099511628211ull;
      29 
      30  // Fowler–Noll–Vo hash function v. 1a - the good
      31  static constexpr std::uint64_t helper(std::uint64_t partial, const char *str) noexcept {
      32  return str[0] == 0 ? partial : helper((partial^str[0])*prime, str+1);
      33  }
      34 
      35 public:
      37  using hash_type = std::uint64_t;
      38 
      53  template <std::size_t N>
      54  constexpr HashedString(const char (&str)[N]) noexcept
      55  : hash{helper(offset, str)}, str{str}
      56  {}
      57 
      64  explicit constexpr HashedString(ConstCharWrapper wrapper) noexcept
      65  : hash{helper(offset, wrapper.str)}, str{wrapper.str}
      66  {}
      67 
      72  constexpr operator const char *() const noexcept { return str; }
      73 
      78  constexpr operator hash_type() const noexcept { return hash; }
      79 
      85  constexpr bool operator==(const HashedString &other) const noexcept {
      86  return hash == other.hash;
      87  }
      88 
      89 private:
      90  const hash_type hash;
      91  const char *str;
      92 };
      93 
      94 
      101 constexpr bool operator!=(const HashedString &lhs, const HashedString &rhs) noexcept {
      102  return !(lhs == rhs);
      103 }
      104 
      105 
      106 }
      107 
      108 
      109 #endif // ENTT_CORE_HASHED_STRING_HPP
      entt::HashedString::HashedString
      constexpr HashedString(ConstCharWrapper wrapper) noexcept
      Explicit constructor on purpose to avoid constructing a hashed string directly from a const char *...
      Definition: hashed_string.hpp:64
      +
      1 #ifndef ENTT_CORE_HASHED_STRING_HPP
      2 #define ENTT_CORE_HASHED_STRING_HPP
      3 
      4 
      5 #include <cstddef>
      6 #include <cstdint>
      7 
      8 
      9 namespace entt {
      10 
      11 
      21 class HashedString final {
      22  struct ConstCharWrapper final {
      23  // non-explicit constructor on purpose
      24  constexpr ConstCharWrapper(const char *str) noexcept: str{str} {}
      25  const char *str;
      26  };
      27 
      28  static constexpr std::uint64_t offset = 14695981039346656037ull;
      29  static constexpr std::uint64_t prime = 1099511628211ull;
      30 
      31  // Fowler–Noll–Vo hash function v. 1a - the good
      32  static constexpr std::uint64_t helper(std::uint64_t partial, const char *str) noexcept {
      33  return str[0] == 0 ? partial : helper((partial^str[0])*prime, str+1);
      34  }
      35 
      36 public:
      38  using hash_type = std::uint64_t;
      39 
      54  template <std::size_t N>
      55  constexpr HashedString(const char (&str)[N]) noexcept
      56  : hash{helper(offset, str)}, str{str}
      57  {}
      58 
      65  explicit constexpr HashedString(ConstCharWrapper wrapper) noexcept
      66  : hash{helper(offset, wrapper.str)}, str{wrapper.str}
      67  {}
      68 
      73  constexpr operator const char *() const noexcept { return str; }
      74 
      79  constexpr operator hash_type() const noexcept { return hash; }
      80 
      86  constexpr bool operator==(const HashedString &other) const noexcept {
      87  return hash == other.hash;
      88  }
      89 
      90 private:
      91  const hash_type hash;
      92  const char *str;
      93 };
      94 
      95 
      102 constexpr bool operator!=(const HashedString &lhs, const HashedString &rhs) noexcept {
      103  return !(lhs == rhs);
      104 }
      105 
      106 
      107 }
      108 
      109 
      110 #endif // ENTT_CORE_HASHED_STRING_HPP
      entt::HashedString::HashedString
      constexpr HashedString(ConstCharWrapper wrapper) noexcept
      Explicit constructor on purpose to avoid constructing a hashed string directly from a const char *...
      Definition: hashed_string.hpp:65
      entt
      EnTT default namespace.
      Definition: family.hpp:9
      -
      entt::HashedString
      Zero overhead resource identifier.
      Definition: hashed_string.hpp:20
      -
      entt::HashedString::HashedString
      constexpr HashedString(const char(&str)[N]) noexcept
      Constructs a hashed string from an array of const chars.
      Definition: hashed_string.hpp:54
      -
      entt::HashedString::hash_type
      std::uint64_t hash_type
      Unsigned integer type.
      Definition: hashed_string.hpp:37
      -
      entt::operator!=
      constexpr bool operator!=(const HashedString &lhs, const HashedString &rhs) noexcept
      Compares two hashed strings.
      Definition: hashed_string.hpp:101
      -
      entt::HashedString::operator==
      constexpr bool operator==(const HashedString &other) const noexcept
      Compares two hashed strings.
      Definition: hashed_string.hpp:85
      +
      entt::HashedString
      Zero overhead resource identifier.
      Definition: hashed_string.hpp:21
      +
      entt::HashedString::HashedString
      constexpr HashedString(const char(&str)[N]) noexcept
      Constructs a hashed string from an array of const chars.
      Definition: hashed_string.hpp:55
      +
      entt::HashedString::hash_type
      std::uint64_t hash_type
      Unsigned integer type.
      Definition: hashed_string.hpp:38
      +
      entt::operator!=
      constexpr bool operator!=(const HashedString &lhs, const HashedString &rhs) noexcept
      Compares two hashed strings.
      Definition: hashed_string.hpp:102
      +
      entt::HashedString::operator==
      constexpr bool operator==(const HashedString &other) const noexcept
      Compares two hashed strings.
      Definition: hashed_string.hpp:86
      diff --git a/hierarchy.html b/hierarchy.html index a015e11fc..758c9ffd0 100644 --- a/hierarchy.html +++ b/hierarchy.html @@ -22,7 +22,7 @@
      entt -  2.4.1 +  2.4.2
      diff --git a/ident_8hpp_source.html b/ident_8hpp_source.html index bf0f7d0b2..dae3bf459 100644 --- a/ident_8hpp_source.html +++ b/ident_8hpp_source.html @@ -22,7 +22,7 @@
      entt -  2.4.1 +  2.4.2
      diff --git a/index.html b/index.html index cfec9941f..6129d3941 100644 --- a/index.html +++ b/index.html @@ -22,7 +22,7 @@
      entt -  2.4.1 +  2.4.2
      @@ -234,9 +234,9 @@ The Registry, the Entity and the Component In case entity identifiers are stored around, the registry offers all the functionalities required to test them and get out of the them all the information they carry:

      // returns true if the entity is still valid, false otherwise
      bool b = registry.valid(entity);
      // gets the version contained in the entity identifier
      auto version = registry.version(entity);
      // gets the actual version for the given entity
      auto curr = registry.current(entity);

      Components can be assigned to or removed from entities at any time with a few calls to member functions of the registry. As for the entities, the registry offers also a set of functionalities users can use to work with the components.

      The assign member function template creates, initializes and assigns to an entity the given component. It accepts a variable number of arguments that are used to construct the component itself if present:

      -
      registry.assign<Position>(entity, 0., 0.);
      // ...
      auto &velocity = registry.assign<Velocity>(entity);
      velocity.dx = 0.;
      velocity.dy = 0.;

      If the entity already has the given component, the replace member function template can be used to replace it:

      -
      registry.replace<Position>(entity, 0., 0.);
      // ...
      auto &velocity = registry.replace<Velocity>(entity);
      velocity.dx = 0.;
      velocity.dy = 0.;

      In case users want to assign a component to an entity, but it's unknown whether the entity already has it or not, accomodate does the work in a single call (there is a performance penalty to pay for this mainly due to the fact that it has to check if entity already has the given component or not):

      -
      registry.accomodate<Position>(entity, 0., 0.);
      // ...
      auto &velocity = registry.accomodate<Velocity>(entity);
      velocity.dx = 0.;
      velocity.dy = 0.;

      Note that accomodate is a sliglhty faster alternative for the following if/else statement and nothing more:

      +
      registry.assign<Position>(entity, 0., 0.);
      // ...
      Velocity &velocity = registry.assign<Velocity>(entity);
      velocity.dx = 0.;
      velocity.dy = 0.;

      If the entity already has the given component, the replace member function template can be used to replace it:

      +
      registry.replace<Position>(entity, 0., 0.);
      // ...
      Velocity &velocity = registry.replace<Velocity>(entity);
      velocity.dx = 0.;
      velocity.dy = 0.;

      In case users want to assign a component to an entity, but it's unknown whether the entity already has it or not, accomodate does the work in a single call (there is a performance penalty to pay for this mainly due to the fact that it has to check if entity already has the given component or not):

      +
      registry.accomodate<Position>(entity, 0., 0.);
      // ...
      Velocity &velocity = registry.accomodate<Velocity>(entity);
      velocity.dx = 0.;
      velocity.dy = 0.;

      Note that accomodate is a sliglhty faster alternative for the following if/else statement and nothing more:

      if(registry.has<Comp>(entity)) {
      registry.replace<Comp>(entity, arg1, argN);
      } else {
      registry.assign<Comp>(entity, arg1, argN);
      }

      As already shown, if in doubt about whether or not an entity has one or more components, the has member function template may be useful:

      bool b = registry.has<Position, Velocity>(entity);

      On the other side, if the goal is to delete a single component, the remove member function template is the way to go when it's certain that the entity owns a copy of the component:

      registry.remove<Position>(entity);

      Otherwise consider to use the reset member function. It behaves similarly to remove but with a strictly defined behaviour (and a performance penalty is the price to pay for this). In particular it removes the component if and only if it exists, otherwise it returns safely to the caller:

      @@ -248,7 +248,7 @@ The Registry, the Entity and the Component
    • If neither the entity nor the component are specified, all the entities and their components are destroyed:
    registry.reset();

    Finally, references to components can be retrieved simply by doing this:

    -
    // either a non-const reference ...
    entt::DefaultRegistry registry;
    auto &position = registry.get<Position>(entity);
    // ... or a const one
    const auto &cregistry = registry;
    const auto &position = cregistry.get<Position>(entity);

    The get member function template gives direct access to the component of an entity stored in the underlying data structures of the registry.

    +
    entt::DefaultRegistry registry;
    const auto &cregistry = registry;
    // const and non-const reference
    const Position &position = cregistry.get<Position>(entity);
    Position &position = registry.get<Position>(entity);
    // const and non-const references
    std::tuple<const Position &, const Velocity &> tup = cregistry.get<Position, Velocity>(entity);
    std::tuple<Position &, Velocity &> tup = registry.get<Position, Velocity>(entity);

    The get member function template gives direct access to the component of an entity stored in the underlying data structures of the registry.

    Single instance components

    In those cases where all what is needed is a single instance component, tags are the right tool to achieve the purpose.
    @@ -257,7 +257,7 @@ Single instance components

    Attaching tags to entities and removing them is trivial:

    auto player = registry.create();
    auto camera = registry.create();
    // attaches a default-initialized tag to an entity
    registry.attach<PlayingCharacter>(player);
    // attaches a tag to an entity and initializes it
    registry.attach<Camera>(camera, player);
    // removes tags from their owners
    registry.remove<PlayingCharacter>();
    registry.remove<Camera>();

    If in doubt about whether or not a tag has already an owner, the has member function template may be useful:

    bool b = registry.has<PlayingCharacter>();

    References to tags can be retrieved simply by doing this:

    -
    // either a non-const reference ...
    entt::DefaultRegistry registry;
    auto &player = registry.get<PlayingCharacter>();
    // ... or a const one
    const auto &cregistry = registry;
    const auto &camera = cregistry.get<Camera>();

    The get member function template gives direct access to the tag as stored in the underlying data structures of the registry.

    +
    // either a non-const reference ...
    entt::DefaultRegistry registry;
    PlayingCharacter &player = registry.get<PlayingCharacter>();
    // ... or a const one
    const auto &cregistry = registry;
    const Camera &camera = cregistry.get<Camera>();

    The get member function template gives direct access to the tag as stored in the underlying data structures of the registry.

    As shown above, in almost all the cases the entity identifier isn't required, since a single instance component can have only one associated entity and therefore it doesn't make much sense to mention it explicitly.
    To find out who the owner is, just do the following:

    auto player = registry.attachee<PlayingCharacter>();

    Note that iterating tags isn't possible for obvious reasons. Tags give direct access to single entities and nothing more.

    @@ -337,7 +337,7 @@ Single component standard view Refer to the official documentation for all the details.

    There is no need to store views around for they are extremely cheap to construct, even though they can be copied without problems and reused freely. In fact, they return newly created and correctly initialized iterators whenever begin or end are invoked.
    To iterate a single component standard view, either use it in range-for loop:

    -
    auto view = registry.view<Renderable>();
    for(auto entity: view) {
    auto &renderable = view.get(entity);
    // ...
    }

    Or rely on the each member function to iterate entities and get all their components at once:

    +
    auto view = registry.view<Renderable>();
    for(auto entity: view) {
    Renderable &renderable = view.get(entity);
    // ...
    }

    Or rely on the each member function to iterate entities and get all their components at once:

    registry.view<Renderable>().each([](auto entity, auto &renderable) {
    // ...
    });

    Performance are more or less the same. The best approach depends mainly on whether all the components have to be accessed or not.

    Note: prefer the get member function of a view instead of the get member function template of a registry during iterations, if possible. However, keep in mind that it works only with the components of the view itself.

    @@ -347,7 +347,7 @@ Multi component standard view

    Refer to the official documentation for all the details.

    There is no need to store views around for they are extremely cheap to construct, even though they can be copied without problems and reused freely. In fact, they return newly created and correctly initialized iterators whenever begin or end are invoked.
    To iterate a multi component standard view, either use it in range-for loop:

    -
    auto view = registry.view<Position, Velocity>();
    for(auto entity: view) {
    auto &position = view.get<Position>(entity);
    auto &velocity = view.get<Velocity>(entity);
    // ...
    }

    Or rely on the each member function to iterate entities and get all their components at once:

    +
    auto view = registry.view<Position, Velocity>();
    for(auto entity: view) {
    // a component at a time ...
    Position &position = view.get<Position>(entity);
    Velocity &velocity = view.get<Velocity>(entity);
    // ... or multiple components at once
    std::tuple<Position &, Velocity &> tup = view.get<Position, Velocity>(entity);
    // ...
    }

    Or rely on the each member function to iterate entities and get all their components at once:

    registry.view<Position, Velocity>().each([](auto entity, auto &position, auto &velocity) {
    // ...
    });

    Performance are more or less the same. The best approach depends mainly on whether all the components have to be accessed or not.

    Note: prefer the get member function of a view instead of the get member function template of a registry during iterations, if possible. However, keep in mind that it works only with the components of the view itself.

    @@ -361,7 +361,7 @@ Persistent View

    A persistent view offers a bunch of functionalities to get the number of entities it's going to return, a raw access to the entity list and the possibility to sort the underlying data structures according to the order of one of the components for which it has been constructed.
    Refer to the official documentation for all the details.

    To iterate a persistent view, either use it in range-for loop:

    -
    auto view = registry.persistent<Position, Velocity>();
    for(auto entity: view) {
    auto &position = view.get<Position>(entity);
    auto &velocity = view.get<Velocity>(entity);
    // ...
    }

    Or rely on the each member function to iterate entities and get all their components at once:

    +
    auto view = registry.persistent<Position, Velocity>();
    for(auto entity: view) {
    // a component at a time ...
    Position &position = view.get<Position>(entity);
    Velocity &velocity = view.get<Velocity>(entity);
    // ... or multiple components at once
    std::tuple<Position &, Velocity &> tup = view.get<Position, Velocity>(entity);
    // ...
    }

    Or rely on the each member function to iterate entities and get all their components at once:

    registry.persistent<Position, Velocity>().each([](auto entity, auto &position, auto &velocity) {
    // ...
    });

    Performance are more or less the same. The best approach depends mainly on whether all the components have to be accessed or not.

    Note: prefer the get member function of a view instead of the get member function template of a registry during iterations, if possible. However, keep in mind that it works only with the components of the view itself.

    @@ -398,7 +398,7 @@ Contributors

    Check the contributors list to see who has partecipated so far.

    License

    -

    Code and documentation Copyright (c) 2017 Michele Caini.
    +

    Code and documentation Copyright (c) 2018 Michele Caini.
    Code released under the MIT license. Docs released under Creative Commons.

    Donation

    diff --git a/inherits.html b/inherits.html index 62178bec6..b16de2403 100644 --- a/inherits.html +++ b/inherits.html @@ -22,7 +22,7 @@
    entt -  2.4.1 +  2.4.2
    diff --git a/loader_8hpp_source.html b/loader_8hpp_source.html index 7cd3e660d..ee52f7b41 100644 --- a/loader_8hpp_source.html +++ b/loader_8hpp_source.html @@ -22,7 +22,7 @@
    entt -  2.4.1 +  2.4.2
    diff --git a/locator_8hpp_source.html b/locator_8hpp_source.html index 9bbfbace7..8b452fe95 100644 --- a/locator_8hpp_source.html +++ b/locator_8hpp_source.html @@ -22,7 +22,7 @@
    entt -  2.4.1 +  2.4.2
    diff --git a/namespaceentt.html b/namespaceentt.html index c45d365cc..5ae24153d 100644 --- a/namespaceentt.html +++ b/namespaceentt.html @@ -22,7 +22,7 @@
    entt -  2.4.1 +  2.4.2
    @@ -247,7 +247,7 @@ template<typename Delta > -

    Definition at line 146 of file actor.hpp.

    +

    Definition at line 148 of file actor.hpp.

    @@ -267,7 +267,7 @@ template<typename Delta >

    The default registry is the best choice for almost all the applications.
    Users should have a really good reason to choose something different.

    -

    Definition at line 1063 of file registry.hpp.

    +

    Definition at line 1105 of file registry.hpp.

    @@ -410,7 +410,7 @@ template<typename... Event>
    Returns
    True if the two hashed strings are identical, false otherwise.
    -

    Definition at line 101 of file hashed_string.hpp.

    +

    Definition at line 102 of file hashed_string.hpp.

    diff --git a/namespacemembers.html b/namespacemembers.html index 6a139477e..75c8d84f4 100644 --- a/namespacemembers.html +++ b/namespacemembers.html @@ -22,7 +22,7 @@
    entt -  2.4.1 +  2.4.2
    diff --git a/namespacemembers_func.html b/namespacemembers_func.html index f244bede4..ffa156119 100644 --- a/namespacemembers_func.html +++ b/namespacemembers_func.html @@ -22,7 +22,7 @@
    entt -  2.4.1 +  2.4.2
    diff --git a/namespacemembers_type.html b/namespacemembers_type.html index e19a01113..6b3503818 100644 --- a/namespacemembers_type.html +++ b/namespacemembers_type.html @@ -22,7 +22,7 @@
    entt -  2.4.1 +  2.4.2
    diff --git a/namespacemembers_vars.html b/namespacemembers_vars.html index 8f5ed06d2..c0f63d927 100644 --- a/namespacemembers_vars.html +++ b/namespacemembers_vars.html @@ -22,7 +22,7 @@
    entt -  2.4.1 +  2.4.2
    diff --git a/namespaces.html b/namespaces.html index ca8ec65cd..0ba8d693f 100644 --- a/namespaces.html +++ b/namespaces.html @@ -22,7 +22,7 @@
    entt -  2.4.1 +  2.4.2
    diff --git a/process_8hpp_source.html b/process_8hpp_source.html index 39e2eefd7..debe9ff07 100644 --- a/process_8hpp_source.html +++ b/process_8hpp_source.html @@ -22,7 +22,7 @@
    entt -  2.4.1 +  2.4.2
    diff --git a/registry_8hpp_source.html b/registry_8hpp_source.html index bae100532..e92432594 100644 --- a/registry_8hpp_source.html +++ b/registry_8hpp_source.html @@ -22,7 +22,7 @@
    entt -  2.4.1 +  2.4.2
    @@ -67,57 +67,57 @@ $(function() {
    registry.hpp
    -
    1 #ifndef ENTT_ENTITY_REGISTRY_HPP
    2 #define ENTT_ENTITY_REGISTRY_HPP
    3 
    4 
    5 #include <vector>
    6 #include <memory>
    7 #include <utility>
    8 #include <cstddef>
    9 #include <cstdint>
    10 #include <cassert>
    11 #include <algorithm>
    12 #include "../core/family.hpp"
    13 #include "sparse_set.hpp"
    14 #include "traits.hpp"
    15 #include "view.hpp"
    16 
    17 
    18 namespace entt {
    19 
    20 
    31 template<typename Entity>
    32 class Registry {
    33  using tag_family = Family<struct InternalRegistryTagFamily>;
    34  using component_family = Family<struct InternalRegistryComponentFamily>;
    35  using view_family = Family<struct InternalRegistryViewFamily>;
    36  using traits_type = entt_traits<Entity>;
    37 
    38  struct Attachee {
    39  Entity entity;
    40  };
    41 
    42  template<typename Tag>
    43  struct Attaching: Attachee {
    44  // requirements for aggregates are relaxed only since C++17
    45  template<typename... Args>
    46  Attaching(Entity entity, Tag tag)
    47  : Attachee{entity}, tag{std::move(tag)}
    48  {}
    49 
    50  Tag tag;
    51  };
    52 
    53  template<typename Component>
    54  struct Pool: SparseSet<Entity, Component> {
    55  using test_fn_type = bool(Registry::*)(Entity) const;
    56 
    57  template<typename... Args>
    58  Component & construct(Registry &registry, Entity entity, Args&&... args) {
    59  auto &component = SparseSet<Entity, Component>::construct(entity, std::forward<Args>(args)...);
    60 
    61  for(auto &&listener: listeners) {
    62  if((registry.*listener.second)(entity)) {
    63  listener.first->construct(entity);
    64  }
    65  }
    66 
    67  return component;
    68  }
    69 
    70  void destroy(Entity entity) override {
    71  SparseSet<Entity, Component>::destroy(entity);
    72 
    73  for(auto &&listener: listeners) {
    74  auto *handler = listener.first;
    75 
    76  if(handler->has(entity)) {
    77  handler->destroy(entity);
    78  }
    79  }
    80  }
    81 
    82  inline void append(SparseSet<Entity> *handler, test_fn_type fn) {
    83  listeners.emplace_back(handler, fn);
    84  }
    85 
    86  inline void remove(SparseSet<Entity> *handler) {
    87  listeners.erase(std::remove_if(listeners.begin(), listeners.end(), [handler](auto &listener) {
    88  return listener.first == handler;
    89  }), listeners.end());
    90  }
    91 
    92  private:
    93  std::vector<std::pair<SparseSet<Entity> *, test_fn_type>> listeners;
    94  };
    95 
    96  template<typename Component>
    97  bool managed() const noexcept {
    98  const auto ctype = component_family::type<Component>();
    99  return ctype < pools.size() && pools[ctype];
    100  }
    101 
    102  template<typename Component>
    103  const Pool<Component> & pool() const noexcept {
    104  assert(managed<Component>());
    105  return static_cast<Pool<Component> &>(*pools[component_family::type<Component>()]);
    106  }
    107 
    108  template<typename Component>
    109  Pool<Component> & pool() noexcept {
    110  return const_cast<Pool<Component> &>(const_cast<const Registry *>(this)->pool<Component>());
    111  }
    112 
    113  template<typename Component>
    114  Pool<Component> & ensure() {
    115  const auto ctype = component_family::type<Component>();
    116 
    117  if(!(ctype < pools.size())) {
    118  pools.resize(ctype + 1);
    119  }
    120 
    121  if(!pools[ctype]) {
    122  pools[ctype] = std::make_unique<Pool<Component>>();
    123  }
    124 
    125  return pool<Component>();
    126  }
    127 
    128  template<typename... Component>
    129  SparseSet<Entity> & handler() {
    130  static_assert(sizeof...(Component) > 1, "!");
    131  const auto vtype = view_family::type<Component...>();
    132 
    133  if(!(vtype < handlers.size())) {
    134  handlers.resize(vtype + 1);
    135  }
    136 
    137  if(!handlers[vtype]) {
    138  using accumulator_type = int[];
    139 
    140  auto set = std::make_unique<SparseSet<Entity>>();
    141 
    142  for(auto entity: view<Component...>()) {
    143  set->construct(entity);
    144  }
    145 
    146  accumulator_type accumulator = {
    147  (ensure<Component>().append(set.get(), &Registry::has<Component...>), 0)...
    148  };
    149 
    150  handlers[vtype] = std::move(set);
    151  (void)accumulator;
    152  }
    153 
    154  return *handlers[vtype];
    155  }
    156 
    157 public:
    159  using entity_type = typename traits_type::entity_type;
    161  using version_type = typename traits_type::version_type;
    163  using size_type = std::size_t;
    165  using tag_type = typename tag_family::family_type;
    167  using component_type = typename component_family::family_type;
    168 
    170  Registry() = default;
    171 
    173  Registry(const Registry &) = delete;
    175  Registry(Registry &&) = default;
    176 
    178  Registry & operator=(const Registry &) = delete;
    180  Registry & operator=(Registry &&) = default;
    181 
    194  template<typename Tag>
    195  tag_type tag() const noexcept {
    196  return tag_family::type<Tag>();
    197  }
    198 
    211  template<typename Component>
    212  component_type component() const noexcept {
    213  return component_family::type<Component>();
    214  }
    215 
    221  template<typename Component>
    222  size_type size() const noexcept {
    223  return managed<Component>() ? pool<Component>().size() : size_type{};
    224  }
    225 
    230  size_type size() const noexcept {
    231  return entities.size() - available.size();
    232  }
    233 
    243  template<typename Component>
    244  void reserve(size_type cap) {
    245  ensure<Component>().reserve(cap);
    246  }
    247 
    256  void reserve(size_type cap) {
    257  entities.reserve(cap);
    258  available.reserve(cap);
    259  }
    260 
    265  size_type capacity() const noexcept {
    266  return entities.size();
    267  }
    268 
    275  template<typename Component>
    276  bool empty() const noexcept {
    277  return managed<Component>() ? pool<Component>().empty() : true;
    278  }
    279 
    284  bool empty() const noexcept {
    285  return entities.size() == available.size();
    286  }
    287 
    293  bool valid(entity_type entity) const noexcept {
    294  using promotion_type = std::conditional_t<sizeof(size_type) >= sizeof(entity_type), size_type, entity_type>;
    295  // explicit promotion to avoid warnings with std::uint16_t
    296  const entity_type entt = promotion_type{entity} & traits_type::entity_mask;
    297  return (entt < entities.size() && entities[entt] == entity);
    298  }
    299 
    305  version_type version(entity_type entity) const noexcept {
    306  return version_type((entity >> traits_type::entity_shift) & traits_type::version_mask);
    307  }
    308 
    326  version_type current(entity_type entity) const noexcept {
    327  using promotion_type = std::conditional_t<sizeof(size_type) >= sizeof(entity_type), size_type, entity_type>;
    328  // explicit promotion to avoid warnings with std::uint16_t
    329  const auto entt = promotion_type{entity} & traits_type::entity_mask;
    330  assert(entt < entities.size());
    331  return version_type((entities[entt] >> traits_type::entity_shift) & traits_type::version_mask);
    332  }
    333 
    353  template<typename... Component>
    354  entity_type create(Component&&... components) noexcept {
    355  using accumulator_type = int[];
    356  const auto entity = create();
    357  accumulator_type accumulator = { 0, (ensure<Component>().construct(*this, entity, std::forward<Component>(components)), 0)... };
    358  (void)accumulator;
    359  return entity;
    360  }
    361 
    380  template<typename... Component>
    381  entity_type create() noexcept {
    382  using accumulator_type = int[];
    383  const auto entity = create();
    384  accumulator_type accumulator = { 0, (ensure<Component>().construct(*this, entity), 0)... };
    385  (void)accumulator;
    386  return entity;
    387  }
    388 
    406  entity_type create() noexcept {
    407  entity_type entity;
    408 
    409  if(available.empty()) {
    410  entity = entity_type(entities.size());
    411  assert(entity < traits_type::entity_mask);
    412  assert((entity >> traits_type::entity_shift) == entity_type{});
    413  entities.push_back(entity);
    414  } else {
    415  entity = available.back();
    416  available.pop_back();
    417  }
    418 
    419  return entity;
    420  }
    421 
    437  void destroy(entity_type entity) {
    438  assert(valid(entity));
    439  const auto entt = entity & traits_type::entity_mask;
    440  const auto version = version_type{1} + ((entity >> traits_type::entity_shift) & traits_type::version_mask);
    441  const auto next = entt | (version << traits_type::entity_shift);
    442 
    443  entities[entt] = next;
    444  available.push_back(next);
    445 
    446  for(auto &&cpool: pools) {
    447  if(cpool && cpool->has(entity)) {
    448  cpool->destroy(entity);
    449  }
    450  }
    451  }
    452 
    474  template<typename Tag, typename... Args>
    475  Tag & attach(entity_type entity, Args&&... args) {
    476  assert(valid(entity));
    477  assert(!has<Tag>());
    478  const auto ttype = tag_family::type<Tag>();
    479 
    480  if(!(ttype < tags.size())) {
    481  tags.resize(ttype + 1);
    482  }
    483 
    484  tags[ttype].reset(new Attaching<Tag>{entity, { std::forward<Args>(args)... }});
    485 
    486  return static_cast<Attaching<Tag> *>(tags[ttype].get())->tag;
    487  }
    488 
    493  template<typename Tag>
    494  void remove() {
    495  if(has<Tag>()) {
    496  tags[tag_family::type<Tag>()].reset();
    497  }
    498  }
    499 
    505  template<typename Tag>
    506  bool has() const noexcept {
    507  const auto ttype = tag_family::type<Tag>();
    508  return (ttype < tags.size() &&
    509  // it's a valid tag
    510  tags[ttype] &&
    511  // the associated entity hasn't been destroyed in the meantime
    512  tags[ttype]->entity == (entities[tags[ttype]->entity & traits_type::entity_mask]));
    513  }
    514 
    527  template<typename Tag>
    528  const Tag & get() const noexcept {
    529  assert(has<Tag>());
    530  return static_cast<Attaching<Tag> *>(tags[tag_family::type<Tag>()].get())->tag;
    531  }
    532 
    545  template<typename Tag>
    546  Tag & get() noexcept {
    547  return const_cast<Tag &>(const_cast<const Registry *>(this)->get<Tag>());
    548  }
    549 
    562  template<typename Tag>
    563  entity_type attachee() const noexcept {
    564  assert(has<Tag>());
    565  return tags[tag_family::type<Tag>()]->entity;
    566  }
    567 
    588  template<typename Component, typename... Args>
    589  Component & assign(entity_type entity, Args&&... args) {
    590  assert(valid(entity));
    591  return ensure<Component>().construct(*this, entity, std::forward<Args>(args)...);
    592  }
    593 
    607  template<typename Component>
    608  void remove(entity_type entity) {
    609  assert(valid(entity));
    610  pool<Component>().destroy(entity);
    611  }
    612 
    625  template<typename... Component>
    626  bool has(entity_type entity) const noexcept {
    627  assert(valid(entity));
    628  using accumulator_type = bool[];
    629  bool all = true;
    630  accumulator_type accumulator = { all, (all = all && managed<Component>() && pool<Component>().has(entity))... };
    631  (void)accumulator;
    632  return all;
    633  }
    634 
    649  template<typename Component>
    650  const Component & get(entity_type entity) const noexcept {
    651  assert(valid(entity));
    652  return pool<Component>().get(entity);
    653  }
    654 
    669  template<typename Component>
    670  Component & get(entity_type entity) noexcept {
    671  return const_cast<Component &>(const_cast<const Registry *>(this)->get<Component>(entity));
    672  }
    673 
    694  template<typename Component, typename... Args>
    695  Component & replace(entity_type entity, Args&&... args) {
    696  assert(valid(entity));
    697  return (pool<Component>().get(entity) = Component{std::forward<Args>(args)...});
    698  }
    699 
    727  template<typename Component, typename... Args>
    728  Component & accomodate(entity_type entity, Args&&... args) {
    729  assert(valid(entity));
    730  auto &cpool = ensure<Component>();
    731 
    732  return (cpool.has(entity)
    733  ? (cpool.get(entity) = Component{std::forward<Args>(args)...})
    734  : cpool.construct(*this, entity, std::forward<Args>(args)...));
    735  }
    736 
    760  template<typename Component, typename Compare>
    761  void sort(Compare compare) {
    762  ensure<Component>().sort(std::move(compare));
    763  }
    764 
    795  template<typename To, typename From>
    796  void sort() {
    797  ensure<To>().respect(ensure<From>());
    798  }
    799 
    814  template<typename Component>
    815  void reset(entity_type entity) {
    816  assert(valid(entity));
    817 
    818  if(managed<Component>()) {
    819  auto &cpool = pool<Component>();
    820 
    821  if(cpool.has(entity)) {
    822  cpool.destroy(entity);
    823  }
    824  }
    825  }
    826 
    835  template<typename Component>
    836  void reset() {
    837  if(managed<Component>()) {
    838  auto &cpool = pool<Component>();
    839 
    840  for(auto entity: entities) {
    841  if(cpool.has(entity)) {
    842  cpool.destroy(entity);
    843  }
    844  }
    845  }
    846  }
    847 
    856  void reset() {
    857  available.clear();
    858 
    859  for(auto &&entity: entities) {
    860  const auto version = version_type{1} + ((entity >> traits_type::entity_shift) & traits_type::version_mask);
    861  entity = (entity & traits_type::entity_mask) | (version << traits_type::entity_shift);
    862  available.push_back(entity);
    863  }
    864 
    865  for(auto &&handler: handlers) {
    866  if(handler) {
    867  handler->reset();
    868  }
    869  }
    870 
    871  for(auto &&pool: pools) {
    872  if(pool) {
    873  pool->reset();
    874  }
    875  }
    876 
    877  for(auto &&tag: tags) {
    878  tag.reset();
    879  }
    880  }
    881 
    900  template<typename Func>
    901  void each(Func func) const {
    902  for(auto pos = entities.size(); pos > size_type{0}; --pos) {
    903  func(entities[pos-1]);
    904  }
    905  }
    906 
    939  template<typename... Component>
    940  View<Entity, Component...> view() {
    941  return View<Entity, Component...>{ensure<Component>()...};
    942  }
    943 
    960  template<typename... Component>
    961  void prepare() {
    962  handler<Component...>();
    963  }
    964 
    980  template<typename... Component>
    981  void discard() {
    982  if(contains<Component...>()) {
    983  using accumulator_type = int[];
    984  const auto vtype = view_family::type<Component...>();
    985  auto *set = handlers[vtype].get();
    986  // if a set exists, pools have already been created for it
    987  accumulator_type accumulator = { (pool<Component>().remove(set), 0)... };
    988  handlers[vtype].reset();
    989  (void)accumulator;
    990  }
    991  }
    992 
    998  template<typename... Component>
    999  bool contains() const noexcept {
    1000  static_assert(sizeof...(Component) > 1, "!");
    1001  const auto vtype = view_family::type<Component...>();
    1002  return vtype < handlers.size() && handlers[vtype];
    1003  }
    1004 
    1042  template<typename... Component>
    1043  PersistentView<Entity, Component...> persistent() {
    1044  // after the calls to handler, pools have already been created
    1045  return PersistentView<Entity, Component...>{handler<Component...>(), pool<Component>()...};
    1046  }
    1047 
    1048 private:
    1049  std::vector<std::unique_ptr<SparseSet<Entity>>> handlers;
    1050  std::vector<std::unique_ptr<SparseSet<Entity>>> pools;
    1051  std::vector<std::unique_ptr<Attachee>> tags;
    1052  std::vector<entity_type> available;
    1053  std::vector<entity_type> entities;
    1054 };
    1055 
    1056 
    1063 using DefaultRegistry = Registry<std::uint32_t>;
    1064 
    1065 
    1066 }
    1067 
    1068 
    1069 #endif // ENTT_ENTITY_REGISTRY_HPP
    entt::Registry::each
    void each(Func func) const
    Iterate entities and applies them the given function object.
    Definition: registry.hpp:901
    -
    entt::Registry::discard
    void discard()
    Discards all the data structures used for a given persitent view.
    Definition: registry.hpp:981
    -
    entt::Registry::persistent
    PersistentView< Entity, Component... > persistent()
    Returns a persistent view for the given components.
    Definition: registry.hpp:1043
    -
    entt::Registry::assign
    Component & assign(entity_type entity, Args &&... args)
    Assigns the given component to an entity.
    Definition: registry.hpp:589
    -
    entt::Registry::reset
    void reset()
    Resets the pool of the given component.
    Definition: registry.hpp:836
    -
    entt::Registry
    Fast and reliable entity-component system.
    Definition: registry.hpp:32
    -
    entt::Registry::sort
    void sort(Compare compare)
    Sorts the pool of entities for the given component.
    Definition: registry.hpp:761
    -
    entt::Registry::replace
    Component & replace(entity_type entity, Args &&... args)
    Replaces the given component for an entity.
    Definition: registry.hpp:695
    -
    entt::Registry::size
    size_type size() const noexcept
    Returns the number of existing components of the given type.
    Definition: registry.hpp:222
    -
    entt::Registry::prepare
    void prepare()
    Prepares the internal data structures used by persistent views.
    Definition: registry.hpp:961
    +
    1 #ifndef ENTT_ENTITY_REGISTRY_HPP
    2 #define ENTT_ENTITY_REGISTRY_HPP
    3 
    4 
    5 #include <tuple>
    6 #include <vector>
    7 #include <memory>
    8 #include <utility>
    9 #include <cstddef>
    10 #include <cstdint>
    11 #include <cassert>
    12 #include <algorithm>
    13 #include <type_traits>
    14 #include "../core/family.hpp"
    15 #include "entt_traits.hpp"
    16 #include "sparse_set.hpp"
    17 #include "view.hpp"
    18 
    19 
    20 namespace entt {
    21 
    22 
    33 template<typename Entity>
    34 class Registry {
    35  using tag_family = Family<struct InternalRegistryTagFamily>;
    36  using component_family = Family<struct InternalRegistryComponentFamily>;
    37  using view_family = Family<struct InternalRegistryViewFamily>;
    38  using traits_type = entt_traits<Entity>;
    39 
    40  struct Attachee {
    41  Entity entity;
    42  };
    43 
    44  template<typename Tag>
    45  struct Attaching: Attachee {
    46  // requirements for aggregates are relaxed only since C++17
    47  template<typename... Args>
    48  Attaching(Entity entity, Tag tag)
    49  : Attachee{entity}, tag{std::move(tag)}
    50  {}
    51 
    52  Tag tag;
    53  };
    54 
    55  template<typename Component>
    56  struct Pool: SparseSet<Entity, Component> {
    57  using test_fn_type = bool(Registry::*)(Entity) const;
    58 
    59  template<typename... Args>
    60  Component & construct(Registry &registry, Entity entity, Args&&... args) {
    61  auto &component = SparseSet<Entity, Component>::construct(entity, std::forward<Args>(args)...);
    62 
    63  for(auto &&listener: listeners) {
    64  if((registry.*listener.second)(entity)) {
    65  listener.first->construct(entity);
    66  }
    67  }
    68 
    69  return component;
    70  }
    71 
    72  void destroy(Entity entity) override {
    73  SparseSet<Entity, Component>::destroy(entity);
    74 
    75  for(auto &&listener: listeners) {
    76  auto *handler = listener.first;
    77 
    78  if(handler->has(entity)) {
    79  handler->destroy(entity);
    80  }
    81  }
    82  }
    83 
    84  inline void append(SparseSet<Entity> *handler, test_fn_type fn) {
    85  listeners.emplace_back(handler, fn);
    86  }
    87 
    88  inline void remove(SparseSet<Entity> *handler) {
    89  listeners.erase(std::remove_if(listeners.begin(), listeners.end(), [handler](auto &listener) {
    90  return listener.first == handler;
    91  }), listeners.end());
    92  }
    93 
    94  private:
    95  std::vector<std::pair<SparseSet<Entity> *, test_fn_type>> listeners;
    96  };
    97 
    98  template<typename Component>
    99  bool managed() const noexcept {
    100  const auto ctype = component_family::type<Component>();
    101  return ctype < pools.size() && pools[ctype];
    102  }
    103 
    104  template<typename Component>
    105  const Pool<Component> & pool() const noexcept {
    106  assert(managed<Component>());
    107  return static_cast<Pool<Component> &>(*pools[component_family::type<Component>()]);
    108  }
    109 
    110  template<typename Component>
    111  Pool<Component> & pool() noexcept {
    112  return const_cast<Pool<Component> &>(const_cast<const Registry *>(this)->pool<Component>());
    113  }
    114 
    115  template<typename Component>
    116  Pool<Component> & ensure() {
    117  const auto ctype = component_family::type<Component>();
    118 
    119  if(!(ctype < pools.size())) {
    120  pools.resize(ctype + 1);
    121  }
    122 
    123  if(!pools[ctype]) {
    124  pools[ctype] = std::make_unique<Pool<Component>>();
    125  }
    126 
    127  return pool<Component>();
    128  }
    129 
    130  template<typename... Component>
    131  SparseSet<Entity> & handler() {
    132  static_assert(sizeof...(Component) > 1, "!");
    133  const auto vtype = view_family::type<Component...>();
    134 
    135  if(!(vtype < handlers.size())) {
    136  handlers.resize(vtype + 1);
    137  }
    138 
    139  if(!handlers[vtype]) {
    140  using accumulator_type = int[];
    141 
    142  auto set = std::make_unique<SparseSet<Entity>>();
    143 
    144  for(auto entity: view<Component...>()) {
    145  set->construct(entity);
    146  }
    147 
    148  accumulator_type accumulator = {
    149  (ensure<Component>().append(set.get(), &Registry::has<Component...>), 0)...
    150  };
    151 
    152  handlers[vtype] = std::move(set);
    153  (void)accumulator;
    154  }
    155 
    156  return *handlers[vtype];
    157  }
    158 
    159 public:
    161  using entity_type = typename traits_type::entity_type;
    163  using version_type = typename traits_type::version_type;
    165  using size_type = std::size_t;
    167  using tag_type = typename tag_family::family_type;
    169  using component_type = typename component_family::family_type;
    170 
    172  Registry() = default;
    173 
    175  Registry(const Registry &) = delete;
    177  Registry(Registry &&) = default;
    178 
    180  Registry & operator=(const Registry &) = delete;
    182  Registry & operator=(Registry &&) = default;
    183 
    196  template<typename Tag>
    197  tag_type tag() const noexcept {
    198  return tag_family::type<Tag>();
    199  }
    200 
    213  template<typename Component>
    214  component_type component() const noexcept {
    215  return component_family::type<Component>();
    216  }
    217 
    223  template<typename Component>
    224  size_type size() const noexcept {
    225  return managed<Component>() ? pool<Component>().size() : size_type{};
    226  }
    227 
    232  size_type size() const noexcept {
    233  return entities.size() - available.size();
    234  }
    235 
    245  template<typename Component>
    246  void reserve(size_type cap) {
    247  ensure<Component>().reserve(cap);
    248  }
    249 
    258  void reserve(size_type cap) {
    259  entities.reserve(cap);
    260  available.reserve(cap);
    261  }
    262 
    267  size_type capacity() const noexcept {
    268  return entities.size();
    269  }
    270 
    277  template<typename Component>
    278  bool empty() const noexcept {
    279  return managed<Component>() ? pool<Component>().empty() : true;
    280  }
    281 
    286  bool empty() const noexcept {
    287  return entities.size() == available.size();
    288  }
    289 
    295  bool valid(entity_type entity) const noexcept {
    296  using promotion_type = std::conditional_t<sizeof(size_type) >= sizeof(entity_type), size_type, entity_type>;
    297  // explicit promotion to avoid warnings with std::uint16_t
    298  const entity_type entt = promotion_type{entity} & traits_type::entity_mask;
    299  return (entt < entities.size() && entities[entt] == entity);
    300  }
    301 
    307  version_type version(entity_type entity) const noexcept {
    308  return version_type((entity >> traits_type::entity_shift) & traits_type::version_mask);
    309  }
    310 
    328  version_type current(entity_type entity) const noexcept {
    329  using promotion_type = std::conditional_t<sizeof(size_type) >= sizeof(entity_type), size_type, entity_type>;
    330  // explicit promotion to avoid warnings with std::uint16_t
    331  const auto entt = promotion_type{entity} & traits_type::entity_mask;
    332  assert(entt < entities.size());
    333  return version_type((entities[entt] >> traits_type::entity_shift) & traits_type::version_mask);
    334  }
    335 
    355  template<typename... Component>
    356  entity_type create(Component&&... components) noexcept {
    357  using accumulator_type = int[];
    358  const auto entity = create();
    359  accumulator_type accumulator = { 0, (ensure<Component>().construct(*this, entity, std::forward<Component>(components)), 0)... };
    360  (void)accumulator;
    361  return entity;
    362  }
    363 
    382  template<typename... Component>
    383  entity_type create() noexcept {
    384  using accumulator_type = int[];
    385  const auto entity = create();
    386  accumulator_type accumulator = { 0, (ensure<Component>().construct(*this, entity), 0)... };
    387  (void)accumulator;
    388  return entity;
    389  }
    390 
    408  entity_type create() noexcept {
    409  entity_type entity;
    410 
    411  if(available.empty()) {
    412  entity = entity_type(entities.size());
    413  assert(entity < traits_type::entity_mask);
    414  assert((entity >> traits_type::entity_shift) == entity_type{});
    415  entities.push_back(entity);
    416  } else {
    417  entity = available.back();
    418  available.pop_back();
    419  }
    420 
    421  return entity;
    422  }
    423 
    439  void destroy(entity_type entity) {
    440  assert(valid(entity));
    441  const auto entt = entity & traits_type::entity_mask;
    442  const auto version = version_type{1} + ((entity >> traits_type::entity_shift) & traits_type::version_mask);
    443  const auto next = entt | (version << traits_type::entity_shift);
    444 
    445  entities[entt] = next;
    446  available.push_back(next);
    447 
    448  for(auto &&cpool: pools) {
    449  if(cpool && cpool->has(entity)) {
    450  cpool->destroy(entity);
    451  }
    452  }
    453  }
    454 
    476  template<typename Tag, typename... Args>
    477  Tag & attach(entity_type entity, Args&&... args) {
    478  assert(valid(entity));
    479  assert(!has<Tag>());
    480  const auto ttype = tag_family::type<Tag>();
    481 
    482  if(!(ttype < tags.size())) {
    483  tags.resize(ttype + 1);
    484  }
    485 
    486  tags[ttype].reset(new Attaching<Tag>{entity, { std::forward<Args>(args)... }});
    487 
    488  return static_cast<Attaching<Tag> *>(tags[ttype].get())->tag;
    489  }
    490 
    495  template<typename Tag>
    496  void remove() {
    497  if(has<Tag>()) {
    498  tags[tag_family::type<Tag>()].reset();
    499  }
    500  }
    501 
    507  template<typename Tag>
    508  bool has() const noexcept {
    509  const auto ttype = tag_family::type<Tag>();
    510  return (ttype < tags.size() &&
    511  // it's a valid tag
    512  tags[ttype] &&
    513  // the associated entity hasn't been destroyed in the meantime
    514  tags[ttype]->entity == (entities[tags[ttype]->entity & traits_type::entity_mask]));
    515  }
    516 
    529  template<typename Tag>
    530  const Tag & get() const noexcept {
    531  assert(has<Tag>());
    532  return static_cast<Attaching<Tag> *>(tags[tag_family::type<Tag>()].get())->tag;
    533  }
    534 
    547  template<typename Tag>
    548  Tag & get() noexcept {
    549  return const_cast<Tag &>(const_cast<const Registry *>(this)->get<Tag>());
    550  }
    551 
    564  template<typename Tag>
    565  entity_type attachee() const noexcept {
    566  assert(has<Tag>());
    567  return tags[tag_family::type<Tag>()]->entity;
    568  }
    569 
    590  template<typename Component, typename... Args>
    591  Component & assign(entity_type entity, Args&&... args) {
    592  assert(valid(entity));
    593  return ensure<Component>().construct(*this, entity, std::forward<Args>(args)...);
    594  }
    595 
    609  template<typename Component>
    610  void remove(entity_type entity) {
    611  assert(valid(entity));
    612  pool<Component>().destroy(entity);
    613  }
    614 
    627  template<typename... Component>
    628  bool has(entity_type entity) const noexcept {
    629  assert(valid(entity));
    630  using accumulator_type = bool[];
    631  bool all = true;
    632  accumulator_type accumulator = { all, (all = all && managed<Component>() && pool<Component>().has(entity))... };
    633  (void)accumulator;
    634  return all;
    635  }
    636 
    651  template<typename Component>
    652  const Component & get(entity_type entity) const noexcept {
    653  assert(valid(entity));
    654  return pool<Component>().get(entity);
    655  }
    656 
    671  template<typename Component>
    672  Component & get(entity_type entity) noexcept {
    673  return const_cast<Component &>(const_cast<const Registry *>(this)->get<Component>(entity));
    674  }
    675 
    690  template<typename... Component>
    691  std::enable_if_t<(sizeof...(Component) > 1), std::tuple<const Component &...>>
    692  get(entity_type entity) const noexcept {
    693  return std::tuple<const Component &...>{ get<Component>(entity)... };
    694  }
    695 
    710  template<typename... Component>
    711  std::enable_if_t<(sizeof...(Component) > 1), std::tuple<Component &...>>
    712  get(entity_type entity) noexcept {
    713  return std::tuple<Component &...>{ get<Component>(entity)... };
    714  }
    715 
    736  template<typename Component, typename... Args>
    737  Component & replace(entity_type entity, Args&&... args) {
    738  assert(valid(entity));
    739  return (pool<Component>().get(entity) = Component{std::forward<Args>(args)...});
    740  }
    741 
    769  template<typename Component, typename... Args>
    770  Component & accomodate(entity_type entity, Args&&... args) {
    771  assert(valid(entity));
    772  auto &cpool = ensure<Component>();
    773 
    774  return (cpool.has(entity)
    775  ? (cpool.get(entity) = Component{std::forward<Args>(args)...})
    776  : cpool.construct(*this, entity, std::forward<Args>(args)...));
    777  }
    778 
    802  template<typename Component, typename Compare>
    803  void sort(Compare compare) {
    804  ensure<Component>().sort(std::move(compare));
    805  }
    806 
    837  template<typename To, typename From>
    838  void sort() {
    839  ensure<To>().respect(ensure<From>());
    840  }
    841 
    856  template<typename Component>
    857  void reset(entity_type entity) {
    858  assert(valid(entity));
    859 
    860  if(managed<Component>()) {
    861  auto &cpool = pool<Component>();
    862 
    863  if(cpool.has(entity)) {
    864  cpool.destroy(entity);
    865  }
    866  }
    867  }
    868 
    877  template<typename Component>
    878  void reset() {
    879  if(managed<Component>()) {
    880  auto &cpool = pool<Component>();
    881 
    882  for(auto entity: entities) {
    883  if(cpool.has(entity)) {
    884  cpool.destroy(entity);
    885  }
    886  }
    887  }
    888  }
    889 
    898  void reset() {
    899  available.clear();
    900 
    901  for(auto &&entity: entities) {
    902  const auto version = version_type{1} + ((entity >> traits_type::entity_shift) & traits_type::version_mask);
    903  entity = (entity & traits_type::entity_mask) | (version << traits_type::entity_shift);
    904  available.push_back(entity);
    905  }
    906 
    907  for(auto &&handler: handlers) {
    908  if(handler) {
    909  handler->reset();
    910  }
    911  }
    912 
    913  for(auto &&pool: pools) {
    914  if(pool) {
    915  pool->reset();
    916  }
    917  }
    918 
    919  for(auto &&tag: tags) {
    920  tag.reset();
    921  }
    922  }
    923 
    942  template<typename Func>
    943  void each(Func func) const {
    944  for(auto pos = entities.size(); pos > size_type{0}; --pos) {
    945  func(entities[pos-1]);
    946  }
    947  }
    948 
    981  template<typename... Component>
    982  View<Entity, Component...> view() {
    983  return View<Entity, Component...>{ensure<Component>()...};
    984  }
    985 
    1002  template<typename... Component>
    1003  void prepare() {
    1004  handler<Component...>();
    1005  }
    1006 
    1022  template<typename... Component>
    1023  void discard() {
    1024  if(contains<Component...>()) {
    1025  using accumulator_type = int[];
    1026  const auto vtype = view_family::type<Component...>();
    1027  auto *set = handlers[vtype].get();
    1028  // if a set exists, pools have already been created for it
    1029  accumulator_type accumulator = { (pool<Component>().remove(set), 0)... };
    1030  handlers[vtype].reset();
    1031  (void)accumulator;
    1032  }
    1033  }
    1034 
    1040  template<typename... Component>
    1041  bool contains() const noexcept {
    1042  static_assert(sizeof...(Component) > 1, "!");
    1043  const auto vtype = view_family::type<Component...>();
    1044  return vtype < handlers.size() && handlers[vtype];
    1045  }
    1046 
    1084  template<typename... Component>
    1085  PersistentView<Entity, Component...> persistent() {
    1086  // after the calls to handler, pools have already been created
    1087  return PersistentView<Entity, Component...>{handler<Component...>(), pool<Component>()...};
    1088  }
    1089 
    1090 private:
    1091  std::vector<std::unique_ptr<SparseSet<Entity>>> handlers;
    1092  std::vector<std::unique_ptr<SparseSet<Entity>>> pools;
    1093  std::vector<std::unique_ptr<Attachee>> tags;
    1094  std::vector<entity_type> available;
    1095  std::vector<entity_type> entities;
    1096 };
    1097 
    1098 
    1105 using DefaultRegistry = Registry<std::uint32_t>;
    1106 
    1107 
    1108 }
    1109 
    1110 
    1111 #endif // ENTT_ENTITY_REGISTRY_HPP
    entt::Registry::each
    void each(Func func) const
    Iterate entities and applies them the given function object.
    Definition: registry.hpp:943
    +
    entt::Registry::discard
    void discard()
    Discards all the data structures used for a given persitent view.
    Definition: registry.hpp:1023
    +
    entt::Registry::persistent
    PersistentView< Entity, Component... > persistent()
    Returns a persistent view for the given components.
    Definition: registry.hpp:1085
    +
    entt::Registry::assign
    Component & assign(entity_type entity, Args &&... args)
    Assigns the given component to an entity.
    Definition: registry.hpp:591
    +
    entt::Registry::reset
    void reset()
    Resets the pool of the given component.
    Definition: registry.hpp:878
    +
    entt::Registry
    Fast and reliable entity-component system.
    Definition: registry.hpp:34
    +
    entt::Registry::sort
    void sort(Compare compare)
    Sorts the pool of entities for the given component.
    Definition: registry.hpp:803
    +
    entt::Registry::replace
    Component & replace(entity_type entity, Args &&... args)
    Replaces the given component for an entity.
    Definition: registry.hpp:737
    +
    entt::Registry::size
    size_type size() const noexcept
    Returns the number of existing components of the given type.
    Definition: registry.hpp:224
    +
    entt::Registry::prepare
    void prepare()
    Prepares the internal data structures used by persistent views.
    Definition: registry.hpp:1003
    entt
    EnTT default namespace.
    Definition: family.hpp:9
    -
    entt::Registry::attachee
    entity_type attachee() const noexcept
    Gets the owner of a tag, if any.
    Definition: registry.hpp:563
    -
    entt::Registry::valid
    bool valid(entity_type entity) const noexcept
    Verifies if an entity identifier still refers to a valid entity.
    Definition: registry.hpp:293
    -
    entt::Registry::has
    bool has(entity_type entity) const noexcept
    Checks if an entity has all the given components.
    Definition: registry.hpp:626
    -
    entt::Registry::reserve
    void reserve(size_type cap)
    Increases the capacity of a registry in terms of entities.
    Definition: registry.hpp:256
    +
    entt::Registry::attachee
    entity_type attachee() const noexcept
    Gets the owner of a tag, if any.
    Definition: registry.hpp:565
    +
    entt::Registry::valid
    bool valid(entity_type entity) const noexcept
    Verifies if an entity identifier still refers to a valid entity.
    Definition: registry.hpp:295
    +
    entt::Registry::has
    bool has(entity_type entity) const noexcept
    Checks if an entity has all the given components.
    Definition: registry.hpp:628
    +
    entt::Registry::reserve
    void reserve(size_type cap)
    Increases the capacity of a registry in terms of entities.
    Definition: registry.hpp:258
    entt::Registry::Registry
    Registry()=default
    Default constructor.
    -
    entt::Registry::reserve
    void reserve(size_type cap)
    Increases the capacity of the pool for a given component.
    Definition: registry.hpp:244
    +
    entt::Registry::reserve
    void reserve(size_type cap)
    Increases the capacity of the pool for a given component.
    Definition: registry.hpp:246
    entt::SparseSet
    Sparse set.
    Definition: sparse_set.hpp:25
    -
    entt::Registry::create
    entity_type create() noexcept
    Returns a new entity to which the given components are assigned.
    Definition: registry.hpp:381
    +
    entt::Registry::create
    entity_type create() noexcept
    Returns a new entity to which the given components are assigned.
    Definition: registry.hpp:383
    entt::Family::type
    static family_type type() noexcept
    Returns an unique identifier for the given type.
    Definition: family.hpp:41
    -
    entt::Registry::tag
    tag_type tag() const noexcept
    Returns the numeric identifier of a type of tag at runtime.
    Definition: registry.hpp:195
    -
    entt::Registry::current
    version_type current(entity_type entity) const noexcept
    Returns the actual version for an entity identifier.
    Definition: registry.hpp:326
    -
    entt::Registry::has
    bool has() const noexcept
    Checks if a tag has an owner.
    Definition: registry.hpp:506
    -
    entt::Registry::version_type
    typename traits_type::version_type version_type
    Underlying version type.
    Definition: registry.hpp:161
    -
    entt::Registry::reset
    void reset(entity_type entity)
    Resets the given component for an entity.
    Definition: registry.hpp:815
    -
    entt::Registry::reset
    void reset()
    Resets a whole registry.
    Definition: registry.hpp:856
    -
    entt::Registry::create
    entity_type create(Component &&... components) noexcept
    Returns a new entity initialized with the given components.
    Definition: registry.hpp:354
    +
    entt::Registry::tag
    tag_type tag() const noexcept
    Returns the numeric identifier of a type of tag at runtime.
    Definition: registry.hpp:197
    +
    entt::Registry::current
    version_type current(entity_type entity) const noexcept
    Returns the actual version for an entity identifier.
    Definition: registry.hpp:328
    +
    entt::Registry::has
    bool has() const noexcept
    Checks if a tag has an owner.
    Definition: registry.hpp:508
    +
    entt::Registry::version_type
    typename traits_type::version_type version_type
    Underlying version type.
    Definition: registry.hpp:163
    +
    entt::Registry::reset
    void reset(entity_type entity)
    Resets the given component for an entity.
    Definition: registry.hpp:857
    +
    entt::Registry::reset
    void reset()
    Resets a whole registry.
    Definition: registry.hpp:898
    +
    entt::Registry::create
    entity_type create(Component &&... components) noexcept
    Returns a new entity initialized with the given components.
    Definition: registry.hpp:356
    entt::SparseSet< Entity >
    Basic sparse set implementation.
    Definition: sparse_set.hpp:56
    -
    entt::Registry::empty
    bool empty() const noexcept
    Checks whether the pool for the given component is empty.
    Definition: registry.hpp:276
    -
    entt::Registry::component
    component_type component() const noexcept
    Returns the numeric identifier of a type of component at runtime.
    Definition: registry.hpp:212
    -
    entt::Registry::view
    View< Entity, Component... > view()
    Returns a standard view for the given components.
    Definition: registry.hpp:940
    +
    entt::Registry::empty
    bool empty() const noexcept
    Checks whether the pool for the given component is empty.
    Definition: registry.hpp:278
    +
    entt::Registry::component
    component_type component() const noexcept
    Returns the numeric identifier of a type of component at runtime.
    Definition: registry.hpp:214
    +
    entt::Registry::view
    View< Entity, Component... > view()
    Returns a standard view for the given components.
    Definition: registry.hpp:982
    entt::Registry::operator=
    Registry & operator=(const Registry &)=delete
    Copying a registry isn&#39;t allowed.
    -
    entt::Registry::size_type
    std::size_t size_type
    Unsigned integer type.
    Definition: registry.hpp:163
    -
    entt::Registry::sort
    void sort()
    Sorts two pools of components in the same way.
    Definition: registry.hpp:796
    -
    entt::Registry::component_type
    typename component_family::family_type component_type
    Unsigned integer type.
    Definition: registry.hpp:167
    -
    entt::Registry::destroy
    void destroy(entity_type entity)
    Destroys an entity and lets the registry recycle the identifier.
    Definition: registry.hpp:437
    -
    entt::Registry::entity_type
    typename traits_type::entity_type entity_type
    Underlying entity identifier.
    Definition: registry.hpp:159
    -
    entt::Registry::version
    version_type version(entity_type entity) const noexcept
    Returns the version stored along with an entity identifier.
    Definition: registry.hpp:305
    -
    entt::View
    Multi component view.
    Definition: view.hpp:301
    -
    entt::PersistentView
    Persistent view.
    Definition: view.hpp:54
    -
    entt::Registry::empty
    bool empty() const noexcept
    Checks if there exists at least an entity still in use.
    Definition: registry.hpp:284
    +
    entt::Registry::size_type
    std::size_t size_type
    Unsigned integer type.
    Definition: registry.hpp:165
    +
    entt::Registry::sort
    void sort()
    Sorts two pools of components in the same way.
    Definition: registry.hpp:838
    +
    entt::Registry::component_type
    typename component_family::family_type component_type
    Unsigned integer type.
    Definition: registry.hpp:169
    +
    entt::Registry::destroy
    void destroy(entity_type entity)
    Destroys an entity and lets the registry recycle the identifier.
    Definition: registry.hpp:439
    +
    entt::Registry::entity_type
    typename traits_type::entity_type entity_type
    Underlying entity identifier.
    Definition: registry.hpp:161
    +
    entt::Registry::version
    version_type version(entity_type entity) const noexcept
    Returns the version stored along with an entity identifier.
    Definition: registry.hpp:307
    +
    entt::View
    Multi component view.
    Definition: view.hpp:348
    +
    entt::PersistentView
    Persistent view.
    Definition: view.hpp:55
    +
    entt::Registry::empty
    bool empty() const noexcept
    Checks if there exists at least an entity still in use.
    Definition: registry.hpp:286
    entt::Family::family_type
    std::size_t family_type
    Unsigned integer type.
    Definition: family.hpp:34
    -
    entt::Registry::accomodate
    Component & accomodate(entity_type entity, Args &&... args)
    Assigns or replaces the given component for an entity.
    Definition: registry.hpp:728
    -
    entt::Registry::create
    entity_type create() noexcept
    Creates a new entity and returns it.
    Definition: registry.hpp:406
    -
    entt::Registry::capacity
    size_type capacity() const noexcept
    Returns the number of entities ever created.
    Definition: registry.hpp:265
    +
    entt::Registry::accomodate
    Component & accomodate(entity_type entity, Args &&... args)
    Assigns or replaces the given component for an entity.
    Definition: registry.hpp:770
    +
    entt::Registry::create
    entity_type create() noexcept
    Creates a new entity and returns it.
    Definition: registry.hpp:408
    +
    entt::Registry::capacity
    size_type capacity() const noexcept
    Returns the number of entities ever created.
    Definition: registry.hpp:267
    entt::Family
    Dynamic identifier generator.
    Definition: family.hpp:20
    -
    entt::Registry::size
    size_type size() const noexcept
    Returns the number of entities still in use.
    Definition: registry.hpp:230
    -
    entt::Registry::attach
    Tag & attach(entity_type entity, Args &&... args)
    Attaches a tag to an entity.
    Definition: registry.hpp:475
    -
    entt::Registry::tag_type
    typename tag_family::family_type tag_type
    Unsigned integer type.
    Definition: registry.hpp:165
    -
    entt::entt_traits
    Entity traits.
    Definition: traits.hpp:18
    -
    entt::Registry::contains
    bool contains() const noexcept
    Checks if a persistent view has already been prepared.
    Definition: registry.hpp:999
    +
    entt::Registry::size
    size_type size() const noexcept
    Returns the number of entities still in use.
    Definition: registry.hpp:232
    +
    entt::Registry::attach
    Tag & attach(entity_type entity, Args &&... args)
    Attaches a tag to an entity.
    Definition: registry.hpp:477
    +
    entt::Registry::tag_type
    typename tag_family::family_type tag_type
    Unsigned integer type.
    Definition: registry.hpp:167
    +
    entt::entt_traits
    Entity traits.
    Definition: entt_traits.hpp:18
    +
    entt::Registry::contains
    bool contains() const noexcept
    Checks if a persistent view has already been prepared.
    Definition: registry.hpp:1041
    diff --git a/scheduler_8hpp_source.html b/scheduler_8hpp_source.html index bef4c075c..fb290379f 100644 --- a/scheduler_8hpp_source.html +++ b/scheduler_8hpp_source.html @@ -22,7 +22,7 @@
    entt -  2.4.1 +  2.4.2
    diff --git a/search/all_11.js b/search/all_11.js index 41ef1fd08..b9b8f5205 100644 --- a/search/all_11.js +++ b/search/all_11.js @@ -3,7 +3,7 @@ var searchData= ['valid',['valid',['../classentt_1_1Registry.html#a11a759638bf2c28ac1670c7b533ca53f',1,'entt::Registry']]], ['version',['version',['../classentt_1_1Registry.html#a773c2bb361f4e83aae1349ccfeede56b',1,'entt::Registry']]], ['version_5fmask',['version_mask',['../structentt_1_1entt__traits_3_01std_1_1uint16__t_01_4.html#a78f400e87476e73bf4eb324ccb977682',1,'entt::entt_traits< std::uint16_t >::version_mask()'],['../structentt_1_1entt__traits_3_01std_1_1uint32__t_01_4.html#a6aa8692650455fe7b691a69b7621f9a1',1,'entt::entt_traits< std::uint32_t >::version_mask()'],['../structentt_1_1entt__traits_3_01std_1_1uint64__t_01_4.html#ab242af30841712877cd2d4042840551b',1,'entt::entt_traits< std::uint64_t >::version_mask()']]], - ['version_5ftype',['version_type',['../classentt_1_1Registry.html#a82c8996277034df5e72b5f30a70ebb2d',1,'entt::Registry::version_type()'],['../structentt_1_1entt__traits_3_01std_1_1uint16__t_01_4.html#ab37d10c3be3d59159a63c0bd1e9e2924',1,'entt::entt_traits< std::uint16_t >::version_type()'],['../structentt_1_1entt__traits_3_01std_1_1uint32__t_01_4.html#aee59dc7455ea0be015e699c3e46a22d1',1,'entt::entt_traits< std::uint32_t >::version_type()'],['../structentt_1_1entt__traits_3_01std_1_1uint64__t_01_4.html#aeac4d9172940a9dec0682860ac176725',1,'entt::entt_traits< std::uint64_t >::version_type()']]], - ['view',['View',['../classentt_1_1View.html',1,'entt::View< Entity, Component >'],['../classentt_1_1View.html#a8eb8d63c9db031af7203b5ca7801c7e3',1,'entt::View::View()'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a24c7693fd64b152591a1a63d46f8e91f',1,'entt::View< Entity, Component >::View()'],['../classentt_1_1Registry.html#aed83d4c8f80ae647ee73f2a8440fa09d',1,'entt::Registry::view()']]], + ['version_5ftype',['version_type',['../structentt_1_1entt__traits_3_01std_1_1uint16__t_01_4.html#ab37d10c3be3d59159a63c0bd1e9e2924',1,'entt::entt_traits< std::uint16_t >::version_type()'],['../structentt_1_1entt__traits_3_01std_1_1uint32__t_01_4.html#aee59dc7455ea0be015e699c3e46a22d1',1,'entt::entt_traits< std::uint32_t >::version_type()'],['../structentt_1_1entt__traits_3_01std_1_1uint64__t_01_4.html#aeac4d9172940a9dec0682860ac176725',1,'entt::entt_traits< std::uint64_t >::version_type()'],['../classentt_1_1Registry.html#a82c8996277034df5e72b5f30a70ebb2d',1,'entt::Registry::version_type()']]], + ['view',['View',['../classentt_1_1View.html',1,'entt::View< Entity, Component >'],['../classentt_1_1Registry.html#aed83d4c8f80ae647ee73f2a8440fa09d',1,'entt::Registry::view()'],['../classentt_1_1View.html#a8eb8d63c9db031af7203b5ca7801c7e3',1,'entt::View::View()'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a24c7693fd64b152591a1a63d46f8e91f',1,'entt::View< Entity, Component >::View()']]], ['view_3c_20entity_2c_20component_20_3e',['View< Entity, Component >',['../classentt_1_1View_3_01Entity_00_01Component_01_4.html',1,'entt']]] ]; diff --git a/search/all_4.js b/search/all_4.js index 860402ba7..97ed8d222 100644 --- a/search/all_4.js +++ b/search/all_4.js @@ -7,7 +7,7 @@ var searchData= ['enqueue',['enqueue',['../classentt_1_1Dispatcher.html#ac2ca8cabcdf32b7d017441edc1a937c5',1,'entt::Dispatcher']]], ['entity_5fmask',['entity_mask',['../structentt_1_1entt__traits_3_01std_1_1uint16__t_01_4.html#a8cbe9cd94ffc28ffb6e2302e9c3d9d93',1,'entt::entt_traits< std::uint16_t >::entity_mask()'],['../structentt_1_1entt__traits_3_01std_1_1uint32__t_01_4.html#ad5117f976c01a855164ab5b788f82af5',1,'entt::entt_traits< std::uint32_t >::entity_mask()'],['../structentt_1_1entt__traits_3_01std_1_1uint64__t_01_4.html#a4a9de15b5c7720c248a9cfee974a304f',1,'entt::entt_traits< std::uint64_t >::entity_mask()']]], ['entity_5fshift',['entity_shift',['../structentt_1_1entt__traits_3_01std_1_1uint16__t_01_4.html#aedc1e30160a37f69a5e6cc903a5113cc',1,'entt::entt_traits< std::uint16_t >::entity_shift()'],['../structentt_1_1entt__traits_3_01std_1_1uint32__t_01_4.html#ad2fb05bba66c9426a4c239222a191650',1,'entt::entt_traits< std::uint32_t >::entity_shift()'],['../structentt_1_1entt__traits_3_01std_1_1uint64__t_01_4.html#abbf9ff9ddaf2cb92eec8bd08dcc7d5a7',1,'entt::entt_traits< std::uint64_t >::entity_shift()']]], - ['entity_5ftype',['entity_type',['../classentt_1_1Registry.html#ad434a1920dd2c6a9a31ab482e2f29038',1,'entt::Registry::entity_type()'],['../classentt_1_1SparseSet_3_01Entity_01_4.html#a7d36e852257a965a9a0ed3fb636433e2',1,'entt::SparseSet< Entity >::entity_type()'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#afe382e2d5c8769fb3d924e1a357cf9b0',1,'entt::SparseSet< Entity, Type >::entity_type()'],['../structentt_1_1entt__traits_3_01std_1_1uint16__t_01_4.html#a86e202c8932f341626b29c194bd47489',1,'entt::entt_traits< std::uint16_t >::entity_type()'],['../structentt_1_1entt__traits_3_01std_1_1uint32__t_01_4.html#aecde3ac9bfc28e7f0f880a74ee2c5d8f',1,'entt::entt_traits< std::uint32_t >::entity_type()'],['../structentt_1_1entt__traits_3_01std_1_1uint64__t_01_4.html#a304eb4dc4a1487cf2966d902214f7185',1,'entt::entt_traits< std::uint64_t >::entity_type()'],['../classentt_1_1PersistentView.html#a5195c9d1dede0fe6c40bea576398022b',1,'entt::PersistentView::entity_type()'],['../classentt_1_1View.html#ad167f4bc8202231d768a7b18218bae5b',1,'entt::View::entity_type()'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a75fc64bf381a3003d8acf03ed66728f2',1,'entt::View< Entity, Component >::entity_type()']]], + ['entity_5ftype',['entity_type',['../structentt_1_1Actor.html#a592fca2df475cf3b98bc691648832666',1,'entt::Actor::entity_type()'],['../structentt_1_1entt__traits_3_01std_1_1uint16__t_01_4.html#a86e202c8932f341626b29c194bd47489',1,'entt::entt_traits< std::uint16_t >::entity_type()'],['../structentt_1_1entt__traits_3_01std_1_1uint32__t_01_4.html#aecde3ac9bfc28e7f0f880a74ee2c5d8f',1,'entt::entt_traits< std::uint32_t >::entity_type()'],['../structentt_1_1entt__traits_3_01std_1_1uint64__t_01_4.html#a304eb4dc4a1487cf2966d902214f7185',1,'entt::entt_traits< std::uint64_t >::entity_type()'],['../classentt_1_1Registry.html#ad434a1920dd2c6a9a31ab482e2f29038',1,'entt::Registry::entity_type()'],['../classentt_1_1SparseSet_3_01Entity_01_4.html#a7d36e852257a965a9a0ed3fb636433e2',1,'entt::SparseSet< Entity >::entity_type()'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#afe382e2d5c8769fb3d924e1a357cf9b0',1,'entt::SparseSet< Entity, Type >::entity_type()'],['../classentt_1_1PersistentView.html#a5195c9d1dede0fe6c40bea576398022b',1,'entt::PersistentView::entity_type()'],['../classentt_1_1View.html#ad167f4bc8202231d768a7b18218bae5b',1,'entt::View::entity_type()'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a75fc64bf381a3003d8acf03ed66728f2',1,'entt::View< Entity, Component >::entity_type()']]], ['entt',['entt',['../namespaceentt.html',1,'']]], ['entt_5ftraits',['entt_traits',['../structentt_1_1entt__traits.html',1,'entt']]], ['entt_5ftraits_3c_20std_3a_3auint16_5ft_20_3e',['entt_traits< std::uint16_t >',['../structentt_1_1entt__traits_3_01std_1_1uint16__t_01_4.html',1,'entt']]], diff --git a/search/all_6.js b/search/all_6.js index f3325af3e..e6c7f567c 100644 --- a/search/all_6.js +++ b/search/all_6.js @@ -1,4 +1,4 @@ var searchData= [ - ['get',['get',['../structentt_1_1Actor.html#a995069fd7c86bd152e1eaac811fb56dd',1,'entt::Actor::get() const noexcept'],['../structentt_1_1Actor.html#ae5f572a978820e9055a9778774221104',1,'entt::Actor::get() noexcept'],['../classentt_1_1Registry.html#aad2f79d8d9637a5f666a7121f379a0dd',1,'entt::Registry::get() const noexcept'],['../classentt_1_1Registry.html#a1ff6b9887a50279aec9f463f908924f0',1,'entt::Registry::get() noexcept'],['../classentt_1_1Registry.html#a904b71bae3eaa69d534b4dc41c15e889',1,'entt::Registry::get(entity_type entity) const noexcept'],['../classentt_1_1Registry.html#a6b1cd324d6d080c68f61def36a7a4668',1,'entt::Registry::get(entity_type entity) noexcept'],['../classentt_1_1SparseSet_3_01Entity_01_4.html#a7aa0a2c4f286228fc47d32761552bc13',1,'entt::SparseSet< Entity >::get()'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#ad24ca11a0ce0be4775978c3a06aed24b',1,'entt::SparseSet< Entity, Type >::get(entity_type entity) const noexcept'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#acc051a79f32ee11605c5b61d76e66ef1',1,'entt::SparseSet< Entity, Type >::get(entity_type entity) noexcept'],['../classentt_1_1PersistentView.html#a7b1ca9cc827871a1dbab18e5cbc0826a',1,'entt::PersistentView::get(entity_type entity) const noexcept'],['../classentt_1_1PersistentView.html#ae9378e3f7e89b0f460874100d0e0ee56',1,'entt::PersistentView::get(entity_type entity) noexcept'],['../classentt_1_1View.html#a8d304a255fae2eb2f027dcc7f8d9618d',1,'entt::View::get(entity_type entity) const noexcept'],['../classentt_1_1View.html#a643c0ea0a035790f7dc45b1a7c79429f',1,'entt::View::get(entity_type entity) noexcept'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a831d0d782118c26ca8efe00c452f4b21',1,'entt::View< Entity, Component >::get(entity_type entity) const noexcept'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a97f303e914e114df37e12fd4556efff6',1,'entt::View< Entity, Component >::get(entity_type entity) noexcept'],['../structentt_1_1ServiceLocator.html#a134e8a6d1e3697b7c67bdce9175a7c8b',1,'entt::ServiceLocator::get()'],['../classentt_1_1ResourceHandle.html#a031c890952df1307c771e24166860be8',1,'entt::ResourceHandle::get()']]] + ['get',['get',['../structentt_1_1Actor.html#a995069fd7c86bd152e1eaac811fb56dd',1,'entt::Actor::get() const noexcept'],['../structentt_1_1Actor.html#ae5f572a978820e9055a9778774221104',1,'entt::Actor::get() noexcept'],['../classentt_1_1Registry.html#aad2f79d8d9637a5f666a7121f379a0dd',1,'entt::Registry::get() const noexcept'],['../classentt_1_1Registry.html#a1ff6b9887a50279aec9f463f908924f0',1,'entt::Registry::get() noexcept'],['../classentt_1_1Registry.html#a904b71bae3eaa69d534b4dc41c15e889',1,'entt::Registry::get(entity_type entity) const noexcept'],['../classentt_1_1Registry.html#a6b1cd324d6d080c68f61def36a7a4668',1,'entt::Registry::get(entity_type entity) noexcept'],['../classentt_1_1Registry.html#aa7477b72b93d9f8d12be839d59604f6e',1,'entt::Registry::get(entity_type entity) const noexcept'],['../classentt_1_1Registry.html#aa822126597ded235f9f4b1ad47d02e4f',1,'entt::Registry::get(entity_type entity) noexcept'],['../classentt_1_1SparseSet_3_01Entity_01_4.html#a7aa0a2c4f286228fc47d32761552bc13',1,'entt::SparseSet< Entity >::get()'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#ad24ca11a0ce0be4775978c3a06aed24b',1,'entt::SparseSet< Entity, Type >::get(entity_type entity) const noexcept'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#acc051a79f32ee11605c5b61d76e66ef1',1,'entt::SparseSet< Entity, Type >::get(entity_type entity) noexcept'],['../classentt_1_1PersistentView.html#a7b1ca9cc827871a1dbab18e5cbc0826a',1,'entt::PersistentView::get(entity_type entity) const noexcept'],['../classentt_1_1PersistentView.html#ae9378e3f7e89b0f460874100d0e0ee56',1,'entt::PersistentView::get(entity_type entity) noexcept'],['../classentt_1_1PersistentView.html#a3ea8a5d031b975b57b83d7c900d08422',1,'entt::PersistentView::get(entity_type entity) const noexcept'],['../classentt_1_1PersistentView.html#a963d6b90620d3cb79c338fc5156826dc',1,'entt::PersistentView::get(entity_type entity) noexcept'],['../classentt_1_1View.html#a8d304a255fae2eb2f027dcc7f8d9618d',1,'entt::View::get(entity_type entity) const noexcept'],['../classentt_1_1View.html#a643c0ea0a035790f7dc45b1a7c79429f',1,'entt::View::get(entity_type entity) noexcept'],['../classentt_1_1View.html#ad6c58ec0bc19424396162c76cc2cd532',1,'entt::View::get(entity_type entity) const noexcept'],['../classentt_1_1View.html#ade775c6862a9305f732d6ddac97b0431',1,'entt::View::get(entity_type entity) noexcept'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a831d0d782118c26ca8efe00c452f4b21',1,'entt::View< Entity, Component >::get(entity_type entity) const noexcept'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a97f303e914e114df37e12fd4556efff6',1,'entt::View< Entity, Component >::get(entity_type entity) noexcept'],['../structentt_1_1ServiceLocator.html#a134e8a6d1e3697b7c67bdce9175a7c8b',1,'entt::ServiceLocator::get()'],['../classentt_1_1ResourceHandle.html#a031c890952df1307c771e24166860be8',1,'entt::ResourceHandle::get()']]] ]; diff --git a/search/functions_6.js b/search/functions_6.js index f3325af3e..e6c7f567c 100644 --- a/search/functions_6.js +++ b/search/functions_6.js @@ -1,4 +1,4 @@ var searchData= [ - ['get',['get',['../structentt_1_1Actor.html#a995069fd7c86bd152e1eaac811fb56dd',1,'entt::Actor::get() const noexcept'],['../structentt_1_1Actor.html#ae5f572a978820e9055a9778774221104',1,'entt::Actor::get() noexcept'],['../classentt_1_1Registry.html#aad2f79d8d9637a5f666a7121f379a0dd',1,'entt::Registry::get() const noexcept'],['../classentt_1_1Registry.html#a1ff6b9887a50279aec9f463f908924f0',1,'entt::Registry::get() noexcept'],['../classentt_1_1Registry.html#a904b71bae3eaa69d534b4dc41c15e889',1,'entt::Registry::get(entity_type entity) const noexcept'],['../classentt_1_1Registry.html#a6b1cd324d6d080c68f61def36a7a4668',1,'entt::Registry::get(entity_type entity) noexcept'],['../classentt_1_1SparseSet_3_01Entity_01_4.html#a7aa0a2c4f286228fc47d32761552bc13',1,'entt::SparseSet< Entity >::get()'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#ad24ca11a0ce0be4775978c3a06aed24b',1,'entt::SparseSet< Entity, Type >::get(entity_type entity) const noexcept'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#acc051a79f32ee11605c5b61d76e66ef1',1,'entt::SparseSet< Entity, Type >::get(entity_type entity) noexcept'],['../classentt_1_1PersistentView.html#a7b1ca9cc827871a1dbab18e5cbc0826a',1,'entt::PersistentView::get(entity_type entity) const noexcept'],['../classentt_1_1PersistentView.html#ae9378e3f7e89b0f460874100d0e0ee56',1,'entt::PersistentView::get(entity_type entity) noexcept'],['../classentt_1_1View.html#a8d304a255fae2eb2f027dcc7f8d9618d',1,'entt::View::get(entity_type entity) const noexcept'],['../classentt_1_1View.html#a643c0ea0a035790f7dc45b1a7c79429f',1,'entt::View::get(entity_type entity) noexcept'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a831d0d782118c26ca8efe00c452f4b21',1,'entt::View< Entity, Component >::get(entity_type entity) const noexcept'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a97f303e914e114df37e12fd4556efff6',1,'entt::View< Entity, Component >::get(entity_type entity) noexcept'],['../structentt_1_1ServiceLocator.html#a134e8a6d1e3697b7c67bdce9175a7c8b',1,'entt::ServiceLocator::get()'],['../classentt_1_1ResourceHandle.html#a031c890952df1307c771e24166860be8',1,'entt::ResourceHandle::get()']]] + ['get',['get',['../structentt_1_1Actor.html#a995069fd7c86bd152e1eaac811fb56dd',1,'entt::Actor::get() const noexcept'],['../structentt_1_1Actor.html#ae5f572a978820e9055a9778774221104',1,'entt::Actor::get() noexcept'],['../classentt_1_1Registry.html#aad2f79d8d9637a5f666a7121f379a0dd',1,'entt::Registry::get() const noexcept'],['../classentt_1_1Registry.html#a1ff6b9887a50279aec9f463f908924f0',1,'entt::Registry::get() noexcept'],['../classentt_1_1Registry.html#a904b71bae3eaa69d534b4dc41c15e889',1,'entt::Registry::get(entity_type entity) const noexcept'],['../classentt_1_1Registry.html#a6b1cd324d6d080c68f61def36a7a4668',1,'entt::Registry::get(entity_type entity) noexcept'],['../classentt_1_1Registry.html#aa7477b72b93d9f8d12be839d59604f6e',1,'entt::Registry::get(entity_type entity) const noexcept'],['../classentt_1_1Registry.html#aa822126597ded235f9f4b1ad47d02e4f',1,'entt::Registry::get(entity_type entity) noexcept'],['../classentt_1_1SparseSet_3_01Entity_01_4.html#a7aa0a2c4f286228fc47d32761552bc13',1,'entt::SparseSet< Entity >::get()'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#ad24ca11a0ce0be4775978c3a06aed24b',1,'entt::SparseSet< Entity, Type >::get(entity_type entity) const noexcept'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#acc051a79f32ee11605c5b61d76e66ef1',1,'entt::SparseSet< Entity, Type >::get(entity_type entity) noexcept'],['../classentt_1_1PersistentView.html#a7b1ca9cc827871a1dbab18e5cbc0826a',1,'entt::PersistentView::get(entity_type entity) const noexcept'],['../classentt_1_1PersistentView.html#ae9378e3f7e89b0f460874100d0e0ee56',1,'entt::PersistentView::get(entity_type entity) noexcept'],['../classentt_1_1PersistentView.html#a3ea8a5d031b975b57b83d7c900d08422',1,'entt::PersistentView::get(entity_type entity) const noexcept'],['../classentt_1_1PersistentView.html#a963d6b90620d3cb79c338fc5156826dc',1,'entt::PersistentView::get(entity_type entity) noexcept'],['../classentt_1_1View.html#a8d304a255fae2eb2f027dcc7f8d9618d',1,'entt::View::get(entity_type entity) const noexcept'],['../classentt_1_1View.html#a643c0ea0a035790f7dc45b1a7c79429f',1,'entt::View::get(entity_type entity) noexcept'],['../classentt_1_1View.html#ad6c58ec0bc19424396162c76cc2cd532',1,'entt::View::get(entity_type entity) const noexcept'],['../classentt_1_1View.html#ade775c6862a9305f732d6ddac97b0431',1,'entt::View::get(entity_type entity) noexcept'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a831d0d782118c26ca8efe00c452f4b21',1,'entt::View< Entity, Component >::get(entity_type entity) const noexcept'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a97f303e914e114df37e12fd4556efff6',1,'entt::View< Entity, Component >::get(entity_type entity) noexcept'],['../structentt_1_1ServiceLocator.html#a134e8a6d1e3697b7c67bdce9175a7c8b',1,'entt::ServiceLocator::get()'],['../classentt_1_1ResourceHandle.html#a031c890952df1307c771e24166860be8',1,'entt::ResourceHandle::get()']]] ]; diff --git a/search/functions_f.js b/search/functions_f.js index 9ca23aff8..dd0cec1b8 100644 --- a/search/functions_f.js +++ b/search/functions_f.js @@ -2,5 +2,5 @@ var searchData= [ ['valid',['valid',['../classentt_1_1Registry.html#a11a759638bf2c28ac1670c7b533ca53f',1,'entt::Registry']]], ['version',['version',['../classentt_1_1Registry.html#a773c2bb361f4e83aae1349ccfeede56b',1,'entt::Registry']]], - ['view',['View',['../classentt_1_1View.html#a8eb8d63c9db031af7203b5ca7801c7e3',1,'entt::View::View()'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a24c7693fd64b152591a1a63d46f8e91f',1,'entt::View< Entity, Component >::View()'],['../classentt_1_1Registry.html#aed83d4c8f80ae647ee73f2a8440fa09d',1,'entt::Registry::view()']]] + ['view',['view',['../classentt_1_1Registry.html#aed83d4c8f80ae647ee73f2a8440fa09d',1,'entt::Registry::view()'],['../classentt_1_1View.html#a8eb8d63c9db031af7203b5ca7801c7e3',1,'entt::View::View()'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a24c7693fd64b152591a1a63d46f8e91f',1,'entt::View< Entity, Component >::View()']]] ]; diff --git a/search/typedefs_2.js b/search/typedefs_2.js index 656551666..1ff33b3f2 100644 --- a/search/typedefs_2.js +++ b/search/typedefs_2.js @@ -1,4 +1,4 @@ var searchData= [ - ['entity_5ftype',['entity_type',['../classentt_1_1Registry.html#ad434a1920dd2c6a9a31ab482e2f29038',1,'entt::Registry::entity_type()'],['../classentt_1_1SparseSet_3_01Entity_01_4.html#a7d36e852257a965a9a0ed3fb636433e2',1,'entt::SparseSet< Entity >::entity_type()'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#afe382e2d5c8769fb3d924e1a357cf9b0',1,'entt::SparseSet< Entity, Type >::entity_type()'],['../structentt_1_1entt__traits_3_01std_1_1uint16__t_01_4.html#a86e202c8932f341626b29c194bd47489',1,'entt::entt_traits< std::uint16_t >::entity_type()'],['../structentt_1_1entt__traits_3_01std_1_1uint32__t_01_4.html#aecde3ac9bfc28e7f0f880a74ee2c5d8f',1,'entt::entt_traits< std::uint32_t >::entity_type()'],['../structentt_1_1entt__traits_3_01std_1_1uint64__t_01_4.html#a304eb4dc4a1487cf2966d902214f7185',1,'entt::entt_traits< std::uint64_t >::entity_type()'],['../classentt_1_1PersistentView.html#a5195c9d1dede0fe6c40bea576398022b',1,'entt::PersistentView::entity_type()'],['../classentt_1_1View.html#ad167f4bc8202231d768a7b18218bae5b',1,'entt::View::entity_type()'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a75fc64bf381a3003d8acf03ed66728f2',1,'entt::View< Entity, Component >::entity_type()']]] + ['entity_5ftype',['entity_type',['../structentt_1_1Actor.html#a592fca2df475cf3b98bc691648832666',1,'entt::Actor::entity_type()'],['../structentt_1_1entt__traits_3_01std_1_1uint16__t_01_4.html#a86e202c8932f341626b29c194bd47489',1,'entt::entt_traits< std::uint16_t >::entity_type()'],['../structentt_1_1entt__traits_3_01std_1_1uint32__t_01_4.html#aecde3ac9bfc28e7f0f880a74ee2c5d8f',1,'entt::entt_traits< std::uint32_t >::entity_type()'],['../structentt_1_1entt__traits_3_01std_1_1uint64__t_01_4.html#a304eb4dc4a1487cf2966d902214f7185',1,'entt::entt_traits< std::uint64_t >::entity_type()'],['../classentt_1_1Registry.html#ad434a1920dd2c6a9a31ab482e2f29038',1,'entt::Registry::entity_type()'],['../classentt_1_1SparseSet_3_01Entity_01_4.html#a7d36e852257a965a9a0ed3fb636433e2',1,'entt::SparseSet< Entity >::entity_type()'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#afe382e2d5c8769fb3d924e1a357cf9b0',1,'entt::SparseSet< Entity, Type >::entity_type()'],['../classentt_1_1PersistentView.html#a5195c9d1dede0fe6c40bea576398022b',1,'entt::PersistentView::entity_type()'],['../classentt_1_1View.html#ad167f4bc8202231d768a7b18218bae5b',1,'entt::View::entity_type()'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a75fc64bf381a3003d8acf03ed66728f2',1,'entt::View< Entity, Component >::entity_type()']]] ]; diff --git a/search/typedefs_e.js b/search/typedefs_e.js index a27070ebf..b8dd61089 100644 --- a/search/typedefs_e.js +++ b/search/typedefs_e.js @@ -1,4 +1,4 @@ var searchData= [ - ['version_5ftype',['version_type',['../classentt_1_1Registry.html#a82c8996277034df5e72b5f30a70ebb2d',1,'entt::Registry::version_type()'],['../structentt_1_1entt__traits_3_01std_1_1uint16__t_01_4.html#ab37d10c3be3d59159a63c0bd1e9e2924',1,'entt::entt_traits< std::uint16_t >::version_type()'],['../structentt_1_1entt__traits_3_01std_1_1uint32__t_01_4.html#aee59dc7455ea0be015e699c3e46a22d1',1,'entt::entt_traits< std::uint32_t >::version_type()'],['../structentt_1_1entt__traits_3_01std_1_1uint64__t_01_4.html#aeac4d9172940a9dec0682860ac176725',1,'entt::entt_traits< std::uint64_t >::version_type()']]] + ['version_5ftype',['version_type',['../structentt_1_1entt__traits_3_01std_1_1uint16__t_01_4.html#ab37d10c3be3d59159a63c0bd1e9e2924',1,'entt::entt_traits< std::uint16_t >::version_type()'],['../structentt_1_1entt__traits_3_01std_1_1uint32__t_01_4.html#aee59dc7455ea0be015e699c3e46a22d1',1,'entt::entt_traits< std::uint32_t >::version_type()'],['../structentt_1_1entt__traits_3_01std_1_1uint64__t_01_4.html#aeac4d9172940a9dec0682860ac176725',1,'entt::entt_traits< std::uint64_t >::version_type()'],['../classentt_1_1Registry.html#a82c8996277034df5e72b5f30a70ebb2d',1,'entt::Registry::version_type()']]] ]; diff --git a/sigh_8hpp_source.html b/sigh_8hpp_source.html index 2495a144b..dc03b2585 100644 --- a/sigh_8hpp_source.html +++ b/sigh_8hpp_source.html @@ -22,7 +22,7 @@
    entt -  2.4.1 +  2.4.2
    @@ -83,7 +83,7 @@ $(function() {
    entt::SigH
    Unmanaged signal handler declaration.
    Definition: sigh.hpp:83
    entt::SigH< Ret(Args...), Collector >::publish
    void publish(Args... args)
    Triggers a signal.
    Definition: sigh.hpp:231
    entt::SigH< Ret(Args...), Collector >::connect
    void connect()
    Connects a free function to a signal.
    Definition: sigh.hpp:168
    -
    entt::operator!=
    constexpr bool operator!=(const HashedString &lhs, const HashedString &rhs) noexcept
    Compares two hashed strings.
    Definition: hashed_string.hpp:101
    +
    entt::operator!=
    constexpr bool operator!=(const HashedString &lhs, const HashedString &rhs) noexcept
    Compares two hashed strings.
    Definition: hashed_string.hpp:102
    entt::SigH< Ret(Args...), Collector >::empty
    bool empty() const noexcept
    Returns false if at least a listener is connected to the signal.
    Definition: sigh.hpp:148
    diff --git a/signal_8hpp_source.html b/signal_8hpp_source.html index c80ba020c..20daf75ec 100644 --- a/signal_8hpp_source.html +++ b/signal_8hpp_source.html @@ -22,7 +22,7 @@
    entt -  2.4.1 +  2.4.2
    @@ -81,7 +81,7 @@ $(function() {
    entt::Signal
    Managed signal handler declaration.
    Definition: signal.hpp:23
    entt::Signal< void(Args...)>::empty
    bool empty() const noexcept
    Returns false if at least a listener is connected to the signal.
    Definition: signal.hpp:85
    entt::Signal< void(Args...)>::instance_type
    std::shared_ptr< Class > instance_type
    Instance type when it comes to connecting member functions.
    Definition: signal.hpp:71
    -
    entt::operator!=
    constexpr bool operator!=(const HashedString &lhs, const HashedString &rhs) noexcept
    Compares two hashed strings.
    Definition: hashed_string.hpp:101
    +
    entt::operator!=
    constexpr bool operator!=(const HashedString &lhs, const HashedString &rhs) noexcept
    Compares two hashed strings.
    Definition: hashed_string.hpp:102
    entt::Signal< void(Args...)>::clear
    void clear() noexcept
    Disconnects all the listeners from a signal.
    Definition: signal.hpp:92
    diff --git a/sparse__set_8hpp_source.html b/sparse__set_8hpp_source.html index 4c840cf37..df40cc5be 100644 --- a/sparse__set_8hpp_source.html +++ b/sparse__set_8hpp_source.html @@ -22,7 +22,7 @@
    entt -  2.4.1 +  2.4.2
    @@ -67,13 +67,13 @@ $(function() {
    sparse_set.hpp
    -
    1 #ifndef ENTT_ENTITY_SPARSE_SET_HPP
    2 #define ENTT_ENTITY_SPARSE_SET_HPP
    3 
    4 
    5 #include <algorithm>
    6 #include <numeric>
    7 #include <utility>
    8 #include <vector>
    9 #include <cstddef>
    10 #include <cassert>
    11 #include <type_traits>
    12 #include "traits.hpp"
    13 
    14 
    15 namespace entt {
    16 
    17 
    24 template<typename...>
    25 class SparseSet;
    26 
    27 
    55 template<typename Entity>
    56 class SparseSet<Entity> {
    57  using traits_type = entt_traits<Entity>;
    58 
    59  struct Iterator {
    60  using value_type = Entity;
    61 
    62  Iterator(const std::vector<Entity> *direct, std::size_t pos)
    63  : direct{direct}, pos{pos}
    64  {}
    65 
    66  Iterator & operator++() noexcept {
    67  return --pos, *this;
    68  }
    69 
    70  Iterator operator++(int) noexcept {
    71  Iterator orig = *this;
    72  return ++(*this), orig;
    73  }
    74 
    75  bool operator==(const Iterator &other) const noexcept {
    76  return other.pos == pos && other.direct == direct;
    77  }
    78 
    79  bool operator!=(const Iterator &other) const noexcept {
    80  return !(*this == other);
    81  }
    82 
    83  value_type operator*() const noexcept {
    84  return (*direct)[pos-1];
    85  }
    86 
    87  private:
    88  const std::vector<Entity> *direct;
    89  std::size_t pos;
    90  };
    91 
    92  static constexpr Entity in_use = (Entity{1} << traits_type::entity_shift);
    93 
    94 public:
    96  using entity_type = Entity;
    98  using pos_type = entity_type;
    100  using size_type = std::size_t;
    102  using iterator_type = Iterator;
    103 
    105  SparseSet() noexcept = default;
    106 
    108  virtual ~SparseSet() noexcept = default;
    109 
    111  SparseSet(const SparseSet &) = delete;
    113  SparseSet(SparseSet &&) = default;
    114 
    116  SparseSet & operator=(const SparseSet &) = delete;
    118  SparseSet & operator=(SparseSet &&) = default;
    119 
    128  void reserve(size_type cap) {
    129  reverse.reserve(cap);
    130  direct.reserve(cap);
    131  }
    132 
    143  size_type size() const noexcept {
    144  return direct.size();
    145  }
    146 
    151  bool empty() const noexcept {
    152  return direct.empty();
    153  }
    154 
    170  const entity_type * data() const noexcept {
    171  return direct.data();
    172  }
    173 
    186  iterator_type begin() const noexcept {
    187  return Iterator{&direct, direct.size()};
    188  }
    189 
    203  iterator_type end() const noexcept {
    204  return Iterator{&direct, 0};
    205  }
    206 
    212  bool has(entity_type entity) const noexcept {
    213  using promotion_type = std::conditional_t<sizeof(size_type) >= sizeof(entity_type), size_type, entity_type>;
    214  // explicit promotion to avoid warnings with std::uint16_t
    215  const auto entt = promotion_type{entity} & traits_type::entity_mask;
    216  // the in-use control bit permits to avoid accessing the direct vector
    217  return (entt < reverse.size()) && (reverse[entt] & in_use);
    218  }
    219 
    232  pos_type get(entity_type entity) const noexcept {
    233  assert(has(entity));
    234  const auto entt = entity & traits_type::entity_mask;
    235  // we must get rid of the in-use bit for it's not part of the position
    236  return reverse[entt] & ~in_use;
    237  }
    238 
    250  void construct(entity_type entity) {
    251  assert(!has(entity));
    252  using promotion_type = std::conditional_t<sizeof(size_type) >= sizeof(entity_type), size_type, entity_type>;
    253  // explicit promotion to avoid warnings with std::uint16_t
    254  const auto entt = promotion_type{entity} & traits_type::entity_mask;
    255 
    256  if(!(entt < reverse.size())) {
    257  reverse.resize(entt+1, pos_type{});
    258  }
    259 
    260  // we exploit the fact that pos_type is equal to entity_type and pos has
    261  // traits_type::version_mask bits unused we can use to mark it as in-use
    262  reverse[entt] = pos_type(direct.size()) | in_use;
    263  direct.emplace_back(entity);
    264  }
    265 
    277  virtual void destroy(entity_type entity) {
    278  assert(has(entity));
    279  const auto entt = entity & traits_type::entity_mask;
    280  const auto back = direct.back() & traits_type::entity_mask;
    281  const auto pos = reverse[entt] & ~in_use;
    282  // the order matters: if back and entt are the same (for the sparse set
    283  // has size 1), switching the two lines below doesn't work as expected
    284  reverse[back] = pos | in_use;
    285  reverse[entt] = pos;
    286  // swapping isn't required here, we are getting rid of the last element
    287  direct[pos] = direct.back();
    288  direct.pop_back();
    289  }
    290 
    306  void swap(pos_type lhs, pos_type rhs) noexcept {
    307  assert(lhs < direct.size());
    308  assert(rhs < direct.size());
    309  const auto src = direct[lhs] & traits_type::entity_mask;
    310  const auto dst = direct[rhs] & traits_type::entity_mask;
    311  std::swap(reverse[src], reverse[dst]);
    312  std::swap(direct[lhs], direct[rhs]);
    313  }
    314 
    334  virtual void respect(const SparseSet<Entity> &other) noexcept {
    335  auto from = other.begin();
    336  auto to = other.end();
    337 
    338  pos_type pos = direct.size() - 1;
    339 
    340  while(pos > 0 && from != to) {
    341  if(has(*from)) {
    342  if(*from != direct[pos]) {
    343  swap(pos, get(*from));
    344  }
    345 
    346  --pos;
    347  }
    348 
    349  ++from;
    350  }
    351  }
    352 
    356  virtual void reset() {
    357  reverse.clear();
    358  direct.clear();
    359  }
    360 
    361 private:
    362  std::vector<pos_type> reverse;
    363  std::vector<entity_type> direct;
    364 };
    365 
    366 
    389 template<typename Entity, typename Type>
    390 class SparseSet<Entity, Type>: public SparseSet<Entity> {
    391  using underlying_type = SparseSet<Entity>;
    392 
    393 public:
    395  using object_type = Type;
    397  using entity_type = typename underlying_type::entity_type;
    399  using pos_type = typename underlying_type::pos_type;
    401  using size_type = typename underlying_type::size_type;
    403  using iterator_type = typename underlying_type::iterator_type;
    404 
    406  SparseSet() noexcept = default;
    407 
    409  SparseSet(const SparseSet &) = delete;
    411  SparseSet(SparseSet &&) = default;
    412 
    414  SparseSet & operator=(const SparseSet &) = delete;
    416  SparseSet & operator=(SparseSet &&) = default;
    417 
    426  void reserve(size_type cap) {
    427  underlying_type::reserve(cap);
    428  instances.reserve(cap);
    429  }
    430 
    446  const object_type * raw() const noexcept {
    447  return instances.data();
    448  }
    449 
    465  object_type * raw() noexcept {
    466  return instances.data();
    467  }
    468 
    481  const object_type & get(entity_type entity) const noexcept {
    482  return instances[underlying_type::get(entity)];
    483  }
    484 
    497  object_type & get(entity_type entity) noexcept {
    498  return const_cast<object_type &>(const_cast<const SparseSet *>(this)->get(entity));
    499  }
    500 
    515  template<typename... Args>
    516  object_type & construct(entity_type entity, Args&&... args) {
    517  underlying_type::construct(entity);
    518  // emplace_back doesn't work well with PODs because of its placement new
    519  instances.push_back({ std::forward<Args>(args)... });
    520  return instances.back();
    521  }
    522 
    534  void destroy(entity_type entity) override {
    535  // swapping isn't required here, we are getting rid of the last element
    536  instances[underlying_type::get(entity)] = std::move(instances.back());
    537  instances.pop_back();
    538  underlying_type::destroy(entity);
    539  }
    540 
    563  template<typename Compare>
    564  void sort(Compare compare) {
    565  std::vector<pos_type> copy(instances.size());
    566  std::iota(copy.begin(), copy.end(), 0);
    567 
    568  std::sort(copy.begin(), copy.end(), [this, compare = std::move(compare)](auto lhs, auto rhs) {
    569  return compare(const_cast<const object_type &>(instances[rhs]), const_cast<const object_type &>(instances[lhs]));
    570  });
    571 
    572  for(pos_type pos = 0, last = copy.size(); pos < last; ++pos) {
    573  auto curr = pos;
    574  auto next = copy[curr];
    575 
    576  while(curr != next) {
    577  auto lhs = copy[curr];
    578  auto rhs = copy[next];
    579  std::swap(instances[lhs], instances[rhs]);
    580  underlying_type::swap(lhs, rhs);
    581  copy[curr] = curr;
    582  curr = next;
    583  next = copy[curr];
    584  }
    585  }
    586  }
    587 
    610  void respect(const SparseSet<Entity> &other) noexcept override {
    611  auto from = other.begin();
    612  auto to = other.end();
    613 
    614  pos_type pos = underlying_type::size() - 1;
    615  const auto *direct = underlying_type::data();
    616 
    617  while(pos > 0 && from != to) {
    618  if(underlying_type::has(*from)) {
    619  if(*from != *(direct + pos)) {
    620  auto candidate = underlying_type::get(*from);
    621  std::swap(instances[pos], instances[candidate]);
    622  underlying_type::swap(pos, candidate);
    623  }
    624 
    625  --pos;
    626  }
    627 
    628  ++from;
    629  }
    630  }
    631 
    635  void reset() override {
    636  underlying_type::reset();
    637  instances.clear();
    638  }
    639 
    640 private:
    641  std::vector<object_type> instances;
    642 };
    643 
    644 
    645 }
    646 
    647 
    648 #endif // ENTT_ENTITY_SPARSE_SET_HPP
    entt::SparseSet< Entity, Type >::sort
    void sort(Compare compare)
    Sort components according to the given comparison function.
    Definition: sparse_set.hpp:564
    +
    1 #ifndef ENTT_ENTITY_SPARSE_SET_HPP
    2 #define ENTT_ENTITY_SPARSE_SET_HPP
    3 
    4 
    5 #include <algorithm>
    6 #include <numeric>
    7 #include <utility>
    8 #include <vector>
    9 #include <cstddef>
    10 #include <cassert>
    11 #include <type_traits>
    12 #include "entt_traits.hpp"
    13 
    14 
    15 namespace entt {
    16 
    17 
    24 template<typename...>
    25 class SparseSet;
    26 
    27 
    55 template<typename Entity>
    56 class SparseSet<Entity> {
    57  using traits_type = entt_traits<Entity>;
    58 
    59  struct Iterator final {
    60  using value_type = Entity;
    61 
    62  Iterator(const std::vector<value_type> *direct, std::size_t pos)
    63  : direct{direct}, pos{pos}
    64  {}
    65 
    66  Iterator & operator++() noexcept {
    67  return --pos, *this;
    68  }
    69 
    70  Iterator operator++(int) noexcept {
    71  Iterator orig = *this;
    72  return ++(*this), orig;
    73  }
    74 
    75  bool operator==(const Iterator &other) const noexcept {
    76  return other.pos == pos && other.direct == direct;
    77  }
    78 
    79  bool operator!=(const Iterator &other) const noexcept {
    80  return !(*this == other);
    81  }
    82 
    83  value_type operator*() const noexcept {
    84  return (*direct)[pos-1];
    85  }
    86 
    87  private:
    88  const std::vector<value_type> *direct;
    89  std::size_t pos;
    90  };
    91 
    92  static constexpr Entity in_use = (Entity{1} << traits_type::entity_shift);
    93 
    94 public:
    96  using entity_type = Entity;
    98  using pos_type = entity_type;
    100  using size_type = std::size_t;
    102  using iterator_type = Iterator;
    103 
    105  SparseSet() noexcept = default;
    106 
    108  virtual ~SparseSet() noexcept = default;
    109 
    111  SparseSet(const SparseSet &) = delete;
    113  SparseSet(SparseSet &&) = default;
    114 
    116  SparseSet & operator=(const SparseSet &) = delete;
    118  SparseSet & operator=(SparseSet &&) = default;
    119 
    128  void reserve(size_type cap) {
    129  reverse.reserve(cap);
    130  direct.reserve(cap);
    131  }
    132 
    143  size_type size() const noexcept {
    144  return direct.size();
    145  }
    146 
    151  bool empty() const noexcept {
    152  return direct.empty();
    153  }
    154 
    170  const entity_type * data() const noexcept {
    171  return direct.data();
    172  }
    173 
    186  iterator_type begin() const noexcept {
    187  return Iterator{&direct, direct.size()};
    188  }
    189 
    203  iterator_type end() const noexcept {
    204  return Iterator{&direct, 0};
    205  }
    206 
    212  bool has(entity_type entity) const noexcept {
    213  using promotion_type = std::conditional_t<sizeof(size_type) >= sizeof(entity_type), size_type, entity_type>;
    214  // explicit promotion to avoid warnings with std::uint16_t
    215  const auto entt = promotion_type{entity} & traits_type::entity_mask;
    216  // the in-use control bit permits to avoid accessing the direct vector
    217  return (entt < reverse.size()) && (reverse[entt] & in_use);
    218  }
    219 
    232  pos_type get(entity_type entity) const noexcept {
    233  assert(has(entity));
    234  const auto entt = entity & traits_type::entity_mask;
    235  // we must get rid of the in-use bit for it's not part of the position
    236  return reverse[entt] & ~in_use;
    237  }
    238 
    250  void construct(entity_type entity) {
    251  assert(!has(entity));
    252  using promotion_type = std::conditional_t<sizeof(size_type) >= sizeof(entity_type), size_type, entity_type>;
    253  // explicit promotion to avoid warnings with std::uint16_t
    254  const auto entt = promotion_type{entity} & traits_type::entity_mask;
    255 
    256  if(!(entt < reverse.size())) {
    257  reverse.resize(entt+1, pos_type{});
    258  }
    259 
    260  // we exploit the fact that pos_type is equal to entity_type and pos has
    261  // traits_type::version_mask bits unused we can use to mark it as in-use
    262  reverse[entt] = pos_type(direct.size()) | in_use;
    263  direct.emplace_back(entity);
    264  }
    265 
    277  virtual void destroy(entity_type entity) {
    278  assert(has(entity));
    279  const auto entt = entity & traits_type::entity_mask;
    280  const auto back = direct.back() & traits_type::entity_mask;
    281  const auto pos = reverse[entt] & ~in_use;
    282  // the order matters: if back and entt are the same (for the sparse set
    283  // has size 1), switching the two lines below doesn't work as expected
    284  reverse[back] = pos | in_use;
    285  reverse[entt] = pos;
    286  // swapping isn't required here, we are getting rid of the last element
    287  direct[pos] = direct.back();
    288  direct.pop_back();
    289  }
    290 
    306  void swap(pos_type lhs, pos_type rhs) noexcept {
    307  assert(lhs < direct.size());
    308  assert(rhs < direct.size());
    309  const auto src = direct[lhs] & traits_type::entity_mask;
    310  const auto dst = direct[rhs] & traits_type::entity_mask;
    311  std::swap(reverse[src], reverse[dst]);
    312  std::swap(direct[lhs], direct[rhs]);
    313  }
    314 
    334  virtual void respect(const SparseSet<Entity> &other) noexcept {
    335  auto from = other.begin();
    336  auto to = other.end();
    337 
    338  pos_type pos = direct.size() - 1;
    339 
    340  while(pos > 0 && from != to) {
    341  if(has(*from)) {
    342  if(*from != direct[pos]) {
    343  swap(pos, get(*from));
    344  }
    345 
    346  --pos;
    347  }
    348 
    349  ++from;
    350  }
    351  }
    352 
    356  virtual void reset() {
    357  reverse.clear();
    358  direct.clear();
    359  }
    360 
    361 private:
    362  std::vector<pos_type> reverse;
    363  std::vector<entity_type> direct;
    364 };
    365 
    366 
    389 template<typename Entity, typename Type>
    390 class SparseSet<Entity, Type>: public SparseSet<Entity> {
    391  using underlying_type = SparseSet<Entity>;
    392 
    393 public:
    395  using object_type = Type;
    397  using entity_type = typename underlying_type::entity_type;
    399  using pos_type = typename underlying_type::pos_type;
    401  using size_type = typename underlying_type::size_type;
    403  using iterator_type = typename underlying_type::iterator_type;
    404 
    406  SparseSet() noexcept = default;
    407 
    409  SparseSet(const SparseSet &) = delete;
    411  SparseSet(SparseSet &&) = default;
    412 
    414  SparseSet & operator=(const SparseSet &) = delete;
    416  SparseSet & operator=(SparseSet &&) = default;
    417 
    426  void reserve(size_type cap) {
    427  underlying_type::reserve(cap);
    428  instances.reserve(cap);
    429  }
    430 
    446  const object_type * raw() const noexcept {
    447  return instances.data();
    448  }
    449 
    465  object_type * raw() noexcept {
    466  return instances.data();
    467  }
    468 
    481  const object_type & get(entity_type entity) const noexcept {
    482  return instances[underlying_type::get(entity)];
    483  }
    484 
    497  object_type & get(entity_type entity) noexcept {
    498  return const_cast<object_type &>(const_cast<const SparseSet *>(this)->get(entity));
    499  }
    500 
    515  template<typename... Args>
    516  object_type & construct(entity_type entity, Args&&... args) {
    517  underlying_type::construct(entity);
    518  // emplace_back doesn't work well with PODs because of its placement new
    519  instances.push_back(object_type{ std::forward<Args>(args)... });
    520  return instances.back();
    521  }
    522 
    534  void destroy(entity_type entity) override {
    535  // swapping isn't required here, we are getting rid of the last element
    536  // however, we must protect ourselves from self assignments (see #37)
    537  auto tmp = std::move(instances.back());
    538  instances[underlying_type::get(entity)] = std::move(tmp);
    539  instances.pop_back();
    540  underlying_type::destroy(entity);
    541  }
    542 
    565  template<typename Compare>
    566  void sort(Compare compare) {
    567  std::vector<pos_type> copy(instances.size());
    568  std::iota(copy.begin(), copy.end(), 0);
    569 
    570  std::sort(copy.begin(), copy.end(), [this, compare = std::move(compare)](auto lhs, auto rhs) {
    571  return compare(const_cast<const object_type &>(instances[rhs]), const_cast<const object_type &>(instances[lhs]));
    572  });
    573 
    574  for(pos_type pos = 0, last = copy.size(); pos < last; ++pos) {
    575  auto curr = pos;
    576  auto next = copy[curr];
    577 
    578  while(curr != next) {
    579  auto lhs = copy[curr];
    580  auto rhs = copy[next];
    581  std::swap(instances[lhs], instances[rhs]);
    582  underlying_type::swap(lhs, rhs);
    583  copy[curr] = curr;
    584  curr = next;
    585  next = copy[curr];
    586  }
    587  }
    588  }
    589 
    612  void respect(const SparseSet<Entity> &other) noexcept override {
    613  auto from = other.begin();
    614  auto to = other.end();
    615 
    616  pos_type pos = underlying_type::size() - 1;
    617  const auto *direct = underlying_type::data();
    618 
    619  while(pos > 0 && from != to) {
    620  if(underlying_type::has(*from)) {
    621  if(*from != *(direct + pos)) {
    622  auto candidate = underlying_type::get(*from);
    623  std::swap(instances[pos], instances[candidate]);
    624  underlying_type::swap(pos, candidate);
    625  }
    626 
    627  --pos;
    628  }
    629 
    630  ++from;
    631  }
    632  }
    633 
    637  void reset() override {
    638  underlying_type::reset();
    639  instances.clear();
    640  }
    641 
    642 private:
    643  std::vector<object_type> instances;
    644 };
    645 
    646 
    647 }
    648 
    649 
    650 #endif // ENTT_ENTITY_SPARSE_SET_HPP
    entt::SparseSet< Entity, Type >::sort
    void sort(Compare compare)
    Sort components according to the given comparison function.
    Definition: sparse_set.hpp:566
    entt::SparseSet< Entity >::reset
    virtual void reset()
    Resets a sparse set.
    Definition: sparse_set.hpp:356
    entt
    EnTT default namespace.
    Definition: family.hpp:9
    -
    entt::SparseSet< Entity, Type >::reset
    void reset() override
    Resets a sparse set.
    Definition: sparse_set.hpp:635
    +
    entt::SparseSet< Entity, Type >::reset
    void reset() override
    Resets a sparse set.
    Definition: sparse_set.hpp:637
    entt::SparseSet< Entity, Type >::raw
    const object_type * raw() const noexcept
    Direct access to the array of objects.
    Definition: sparse_set.hpp:446
    entt::SparseSet< Entity >::empty
    bool empty() const noexcept
    Checks whether a sparse set is empty.
    Definition: sparse_set.hpp:151
    -
    entt::SparseSet< Entity, Type >::respect
    void respect(const SparseSet< Entity > &other) noexcept override
    Sort components according to the order of the entities in another sparse set.
    Definition: sparse_set.hpp:610
    +
    entt::SparseSet< Entity, Type >::respect
    void respect(const SparseSet< Entity > &other) noexcept override
    Sort components according to the order of the entities in another sparse set.
    Definition: sparse_set.hpp:612
    entt::SparseSet
    Sparse set.
    Definition: sparse_set.hpp:25
    entt::SparseSet< Entity >::size_type
    std::size_t size_type
    Unsigned integer type.
    Definition: sparse_set.hpp:100
    entt::SparseSet< Entity, Type >
    Extended sparse set implementation.
    Definition: sparse_set.hpp:390
    @@ -91,11 +91,11 @@ $(function() {
    entt::SparseSet< Entity >::construct
    void construct(entity_type entity)
    Assigns an entity to a sparse set.
    Definition: sparse_set.hpp:250
    entt::SparseSet< Entity, Type >::construct
    object_type & construct(entity_type entity, Args &&... args)
    Assigns an entity to a sparse set and constructs its object.
    Definition: sparse_set.hpp:516
    entt::SparseSet< Entity >::size
    size_type size() const noexcept
    Returns the number of elements in a sparse set.
    Definition: sparse_set.hpp:143
    -
    entt::operator!=
    constexpr bool operator!=(const HashedString &lhs, const HashedString &rhs) noexcept
    Compares two hashed strings.
    Definition: hashed_string.hpp:101
    +
    entt::operator!=
    constexpr bool operator!=(const HashedString &lhs, const HashedString &rhs) noexcept
    Compares two hashed strings.
    Definition: hashed_string.hpp:102
    entt::SparseSet< Entity >::respect
    virtual void respect(const SparseSet< Entity > &other) noexcept
    Sort entities according to their order in another sparse set.
    Definition: sparse_set.hpp:334
    entt::SparseSet< Entity, Type >::raw
    object_type * raw() noexcept
    Direct access to the array of objects.
    Definition: sparse_set.hpp:465
    entt::SparseSet< Entity >::swap
    void swap(pos_type lhs, pos_type rhs) noexcept
    Swaps the position of two entities in the internal packed array.
    Definition: sparse_set.hpp:306
    -
    entt::entt_traits
    Entity traits.
    Definition: traits.hpp:18
    +
    entt::entt_traits
    Entity traits.
    Definition: entt_traits.hpp:18
    diff --git a/structentt_1_1Actor-members.html b/structentt_1_1Actor-members.html index be8f64feb..aefd085d3 100644 --- a/structentt_1_1Actor-members.html +++ b/structentt_1_1Actor-members.html @@ -22,7 +22,7 @@
    entt -  2.4.1 +  2.4.2
    @@ -74,18 +74,19 @@ $(function() { Actor(const Actor &)=defaultentt::Actor< Entity, Delta > Actor(Actor &&)=defaultentt::Actor< Entity, Delta > delta_type typedefentt::Actor< Entity, Delta > - get() const noexceptentt::Actor< Entity, Delta >inline - get() noexceptentt::Actor< Entity, Delta >inline - has() const noexceptentt::Actor< Entity, Delta >inline - operator=(const Actor &)=defaultentt::Actor< Entity, Delta > - operator=(Actor &&)=defaultentt::Actor< Entity, Delta > - registry() const noexceptentt::Actor< Entity, Delta >inline - registry() noexceptentt::Actor< Entity, Delta >inline - registry_type typedefentt::Actor< Entity, Delta > - set(Args &&... args)entt::Actor< Entity, Delta >inline - unset()entt::Actor< Entity, Delta >inline - update(delta_type delta)=0entt::Actor< Entity, Delta >pure virtual - ~Actor()entt::Actor< Entity, Delta >inlinevirtual + entity_type typedefentt::Actor< Entity, Delta > + get() const noexceptentt::Actor< Entity, Delta >inline + get() noexceptentt::Actor< Entity, Delta >inline + has() const noexceptentt::Actor< Entity, Delta >inline + operator=(const Actor &)=defaultentt::Actor< Entity, Delta > + operator=(Actor &&)=defaultentt::Actor< Entity, Delta > + registry() const noexceptentt::Actor< Entity, Delta >inline + registry() noexceptentt::Actor< Entity, Delta >inline + registry_type typedefentt::Actor< Entity, Delta > + set(Args &&... args)entt::Actor< Entity, Delta >inline + unset()entt::Actor< Entity, Delta >inline + update(delta_type delta)=0entt::Actor< Entity, Delta >pure virtual + ~Actor()entt::Actor< Entity, Delta >inlinevirtual
    diff --git a/structentt_1_1Actor.html b/structentt_1_1Actor.html index 5ba7b6893..56037294c 100644 --- a/structentt_1_1Actor.html +++ b/structentt_1_1Actor.html @@ -22,7 +22,7 @@
    entt -  2.4.1 +  2.4.2
    @@ -83,6 +83,10 @@ Public Types using registry_type = Registry< Entity >  Type of registry used internally.
      + +using entity_type = Entity + Underlying entity identifier.
    +  using delta_type = Delta  Type used to provide elapsed time.
    @@ -191,7 +195,7 @@ template<typename Entity , typename Delta > -

    Definition at line 32 of file actor.hpp.

    +

    Definition at line 34 of file actor.hpp.

    @@ -232,7 +236,7 @@ template<typename Component >
    Returns
    A reference to the instance of the component owned by the entity.
    -

    Definition at line 95 of file actor.hpp.

    +

    Definition at line 97 of file actor.hpp.

    @@ -272,7 +276,7 @@ template<typename Component >
    Returns
    A reference to the instance of the component owned by the entity.
    -

    Definition at line 105 of file actor.hpp.

    +

    Definition at line 107 of file actor.hpp.

    @@ -312,7 +316,7 @@ template<typename Component >
    Returns
    True if the actor has the component, false otherwise.
    -

    Definition at line 85 of file actor.hpp.

    +

    Definition at line 87 of file actor.hpp.

    @@ -406,7 +410,7 @@ template<typename Entity , typename Delta >

    Returns a reference to the underlying registry.

    Returns
    A reference to the underlying registry
    -

    Definition at line 113 of file actor.hpp.

    +

    Definition at line 115 of file actor.hpp.

    @@ -438,7 +442,7 @@ template<typename Entity , typename Delta >

    Returns a reference to the underlying registry.

    Returns
    A reference to the underlying registry
    -

    Definition at line 121 of file actor.hpp.

    +

    Definition at line 123 of file actor.hpp.

    @@ -488,7 +492,7 @@ template<typename Component , typename... Args>
    Returns
    A reference to the newly created component.
    -

    Definition at line 66 of file actor.hpp.

    +

    Definition at line 68 of file actor.hpp.

    @@ -527,7 +531,7 @@ template<typename Component > -

    Definition at line 75 of file actor.hpp.

    +

    Definition at line 77 of file actor.hpp.

    diff --git a/structentt_1_1Emitter_1_1Connection-members.html b/structentt_1_1Emitter_1_1Connection-members.html index 6c56ed7bb..8fba46598 100644 --- a/structentt_1_1Emitter_1_1Connection-members.html +++ b/structentt_1_1Emitter_1_1Connection-members.html @@ -22,7 +22,7 @@
    entt -  2.4.1 +  2.4.2
    diff --git a/structentt_1_1Emitter_1_1Connection.html b/structentt_1_1Emitter_1_1Connection.html index 39b40fd5e..03727cdd0 100644 --- a/structentt_1_1Emitter_1_1Connection.html +++ b/structentt_1_1Emitter_1_1Connection.html @@ -22,7 +22,7 @@
    entt -  2.4.1 +  2.4.2
    diff --git a/structentt_1_1ProcessAdaptor-members.html b/structentt_1_1ProcessAdaptor-members.html index f1a102616..3f15b6510 100644 --- a/structentt_1_1ProcessAdaptor-members.html +++ b/structentt_1_1ProcessAdaptor-members.html @@ -22,7 +22,7 @@
    entt -  2.4.1 +  2.4.2
    diff --git a/structentt_1_1ProcessAdaptor.html b/structentt_1_1ProcessAdaptor.html index a112724a8..da82b9468 100644 --- a/structentt_1_1ProcessAdaptor.html +++ b/structentt_1_1ProcessAdaptor.html @@ -22,7 +22,7 @@
    entt -  2.4.1 +  2.4.2
    diff --git a/structentt_1_1ServiceLocator-members.html b/structentt_1_1ServiceLocator-members.html index 690a52676..3de75d4e9 100644 --- a/structentt_1_1ServiceLocator-members.html +++ b/structentt_1_1ServiceLocator-members.html @@ -22,7 +22,7 @@
    entt -  2.4.1 +  2.4.2
    diff --git a/structentt_1_1ServiceLocator.html b/structentt_1_1ServiceLocator.html index d4d9cddc2..88eccff9d 100644 --- a/structentt_1_1ServiceLocator.html +++ b/structentt_1_1ServiceLocator.html @@ -22,7 +22,7 @@
    entt -  2.4.1 +  2.4.2
    diff --git a/structentt_1_1entt__traits.html b/structentt_1_1entt__traits.html index f51ddd65e..ef8a0fa76 100644 --- a/structentt_1_1entt__traits.html +++ b/structentt_1_1entt__traits.html @@ -22,7 +22,7 @@
    entt -  2.4.1 +  2.4.2
    @@ -71,7 +71,7 @@ $(function() {

    Entity traits. More...

    -

    #include <traits.hpp>

    +

    #include <entt_traits.hpp>

    Detailed Description

    template<typename>
    struct entt::entt_traits< typename >

    @@ -79,9 +79,9 @@ struct entt::entt_traits< typename >

    Entity traits.

    Primary template isn't defined on purpose. All the specializations give a compile-time error unless the template parameter is an accepted entity type.

    -

    Definition at line 18 of file traits.hpp.

    +

    Definition at line 18 of file entt_traits.hpp.

    The documentation for this struct was generated from the following file: diff --git a/structentt_1_1entt__traits_3_01std_1_1uint16__t_01_4-members.html b/structentt_1_1entt__traits_3_01std_1_1uint16__t_01_4-members.html index 54a1732ed..34ee8130e 100644 --- a/structentt_1_1entt__traits_3_01std_1_1uint16__t_01_4-members.html +++ b/structentt_1_1entt__traits_3_01std_1_1uint16__t_01_4-members.html @@ -22,7 +22,7 @@
    entt -  2.4.1 +  2.4.2
    diff --git a/structentt_1_1entt__traits_3_01std_1_1uint16__t_01_4.html b/structentt_1_1entt__traits_3_01std_1_1uint16__t_01_4.html index 3f27f061c..1e13d0e8d 100644 --- a/structentt_1_1entt__traits_3_01std_1_1uint16__t_01_4.html +++ b/structentt_1_1entt__traits_3_01std_1_1uint16__t_01_4.html @@ -22,7 +22,7 @@
    entt -  2.4.1 +  2.4.2
    @@ -75,7 +75,7 @@ $(function() {

    Entity traits for a 16 bits entity identifier. More...

    -

    #include <traits.hpp>

    +

    #include <entt_traits.hpp>

    @@ -114,9 +114,9 @@ struct entt::entt_traits< std::uint16_t >
  • 4 bit for the version (resets in [0-15]).
    • -

    Definition at line 30 of file traits.hpp.

    +

    Definition at line 30 of file entt_traits.hpp.

    The documentation for this struct was generated from the following file: diff --git a/structentt_1_1entt__traits_3_01std_1_1uint32__t_01_4-members.html b/structentt_1_1entt__traits_3_01std_1_1uint32__t_01_4-members.html index 2857836c1..b16a12774 100644 --- a/structentt_1_1entt__traits_3_01std_1_1uint32__t_01_4-members.html +++ b/structentt_1_1entt__traits_3_01std_1_1uint32__t_01_4-members.html @@ -22,7 +22,7 @@ diff --git a/structentt_1_1entt__traits_3_01std_1_1uint32__t_01_4.html b/structentt_1_1entt__traits_3_01std_1_1uint32__t_01_4.html index 0ee3d5387..eef23a88b 100644 --- a/structentt_1_1entt__traits_3_01std_1_1uint32__t_01_4.html +++ b/structentt_1_1entt__traits_3_01std_1_1uint32__t_01_4.html @@ -22,7 +22,7 @@ @@ -75,7 +75,7 @@ $(function() {

    Entity traits for a 32 bits entity identifier. More...

    -

    #include <traits.hpp>

    +

    #include <entt_traits.hpp>

    Public Types

    entt -  2.4.1 +  2.4.2
    entt -  2.4.1 +  2.4.2
    @@ -114,9 +114,9 @@ struct entt::entt_traits< std::uint32_t >
  • 8 bit for the version (resets in [0-255]).
    • -

    Definition at line 54 of file traits.hpp.

    +

    Definition at line 54 of file entt_traits.hpp.

    The documentation for this struct was generated from the following file: diff --git a/structentt_1_1entt__traits_3_01std_1_1uint64__t_01_4-members.html b/structentt_1_1entt__traits_3_01std_1_1uint64__t_01_4-members.html index 5b9269649..2a49ae548 100644 --- a/structentt_1_1entt__traits_3_01std_1_1uint64__t_01_4-members.html +++ b/structentt_1_1entt__traits_3_01std_1_1uint64__t_01_4-members.html @@ -22,7 +22,7 @@ diff --git a/structentt_1_1entt__traits_3_01std_1_1uint64__t_01_4.html b/structentt_1_1entt__traits_3_01std_1_1uint64__t_01_4.html index 128702c67..0bb210648 100644 --- a/structentt_1_1entt__traits_3_01std_1_1uint64__t_01_4.html +++ b/structentt_1_1entt__traits_3_01std_1_1uint64__t_01_4.html @@ -22,7 +22,7 @@ @@ -75,7 +75,7 @@ $(function() {

    Entity traits for a 64 bits entity identifier. More...

    -

    #include <traits.hpp>

    +

    #include <entt_traits.hpp>

    Public Types

    entt -  2.4.1 +  2.4.2
    entt -  2.4.1 +  2.4.2
    @@ -114,9 +114,9 @@ struct entt::entt_traits< std::uint64_t >
  • 24 bit for the version (an indecently large number).
    • -

    Definition at line 78 of file traits.hpp.

    +

    Definition at line 78 of file entt_traits.hpp.

    The documentation for this struct was generated from the following file: diff --git a/traits_8hpp_source.html b/traits_8hpp_source.html deleted file mode 100644 index 2a27dc1e3..000000000 --- a/traits_8hpp_source.html +++ /dev/null @@ -1,86 +0,0 @@ - - - - - - - -entt: src/entt/entity/traits.hpp Source File - - - - - - - - - -
    -
    -

    Public Types

    - - - - - -
    -
    entt -  2.4.1 -
    -
    - - - - - - - - - -
    -
    - - -
    - -
    - - - -
    -
    -
    traits.hpp
    -
    -
    -
    1 #ifndef ENTT_ENTITY_ENTT_HPP
    2 #define ENTT_ENTITY_ENTT_HPP
    3 
    4 
    5 #include <cstdint>
    6 
    7 
    8 namespace entt {
    9 
    10 
    17 template<typename>
    18 struct entt_traits;
    19 
    20 
    29 template<>
    30 struct entt_traits<std::uint16_t> {
    32  using entity_type = std::uint16_t;
    34  using version_type = std::uint8_t;
    35 
    37  static constexpr auto entity_mask = 0xFFF;
    39  static constexpr auto version_mask = 0xF;
    41  static constexpr auto entity_shift = 12;
    42 };
    43 
    44 
    53 template<>
    54 struct entt_traits<std::uint32_t> {
    56  using entity_type = std::uint32_t;
    58  using version_type = std::uint16_t;
    59 
    61  static constexpr auto entity_mask = 0xFFFFFF;
    63  static constexpr auto version_mask = 0xFF;
    65  static constexpr auto entity_shift = 24;
    66 };
    67 
    68 
    77 template<>
    78 struct entt_traits<std::uint64_t> {
    80  using entity_type = std::uint64_t;
    82  using version_type = std::uint32_t;
    83 
    85  static constexpr auto entity_mask = 0xFFFFFFFFFF;
    87  static constexpr auto version_mask = 0xFFFFFF;
    89  static constexpr auto entity_shift = 40;
    90 };
    91 
    92 
    93 }
    94 
    95 
    96 #endif // ENTT_ENTITY_ENTT_HPP
    entt::entt_traits< std::uint32_t >::entity_type
    std::uint32_t entity_type
    Underlying entity type.
    Definition: traits.hpp:56
    -
    entt::entt_traits< std::uint64_t >::entity_type
    std::uint64_t entity_type
    Underlying entity type.
    Definition: traits.hpp:80
    -
    entt
    EnTT default namespace.
    Definition: family.hpp:9
    -
    entt::entt_traits< std::uint16_t >::entity_type
    std::uint16_t entity_type
    Underlying entity type.
    Definition: traits.hpp:32
    -
    entt::entt_traits< std::uint64_t >::version_type
    std::uint32_t version_type
    Underlying version type.
    Definition: traits.hpp:82
    -
    entt::entt_traits< std::uint16_t >::version_type
    std::uint8_t version_type
    Underlying version type.
    Definition: traits.hpp:34
    -
    entt::entt_traits< std::uint32_t >::version_type
    std::uint16_t version_type
    Underlying version type.
    Definition: traits.hpp:58
    -
    entt::entt_traits
    Entity traits.
    Definition: traits.hpp:18
    -
    - -
    -Generated by   -doxygen - 1.8.13 -
    - - diff --git a/view_8hpp_source.html b/view_8hpp_source.html index e171a3c50..53012f913 100644 --- a/view_8hpp_source.html +++ b/view_8hpp_source.html @@ -22,7 +22,7 @@
    entt -  2.4.1 +  2.4.2
    @@ -67,53 +67,53 @@ $(function() {
    view.hpp
    -
    1 #ifndef ENTT_ENTITY_VIEW_HPP
    2 #define ENTT_ENTITY_VIEW_HPP
    3 
    4 
    5 #include <tuple>
    6 #include <utility>
    7 #include <algorithm>
    8 #include "sparse_set.hpp"
    9 
    10 
    11 namespace entt {
    12 
    13 
    53 template<typename Entity, typename... Component>
    54 class PersistentView final {
    55  static_assert(sizeof...(Component) > 1, "!");
    56 
    57  template<typename Comp>
    58  using pool_type = SparseSet<Entity, Comp>;
    59 
    60  using view_type = SparseSet<Entity>;
    61 
    62 public:
    64  using iterator_type = typename view_type::iterator_type;
    66  using entity_type = typename view_type::entity_type;
    68  using size_type = typename view_type::size_type;
    69 
    82  PersistentView(view_type &view, pool_type<Component>&... pools) noexcept
    83  : view{view}, pools{pools...}
    84  {}
    85 
    90  size_type size() const noexcept {
    91  return view.size();
    92  }
    93 
    106  const entity_type * data() const noexcept {
    107  return view.data();
    108  }
    109 
    124  iterator_type begin() const noexcept {
    125  return view.begin();
    126  }
    127 
    143  iterator_type end() const noexcept {
    144  return view.end();
    145  }
    146 
    164  template<typename Comp>
    165  const Comp & get(entity_type entity) const noexcept {
    166  return std::get<pool_type<Comp> &>(pools).get(entity);
    167  }
    168 
    186  template<typename Comp>
    187  Comp & get(entity_type entity) noexcept {
    188  return const_cast<Comp &>(const_cast<const PersistentView *>(this)->get<Comp>(entity));
    189  }
    190 
    206  template<typename Func>
    207  void each(Func func) const {
    208  for(auto entity: *this) {
    209  func(entity, get<Component>(entity)...);
    210  }
    211  }
    212 
    228  template<typename Func>
    229  void each(Func func) {
    230  const_cast<const PersistentView *>(this)->each([&func](entity_type entity, const Component &... component) {
    231  func(entity, const_cast<Component &>(component)...);
    232  });
    233  }
    234 
    251  template<typename Comp>
    252  void sort() {
    253  view.respect(std::get<pool_type<Comp> &>(pools));
    254  }
    255 
    256 private:
    257  view_type &view;
    258  std::tuple<pool_type<Component> &...> pools;
    259 };
    260 
    261 
    300 template<typename Entity, typename... Component>
    301 class View final {
    302  static_assert(sizeof...(Component) > 1, "!");
    303 
    304  template<typename Comp>
    305  using pool_type = SparseSet<Entity, Comp>;
    306 
    307  using base_pool_type = SparseSet<Entity>;
    308  using underlying_iterator_type = typename base_pool_type::iterator_type;
    309  using repo_type = std::tuple<pool_type<Component> &...>;
    310 
    311  class Iterator {
    312  inline bool valid() const noexcept {
    313  using accumulator_type = bool[];
    314  auto entity = *begin;
    315  bool all = true;
    316  accumulator_type accumulator = { all, (all = all && std::get<pool_type<Component> &>(pools).has(entity))... };
    317  (void)accumulator;
    318  return all;
    319  }
    320 
    321  public:
    322  using value_type = typename base_pool_type::entity_type;
    323 
    324  Iterator(const repo_type &pools, underlying_iterator_type begin, underlying_iterator_type end) noexcept
    325  : pools{pools}, begin{begin}, end{end}
    326  {
    327  if(begin != end && !valid()) {
    328  ++(*this);
    329  }
    330  }
    331 
    332  Iterator & operator++() noexcept {
    333  ++begin;
    334  while(begin != end && !valid()) { ++begin; }
    335  return *this;
    336  }
    337 
    338  Iterator operator++(int) noexcept {
    339  Iterator orig = *this;
    340  return ++(*this), orig;
    341  }
    342 
    343  bool operator==(const Iterator &other) const noexcept {
    344  return other.begin == begin;
    345  }
    346 
    347  bool operator!=(const Iterator &other) const noexcept {
    348  return !(*this == other);
    349  }
    350 
    351  value_type operator*() const noexcept {
    352  return *begin;
    353  }
    354 
    355  private:
    356  const repo_type &pools;
    357  underlying_iterator_type begin;
    358  underlying_iterator_type end;
    359  };
    360 
    361 public:
    363  using iterator_type = Iterator;
    365  using entity_type = typename base_pool_type::entity_type;
    367  using size_type = typename base_pool_type::size_type;
    368 
    373  View(pool_type<Component>&... pools) noexcept
    374  : pools{pools...}, view{nullptr}
    375  {
    376  reset();
    377  }
    378 
    393  iterator_type begin() const noexcept {
    394  return Iterator{pools, view->begin(), view->end()};
    395  }
    396 
    412  iterator_type end() const noexcept {
    413  return Iterator{pools, view->end(), view->end()};
    414  }
    415 
    433  template<typename Comp>
    434  const Comp & get(entity_type entity) const noexcept {
    435  return std::get<pool_type<Comp> &>(pools).get(entity);
    436  }
    437 
    455  template<typename Comp>
    456  Comp & get(entity_type entity) noexcept {
    457  return const_cast<Comp &>(const_cast<const View *>(this)->get<Comp>(entity));
    458  }
    459 
    475  template<typename Func>
    476  void each(Func func) const {
    477  for(auto entity: *this) {
    478  func(entity, get<Component>(entity)...);
    479  }
    480  }
    481 
    497  template<typename Func>
    498  void each(Func func) {
    499  const_cast<const View *>(this)->each([&func](entity_type entity, const Component &... component) {
    500  func(entity, const_cast<Component &>(component)...);
    501  });
    502  }
    503 
    514  void reset() {
    515  using accumulator_type = size_type[];
    516  auto probe = [this](auto sz, auto &pool) { return pool.size() < sz ? (view = &pool, pool.size()) : sz; };
    517  size_type sz = std::max({ std::get<pool_type<Component> &>(pools).size()... }) + std::size_t{1};
    518  accumulator_type accumulator = { sz, (sz = probe(sz, std::get<pool_type<Component> &>(pools)))... };
    519  (void)accumulator;
    520  }
    521 
    522 private:
    523  repo_type pools;
    524  base_pool_type *view;
    525 };
    526 
    527 
    564 template<typename Entity, typename Component>
    565 class View<Entity, Component> final {
    566  using pool_type = SparseSet<Entity, Component>;
    567 
    568 public:
    570  using iterator_type = typename pool_type::iterator_type;
    572  using entity_type = typename pool_type::entity_type;
    574  using size_type = typename pool_type::size_type;
    576  using raw_type = typename pool_type::object_type;
    577 
    582  View(pool_type &pool) noexcept
    583  : pool{pool}
    584  {}
    585 
    590  size_type size() const noexcept {
    591  return pool.size();
    592  }
    593 
    606  raw_type * raw() noexcept {
    607  return pool.raw();
    608  }
    609 
    622  const raw_type * raw() const noexcept {
    623  return pool.raw();
    624  }
    625 
    638  const entity_type * data() const noexcept {
    639  return pool.data();
    640  }
    641 
    656  iterator_type begin() const noexcept {
    657  return pool.begin();
    658  }
    659 
    675  iterator_type end() const noexcept {
    676  return pool.end();
    677  }
    678 
    694  const Component & get(entity_type entity) const noexcept {
    695  return pool.get(entity);
    696  }
    697 
    713  Component & get(entity_type entity) noexcept {
    714  return const_cast<Component &>(const_cast<const View *>(this)->get(entity));
    715  }
    716 
    731  template<typename Func>
    732  void each(Func func) const {
    733  for(auto entity: *this) {
    734  func(entity, get(entity));
    735  }
    736  }
    737 
    752  template<typename Func>
    753  void each(Func func) {
    754  const_cast<const View *>(this)->each([&func](entity_type entity, const Component &component) {
    755  func(entity, const_cast<Component &>(component));
    756  });
    757  }
    758 
    759 private:
    760  pool_type &pool;
    761 };
    762 
    763 
    764 }
    765 
    766 
    767 #endif // ENTT_ENTITY_VIEW_HPP
    entt::View< Entity, Component >::size
    size_type size() const noexcept
    Returns the number of entities that have the given component.
    Definition: view.hpp:590
    -
    entt::View< Entity, Component >::size_type
    typename pool_type::size_type size_type
    Unsigned integer type.
    Definition: view.hpp:574
    -
    entt::PersistentView::entity_type
    typename view_type::entity_type entity_type
    Underlying entity identifier.
    Definition: view.hpp:66
    -
    entt::PersistentView::size
    size_type size() const noexcept
    Returns the number of entities that have the given components.
    Definition: view.hpp:90
    -
    entt::View::View
    View(pool_type< Component > &... pools) noexcept
    Constructs a view out of a bunch of pools of components.
    Definition: view.hpp:373
    -
    entt::View< Entity, Component >::iterator_type
    typename pool_type::iterator_type iterator_type
    Definition: view.hpp:570
    -
    entt::PersistentView::each
    void each(Func func)
    Iterate the entities and applies them the given function object.
    Definition: view.hpp:229
    -
    entt::View< Entity, Component >::raw
    raw_type * raw() noexcept
    Direct access to the list of components.
    Definition: view.hpp:606
    -
    entt::View< Entity, Component >::raw
    const raw_type * raw() const noexcept
    Direct access to the list of components.
    Definition: view.hpp:622
    -
    entt::View::size_type
    typename base_pool_type::size_type size_type
    Unsigned integer type.
    Definition: view.hpp:367
    +
    1 #ifndef ENTT_ENTITY_VIEW_HPP
    2 #define ENTT_ENTITY_VIEW_HPP
    3 
    4 
    5 #include <tuple>
    6 #include <utility>
    7 #include <algorithm>
    8 #include <type_traits>
    9 #include "sparse_set.hpp"
    10 
    11 
    12 namespace entt {
    13 
    14 
    54 template<typename Entity, typename... Component>
    55 class PersistentView final {
    56  static_assert(sizeof...(Component) > 1, "!");
    57 
    58  template<typename Comp>
    59  using pool_type = SparseSet<Entity, Comp>;
    60 
    61  using view_type = SparseSet<Entity>;
    62 
    63 public:
    65  using iterator_type = typename view_type::iterator_type;
    67  using entity_type = typename view_type::entity_type;
    69  using size_type = typename view_type::size_type;
    70 
    83  PersistentView(view_type &view, pool_type<Component>&... pools) noexcept
    84  : view{view}, pools{pools...}
    85  {}
    86 
    91  size_type size() const noexcept {
    92  return view.size();
    93  }
    94 
    107  const entity_type * data() const noexcept {
    108  return view.data();
    109  }
    110 
    125  iterator_type begin() const noexcept {
    126  return view.begin();
    127  }
    128 
    144  iterator_type end() const noexcept {
    145  return view.end();
    146  }
    147 
    165  template<typename Comp>
    166  const Comp & get(entity_type entity) const noexcept {
    167  return std::get<pool_type<Comp> &>(pools).get(entity);
    168  }
    169 
    187  template<typename Comp>
    188  Comp & get(entity_type entity) noexcept {
    189  return const_cast<Comp &>(const_cast<const PersistentView *>(this)->get<Comp>(entity));
    190  }
    191 
    209  template<typename... Comp>
    210  std::enable_if_t<(sizeof...(Comp) > 1), std::tuple<const Comp &...>>
    211  get(entity_type entity) const noexcept {
    212  return std::tuple<const Comp &...>{ get<Comp>(entity)... };
    213  }
    214 
    232  template<typename... Comp>
    233  std::enable_if_t<(sizeof...(Comp) > 1), std::tuple<Comp &...>>
    234  get(entity_type entity) noexcept {
    235  return std::tuple<Comp &...>{ get<Comp>(entity)... };
    236  }
    237 
    253  template<typename Func>
    254  void each(Func func) const {
    255  for(auto entity: *this) {
    256  func(entity, get<Component>(entity)...);
    257  }
    258  }
    259 
    275  template<typename Func>
    276  void each(Func func) {
    277  const_cast<const PersistentView *>(this)->each([&func](entity_type entity, const Component &... component) {
    278  func(entity, const_cast<Component &>(component)...);
    279  });
    280  }
    281 
    298  template<typename Comp>
    299  void sort() {
    300  view.respect(std::get<pool_type<Comp> &>(pools));
    301  }
    302 
    303 private:
    304  view_type &view;
    305  std::tuple<pool_type<Component> &...> pools;
    306 };
    307 
    308 
    347 template<typename Entity, typename... Component>
    348 class View final {
    349  static_assert(sizeof...(Component) > 1, "!");
    350 
    351  template<typename Comp>
    352  using pool_type = SparseSet<Entity, Comp>;
    353 
    354  using base_pool_type = SparseSet<Entity>;
    355  using underlying_iterator_type = typename base_pool_type::iterator_type;
    356  using repo_type = std::tuple<pool_type<Component> &...>;
    357 
    358  class Iterator {
    359  inline bool valid() const noexcept {
    360  using accumulator_type = bool[];
    361  auto entity = *begin;
    362  bool all = true;
    363  accumulator_type accumulator = { all, (all = all && std::get<pool_type<Component> &>(pools).has(entity))... };
    364  (void)accumulator;
    365  return all;
    366  }
    367 
    368  public:
    369  using value_type = typename base_pool_type::entity_type;
    370 
    371  Iterator(const repo_type &pools, underlying_iterator_type begin, underlying_iterator_type end) noexcept
    372  : pools{pools}, begin{begin}, end{end}
    373  {
    374  if(begin != end && !valid()) {
    375  ++(*this);
    376  }
    377  }
    378 
    379  Iterator & operator++() noexcept {
    380  ++begin;
    381  while(begin != end && !valid()) { ++begin; }
    382  return *this;
    383  }
    384 
    385  Iterator operator++(int) noexcept {
    386  Iterator orig = *this;
    387  return ++(*this), orig;
    388  }
    389 
    390  bool operator==(const Iterator &other) const noexcept {
    391  return other.begin == begin;
    392  }
    393 
    394  bool operator!=(const Iterator &other) const noexcept {
    395  return !(*this == other);
    396  }
    397 
    398  value_type operator*() const noexcept {
    399  return *begin;
    400  }
    401 
    402  private:
    403  const repo_type &pools;
    404  underlying_iterator_type begin;
    405  underlying_iterator_type end;
    406  };
    407 
    408 public:
    410  using iterator_type = Iterator;
    412  using entity_type = typename base_pool_type::entity_type;
    414  using size_type = typename base_pool_type::size_type;
    415 
    420  View(pool_type<Component>&... pools) noexcept
    421  : pools{pools...}, view{nullptr}
    422  {
    423  reset();
    424  }
    425 
    440  iterator_type begin() const noexcept {
    441  return Iterator{pools, view->begin(), view->end()};
    442  }
    443 
    459  iterator_type end() const noexcept {
    460  return Iterator{pools, view->end(), view->end()};
    461  }
    462 
    480  template<typename Comp>
    481  const Comp & get(entity_type entity) const noexcept {
    482  return std::get<pool_type<Comp> &>(pools).get(entity);
    483  }
    484 
    502  template<typename Comp>
    503  Comp & get(entity_type entity) noexcept {
    504  return const_cast<Comp &>(const_cast<const View *>(this)->get<Comp>(entity));
    505  }
    506 
    524  template<typename... Comp>
    525  std::enable_if_t<(sizeof...(Comp) > 1), std::tuple<const Comp &...>>
    526  get(entity_type entity) const noexcept {
    527  return std::tuple<const Comp &...>{ get<Comp>(entity)... };
    528  }
    529 
    547  template<typename... Comp>
    548  std::enable_if_t<(sizeof...(Comp) > 1), std::tuple<Comp &...>>
    549  get(entity_type entity) noexcept {
    550  return std::tuple<Comp &...>{ get<Comp>(entity)... };
    551  }
    552 
    568  template<typename Func>
    569  void each(Func func) const {
    570  for(auto entity: *this) {
    571  func(entity, get<Component>(entity)...);
    572  }
    573  }
    574 
    590  template<typename Func>
    591  void each(Func func) {
    592  const_cast<const View *>(this)->each([&func](entity_type entity, const Component &... component) {
    593  func(entity, const_cast<Component &>(component)...);
    594  });
    595  }
    596 
    607  void reset() {
    608  using accumulator_type = size_type[];
    609  auto probe = [this](auto sz, auto &pool) { return pool.size() < sz ? (view = &pool, pool.size()) : sz; };
    610  size_type sz = std::max({ std::get<pool_type<Component> &>(pools).size()... }) + std::size_t{1};
    611  accumulator_type accumulator = { sz, (sz = probe(sz, std::get<pool_type<Component> &>(pools)))... };
    612  (void)accumulator;
    613  }
    614 
    615 private:
    616  repo_type pools;
    617  base_pool_type *view;
    618 };
    619 
    620 
    657 template<typename Entity, typename Component>
    658 class View<Entity, Component> final {
    659  using pool_type = SparseSet<Entity, Component>;
    660 
    661 public:
    663  using iterator_type = typename pool_type::iterator_type;
    665  using entity_type = typename pool_type::entity_type;
    667  using size_type = typename pool_type::size_type;
    669  using raw_type = typename pool_type::object_type;
    670 
    675  View(pool_type &pool) noexcept
    676  : pool{pool}
    677  {}
    678 
    683  size_type size() const noexcept {
    684  return pool.size();
    685  }
    686 
    699  raw_type * raw() noexcept {
    700  return pool.raw();
    701  }
    702 
    715  const raw_type * raw() const noexcept {
    716  return pool.raw();
    717  }
    718 
    731  const entity_type * data() const noexcept {
    732  return pool.data();
    733  }
    734 
    749  iterator_type begin() const noexcept {
    750  return pool.begin();
    751  }
    752 
    768  iterator_type end() const noexcept {
    769  return pool.end();
    770  }
    771 
    787  const Component & get(entity_type entity) const noexcept {
    788  return pool.get(entity);
    789  }
    790 
    806  Component & get(entity_type entity) noexcept {
    807  return const_cast<Component &>(const_cast<const View *>(this)->get(entity));
    808  }
    809 
    824  template<typename Func>
    825  void each(Func func) const {
    826  for(auto entity: *this) {
    827  func(entity, get(entity));
    828  }
    829  }
    830 
    845  template<typename Func>
    846  void each(Func func) {
    847  const_cast<const View *>(this)->each([&func](entity_type entity, const Component &component) {
    848  func(entity, const_cast<Component &>(component));
    849  });
    850  }
    851 
    852 private:
    853  pool_type &pool;
    854 };
    855 
    856 
    857 }
    858 
    859 
    860 #endif // ENTT_ENTITY_VIEW_HPP
    entt::View< Entity, Component >::size
    size_type size() const noexcept
    Returns the number of entities that have the given component.
    Definition: view.hpp:683
    +
    entt::View< Entity, Component >::size_type
    typename pool_type::size_type size_type
    Unsigned integer type.
    Definition: view.hpp:667
    +
    entt::PersistentView::entity_type
    typename view_type::entity_type entity_type
    Underlying entity identifier.
    Definition: view.hpp:67
    +
    entt::PersistentView::size
    size_type size() const noexcept
    Returns the number of entities that have the given components.
    Definition: view.hpp:91
    +
    entt::View::View
    View(pool_type< Component > &... pools) noexcept
    Constructs a view out of a bunch of pools of components.
    Definition: view.hpp:420
    +
    entt::View< Entity, Component >::iterator_type
    typename pool_type::iterator_type iterator_type
    Definition: view.hpp:663
    +
    entt::PersistentView::each
    void each(Func func)
    Iterate the entities and applies them the given function object.
    Definition: view.hpp:276
    +
    entt::View< Entity, Component >::raw
    raw_type * raw() noexcept
    Direct access to the list of components.
    Definition: view.hpp:699
    +
    entt::View< Entity, Component >::raw
    const raw_type * raw() const noexcept
    Direct access to the list of components.
    Definition: view.hpp:715
    +
    entt::View::size_type
    typename base_pool_type::size_type size_type
    Unsigned integer type.
    Definition: view.hpp:414
    entt
    EnTT default namespace.
    Definition: family.hpp:9
    -
    entt::View< Entity, Component >::raw_type
    typename pool_type::object_type raw_type
    Definition: view.hpp:576
    -
    entt::View< Entity, Component >::end
    iterator_type end() const noexcept
    Returns an iterator that is past the last entity that has the given component.
    Definition: view.hpp:675
    +
    entt::View< Entity, Component >::raw_type
    typename pool_type::object_type raw_type
    Definition: view.hpp:669
    +
    entt::View< Entity, Component >::end
    iterator_type end() const noexcept
    Returns an iterator that is past the last entity that has the given component.
    Definition: view.hpp:768
    entt::SparseSet
    Sparse set.
    Definition: sparse_set.hpp:25
    -
    entt::View< Entity, Component >::each
    void each(Func func)
    Iterate the entities and applies them the given function object.
    Definition: view.hpp:753
    +
    entt::View< Entity, Component >::each
    void each(Func func)
    Iterate the entities and applies them the given function object.
    Definition: view.hpp:846
    entt::SparseSet< Entity >::size_type
    std::size_t size_type
    Unsigned integer type.
    Definition: sparse_set.hpp:100
    -
    entt::PersistentView::end
    iterator_type end() const noexcept
    Returns an iterator that is past the last entity that has the given components.
    Definition: view.hpp:143
    -
    entt::View::end
    iterator_type end() const noexcept
    Returns an iterator that is past the last entity that has the given components.
    Definition: view.hpp:412
    +
    entt::PersistentView::end
    iterator_type end() const noexcept
    Returns an iterator that is past the last entity that has the given components.
    Definition: view.hpp:144
    +
    entt::View::end
    iterator_type end() const noexcept
    Returns an iterator that is past the last entity that has the given components.
    Definition: view.hpp:459
    entt::SparseSet< Entity >::entity_type
    Entity entity_type
    Underlying entity identifier.
    Definition: sparse_set.hpp:96
    entt::SparseSet< Entity >::iterator_type
    Iterator iterator_type
    Input iterator type.
    Definition: sparse_set.hpp:102
    -
    entt::View< Entity, Component >::entity_type
    typename pool_type::entity_type entity_type
    Underlying entity identifier.
    Definition: view.hpp:572
    +
    entt::View< Entity, Component >::entity_type
    typename pool_type::entity_type entity_type
    Underlying entity identifier.
    Definition: view.hpp:665
    entt::SparseSet< Entity >
    Basic sparse set implementation.
    Definition: sparse_set.hpp:56
    entt::SparseSet< Entity >::data
    const entity_type * data() const noexcept
    Direct access to the internal packed array.
    Definition: sparse_set.hpp:170
    entt::SparseSet< Entity >::end
    iterator_type end() const noexcept
    Returns an iterator to the end.
    Definition: sparse_set.hpp:203
    -
    entt::View< Entity, Component >::each
    void each(Func func) const
    Iterate the entities and applies them the given function object.
    Definition: view.hpp:732
    -
    entt::View< Entity, Component >::data
    const entity_type * data() const noexcept
    Direct access to the list of entities.
    Definition: view.hpp:638
    -
    entt::View::iterator_type
    Iterator iterator_type
    Definition: view.hpp:363
    -
    entt::View< Entity, Component >::begin
    iterator_type begin() const noexcept
    Returns an iterator to the first entity that has the given component.
    Definition: view.hpp:656
    -
    entt::PersistentView::iterator_type
    typename view_type::iterator_type iterator_type
    Definition: view.hpp:64
    -
    entt::PersistentView::sort
    void sort()
    Sort the shared pool of entities according to the given component.
    Definition: view.hpp:252
    -
    entt::View::begin
    iterator_type begin() const noexcept
    Returns an iterator to the first entity that has the given components.
    Definition: view.hpp:393
    -
    entt::PersistentView::data
    const entity_type * data() const noexcept
    Direct access to the list of entities.
    Definition: view.hpp:106
    -
    entt::View
    Multi component view.
    Definition: view.hpp:301
    +
    entt::View< Entity, Component >::each
    void each(Func func) const
    Iterate the entities and applies them the given function object.
    Definition: view.hpp:825
    +
    entt::View< Entity, Component >::data
    const entity_type * data() const noexcept
    Direct access to the list of entities.
    Definition: view.hpp:731
    +
    entt::View::iterator_type
    Iterator iterator_type
    Definition: view.hpp:410
    +
    entt::View< Entity, Component >::begin
    iterator_type begin() const noexcept
    Returns an iterator to the first entity that has the given component.
    Definition: view.hpp:749
    +
    entt::PersistentView::iterator_type
    typename view_type::iterator_type iterator_type
    Definition: view.hpp:65
    +
    entt::PersistentView::sort
    void sort()
    Sort the shared pool of entities according to the given component.
    Definition: view.hpp:299
    +
    entt::View::begin
    iterator_type begin() const noexcept
    Returns an iterator to the first entity that has the given components.
    Definition: view.hpp:440
    +
    entt::PersistentView::data
    const entity_type * data() const noexcept
    Direct access to the list of entities.
    Definition: view.hpp:107
    +
    entt::View
    Multi component view.
    Definition: view.hpp:348
    entt::SparseSet< Entity >::begin
    iterator_type begin() const noexcept
    Returns an iterator to the beginning.
    Definition: sparse_set.hpp:186
    -
    entt::PersistentView
    Persistent view.
    Definition: view.hpp:54
    -
    entt::PersistentView::PersistentView
    PersistentView(view_type &view, pool_type< Component > &... pools) noexcept
    Constructs a persistent view around a dedicated pool of entities.
    Definition: view.hpp:82
    +
    entt::PersistentView
    Persistent view.
    Definition: view.hpp:55
    +
    entt::PersistentView::PersistentView
    PersistentView(view_type &view, pool_type< Component > &... pools) noexcept
    Constructs a persistent view around a dedicated pool of entities.
    Definition: view.hpp:83
    entt::SparseSet< Entity >::size
    size_type size() const noexcept
    Returns the number of elements in a sparse set.
    Definition: sparse_set.hpp:143
    -
    entt::PersistentView::begin
    iterator_type begin() const noexcept
    Returns an iterator to the first entity that has the given components.
    Definition: view.hpp:124
    -
    entt::View::each
    void each(Func func)
    Iterate the entities and applies them the given function object.
    Definition: view.hpp:498
    -
    entt::View::entity_type
    typename base_pool_type::entity_type entity_type
    Underlying entity identifier.
    Definition: view.hpp:365
    -
    entt::operator!=
    constexpr bool operator!=(const HashedString &lhs, const HashedString &rhs) noexcept
    Compares two hashed strings.
    Definition: hashed_string.hpp:101
    +
    entt::PersistentView::begin
    iterator_type begin() const noexcept
    Returns an iterator to the first entity that has the given components.
    Definition: view.hpp:125
    +
    entt::View::each
    void each(Func func)
    Iterate the entities and applies them the given function object.
    Definition: view.hpp:591
    +
    entt::View::entity_type
    typename base_pool_type::entity_type entity_type
    Underlying entity identifier.
    Definition: view.hpp:412
    +
    entt::operator!=
    constexpr bool operator!=(const HashedString &lhs, const HashedString &rhs) noexcept
    Compares two hashed strings.
    Definition: hashed_string.hpp:102
    entt::SparseSet< Entity >::respect
    virtual void respect(const SparseSet< Entity > &other) noexcept
    Sort entities according to their order in another sparse set.
    Definition: sparse_set.hpp:334
    -
    entt::View::each
    void each(Func func) const
    Iterate the entities and applies them the given function object.
    Definition: view.hpp:476
    -
    entt::View< Entity, Component >::View
    View(pool_type &pool) noexcept
    Constructs a view out of a pool of components.
    Definition: view.hpp:582
    -
    entt::PersistentView::each
    void each(Func func) const
    Iterate the entities and applies them the given function object.
    Definition: view.hpp:207
    -
    entt::View::reset
    void reset()
    Resets the view and reinitializes it.
    Definition: view.hpp:514
    -
    entt::PersistentView::size_type
    typename view_type::size_type size_type
    Unsigned integer type.
    Definition: view.hpp:68
    +
    entt::View::each
    void each(Func func) const
    Iterate the entities and applies them the given function object.
    Definition: view.hpp:569
    +
    entt::View< Entity, Component >::View
    View(pool_type &pool) noexcept
    Constructs a view out of a pool of components.
    Definition: view.hpp:675
    +
    entt::PersistentView::each
    void each(Func func) const
    Iterate the entities and applies them the given function object.
    Definition: view.hpp:254
    +
    entt::View::reset
    void reset()
    Resets the view and reinitializes it.
    Definition: view.hpp:607
    +
    entt::PersistentView::size_type
    typename view_type::size_type size_type
    Unsigned integer type.
    Definition: view.hpp:69