diff --git a/CONTRIBUTING_8md_source.html b/CONTRIBUTING_8md_source.html new file mode 100644 index 000000000..980dcb744 --- /dev/null +++ b/CONTRIBUTING_8md_source.html @@ -0,0 +1,74 @@ + + + + + + + +EnTT: docs/CONTRIBUTING.md Source File + + + + + + + + + +
+
+ + + + + + +
+
EnTT +  2.7.2 +
+
+
+ + + + + + + +
+ +
+
+ + +
+ +
+ +
+
+
docs/CONTRIBUTING.md
+
+
+
1 # Contributing
2 
3 First of all, thank you very much for taking the time to contribute to the
4 `EnTT` framework.<br/>
5 How to do it mostly depends on the type of contribution:
6 
7 * If you have a question, **please** ensure there isn't already an answer for
8  you by searching on GitHub under
9  [issues](https://github.com/skypjack/entt/issues). Do not forget to search
10  also through the closed ones. If you are unable to find a proper answer, feel
11  free to [open a new issue](https://github.com/skypjack/entt/issues/new).
12  Usually, questions are marked as such and closed in a few days.
13 
14 * If you want to fix a typo in the inline documentation or in the README file,
15  if you want to add some new sections or if you want to help me with the
16  language by reviewing what I wrote so far (I'm not a native speaker after
17  all), **please** open a new
18  [pull request](https://github.com/skypjack/entt/pulls) with your changes.
19 
20 * If you found a bug, **please** ensure there isn't already an answer for you by
21  searching on GitHub under [issues](https://github.com/skypjack/entt/issues).
22  If you are unable to find an open issue addressing the problem, feel free to
23  [open a new one](https://github.com/skypjack/entt/issues/new). **Please**, do
24  not forget to carefully describe how to reproduce the problem, then add all
25  the informaion about the system on which you are experiencing it and point out
26  the version of `EnTT` you are using (tag or commit).
27 
28 * If you found a bug and you wrote a patch to fix it, open a new
29  [pull request](https://github.com/skypjack/entt/pulls) with your code.
30  **Please**, add some tests to avoid regressions in future if possible, it
31  would be really appreciated. Note that the `EnTT` framework has a
32  [coverage at 100%](https://coveralls.io/github/skypjack/entt?branch=master)
33  (at least it was at 100% at the time I wrote this file) and this is the reason
34  for which you can be confident with using it in a production environment.
35 
36 * If you want to propose a new feature and you know how to code it, **please**
37  do not issue directly a pull request. Before to do it,
38  [create a new issue](https://github.com/skypjack/entt/issues/new) to discuss
39  your proposal. Other users could be interested in your idea and the discussion
40  that will follow can refine it and therefore give us a better solution.
41 
42 * If you want to request a new feature, I'm available for hiring. Take a look at
43  [my profile](https://github.com/skypjack) and feel free to write me.
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/README_8md_source.html b/README_8md_source.html index 66293663e..c4a4f94bd 100644 --- a/README_8md_source.html +++ b/README_8md_source.html @@ -5,7 +5,7 @@ -entt: README.md Source File +EnTT: README.md Source File @@ -21,8 +21,8 @@ -
entt -  2.7.1 +
EnTT +  2.7.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 # Table of Contents
9 
10 * [Introduction](#introduction)
11 * [Build Instructions](#build-instructions)
12 * [Crash Course: entity-component system](#crash-course-entity-component-system)
13  * [Design choices](#design-choices)
14  * [A bitset-free entity-component system](#a-bitset-free-entity-component-system)
15  * [Pay per use](#pay-per-use)
16  * [Vademecum](#vademecum)
17  * [The Registry, the Entity and the Component](#the-registry-the-entity-and-the-component)
18  * [Single instance components](#single-instance-components)
19  * [Observe changes](#observe-changes)
20  * [Who let the tags out?](#who-let-the-tags-out)
21  * [Runtime components](#runtime-components)
22  * [A journey through a plugin](#a-journey-through-a-plugin)
23  * [Sorting: is it possible?](#sorting-is-it-possible)
24  * [Snapshot: complete vs continuous](#snapshot-complete-vs-continuous)
25  * [Snapshot loader](#snapshot-loader)
26  * [Continuous loader](#continuous-loader)
27  * [Archives](#archives)
28  * [One example to rule them all](#one-example-to-rule-them-all)
29  * [Prototype](#prototype)
30  * [Helpers](#helpers)
31  * [Dependency function](#dependency-function)
32  * [Null entity](#null-entity)
33  * [View: to persist or not to persist?](#view-to-persist-or-not-to-persist)
34  * [Standard View](#standard-view)
35  * [Single component standard view](#single-component-standard-view)
36  * [Multi component standard view](#multi-component-standard-view)
37  * [Persistent View](#persistent-view)
38  * [Raw View](#raw-view)
39  * [Runtime View](#runtime-view)
40  * [Give me everything](#give-me-everything)
41  * [Iterations: what is allowed and what is not](#iterations-what-is-allowed-and-what-is-not)
42  * [Multithreading](#multithreading)
43 * [Crash Course: core functionalities](#crash-course-core-functionalities)
44  * [Compile-time identifiers](#compile-time-identifiers)
45  * [Runtime identifiers](#runtime-identifiers)
46  * [Hashed strings](#hashed-strings)
47  * [Monostate](#monostate)
48 * [Crash Course: service locator](#crash-course-service-locator)
49 * [Crash Course: cooperative scheduler](#crash-course-cooperative-scheduler)
50  * [The process](#the-process)
51  * [The scheduler](#the-scheduler)
52 * [Crash Course: resource management](#crash-course-resource-management)
53  * [The resource, the loader and the cache](#the-resource-the-loader-and-the-cache)
54 * [Crash Course: events, signals and everything in between](#crash-course-events-signals-and-everything-in-between)
55  * [Signals](#signals)
56  * [Delegate](#delegate)
57  * [Event dispatcher](#event-dispatcher)
58  * [Event emitter](#event-emitter)
59 * [Packaging Tools](#packaging-tools)
60 * [EnTT in Action](#entt-in-action)
61 * [License](#license)
62 * [Support](#support)
63  * [Donation](#donation)
64  * [Hire me](#hire-me)
65 
66 # Introduction
67 
68 `EnTT` is a header-only, tiny and easy to use framework written in modern
69 C++.<br/>
70 It was originally designed entirely around an architectural pattern called _ECS_
71 that is used mostly in game development. For further details:
72 
73 * [Entity Systems Wiki](http://entity-systems.wikidot.com/)
74 * [Evolve Your Hierarchy](http://cowboyprogramming.com/2007/01/05/evolve-your-heirachy/)
75 * [ECS on Wikipedia](https://en.wikipedia.org/wiki/Entity%E2%80%93component%E2%80%93system)
76 
77 A long time ago, the sole entity-component system was part of the project. After
78 a while the codebase has grown and more and more classes have become part of the
79 repository.<br/>
80 That's why today it's called _the EnTT Framework_.
81 
82 Currently, `EnTT` is tested on Linux, Microsoft Windows and OS X. It has proven
83 to work also on both Android and iOS.<br/>
84 Most likely it will not be problematic on other systems as well, but has not
85 been sufficiently tested so far.
86 
87 ## The framework
88 
89 `EnTT` was written initially as a faster alternative to other well known and
90 open source entity-component systems. Nowadays the `EnTT` framework is moving
91 its first steps. Much more will come in the future and hopefully I'm going to
92 work on it for a long time.<br/>
93 Requests for feature, PR, suggestions ad feedback are highly appreciated.
94 
95 If you find you can help me and want to contribute to the `EnTT` framework with
96 your experience or you do want to get part of the project for some other
97 reasons, feel free to contact me directly (you can find the mail in the
98 [profile](https://github.com/skypjack)).<br/>
99 I can't promise that each and every contribution will be accepted, but I can
100 assure that I'll do my best to take them all seriously.
101 
102 ### State of the art
103 
104 Here is a brief list of what it offers today:
105 
106 * Statically generated integer identifiers for types (assigned either at
107  compile-time or at runtime).
108 * A constexpr utility for human readable resource identifiers.
109 * An incredibly fast entity-component system based on sparse sets, with its own
110  views and a _pay for what you use_ policy to adjust performance and memory
111  usage according to users' requirements.
112 * Actor class for those who aren't confident with entity-component systems.
113 * The smallest and most basic implementation of a service locator ever seen.
114 * A cooperative scheduler for processes of any type.
115 * All what is needed for resource management (cache, loaders, handles).
116 * Delegates, signal handlers (with built-in support for collectors) and a tiny
117  event dispatcher.
118 * A general purpose event emitter, that is a CRTP idiom based class template.
119 * An event dispatcher for immediate and delayed events to integrate in loops.
120 * ...
121 * Any other business.
122 
123 Consider it a work in progress. For more details and an updated list, please
124 refer to the [online documentation](https://skypjack.github.io/entt/). It
125 probably contains much more. Moreover, the whole API is fully documented in-code
126 for those who are brave enough to read it.<br/>
127 Continue reading to know how the different parts of the project work or follow
128 the link above to take a look at the API reference.
129 
130 ## Code Example
131 
132 ```cpp
133 #include <entt/entt.hpp>
134 #include <cstdint>
135 
136 struct Position {
137  float x;
138  float y;
139 };
140 
141 struct Velocity {
142  float dx;
143  float dy;
144 };
145 
146 void update(entt::DefaultRegistry &registry) {
147  auto view = registry.view<Position, Velocity>();
148 
149  for(auto entity: view) {
150  // gets only the components that are going to be used ...
151 
152  auto &velocity = view.get<Velocity>(entity);
153 
154  velocity.dx = 0.;
155  velocity.dy = 0.;
156 
157  // ...
158  }
159 }
160 
161 void update(std::uint64_t dt, entt::DefaultRegistry &registry) {
162  registry.view<Position, Velocity>().each([dt](auto entity, auto &position, auto &velocity) {
163  // gets all the components of the view at once ...
164 
165  position.x += velocity.dx * dt;
166  position.y += velocity.dy * dt;
167 
168  // ...
169  });
170 }
171 
172 int main() {
173  entt::DefaultRegistry registry;
174  std::uint64_t dt = 16;
175 
176  for(auto i = 0; i < 10; ++i) {
177  auto entity = registry.create();
178  registry.assign<Position>(entity, i * 1.f, i * 1.f);
179  if(i % 2 == 0) { registry.assign<Velocity>(entity, i * .1f, i * .1f); }
180  }
181 
182  update(dt, registry);
183  update(registry);
184 
185  // ...
186 }
187 ```
188 
189 ## Motivation
190 
191 I started working on `EnTT` because of the wrong reason: my goal was to design
192 an entity-component system that beated another well known open source solution
193 in terms of performance and used (possibly) less memory in the average
194 case.<br/>
195 In the end, I did it, but it wasn't much satisfying. Actually it wasn't
196 satisfying at all. The fastest and nothing more, fairly little indeed. When I
197 realized it, I tried hard to keep intact the great performance of `EnTT` and to
198 add all the features I wanted to see in *my own library* at the same time.
199 
200 Today `EnTT` is finally what I was looking for: still faster than its
201 _competitors_, lower memory usage in the average case, a really good API and an
202 amazing set of features. And even more, of course.
203 
204 ## Performance
205 
206 As it stands right now, `EnTT` is just fast enough for my requirements if
207 compared to my first choice (it was already amazingly fast actually).<br/>
208 Below is a comparison between the two (both of them compiled with GCC 7.3.0 on a
209 Dell XPS 13 out of the mid 2014):
210 
211 | Benchmark | EntityX (compile-time) | EnTT |
212 |-----------|-------------|-------------|
213 | Create 1M entities | 0.0147s | **0.0046s** |
214 | Destroy 1M entities | 0.0053s | **0.0045s** |
215 | 1M entities, one component | 0.0012s | **1.9e-07s** |
216 | 1M entities, two components | 0.0012s | **3.8e-07s** |
217 | 1M entities, two components<br/>Half of the entities have all the components | 0.0009s | **3.8e-07s** |
218 | 1M entities, two components<br/>One of the entities has all the components | 0.0008s | **1.0e-06s** |
219 | 1M entities, five components | 0.0010s | **7.0e-07s** |
220 | 1M entities, ten components | 0.0011s | **1.2e-06s** |
221 | 1M entities, ten components<br/>Half of the entities have all the components | 0.0010s | **1.2e-06s** |
222 | 1M entities, ten components<br/>One of the entities has all the components | 0.0008s | **1.2e-06s** |
223 | Sort 150k entities, one component<br/>Arrays are in reverse order | - | **0.0036s** |
224 | Sort 150k entities, enforce permutation<br/>Arrays are in reverse order | - | **0.0005s** |
225 | Sort 150k entities, one component<br/>Arrays are almost sorted, std::sort | - | **0.0035s** |
226 | Sort 150k entities, one component<br/>Arrays are almost sorted, insertion sort | - | **0.0007s** |
227 
228 Note: The default version of `EntityX` (`master` branch) wasn't added to the
229 comparison because it's already much slower than its compile-time counterpart.
230 
231 Pretty interesting, aren't them? In fact, these benchmarks are the same used by
232 `EntityX` to show _how fast it is_. To be honest, they aren't so good and these
233 results shouldn't be taken much seriously (they are completely unrealistic
234 indeed).<br/>
235 The proposed entity-component system is incredibly fast to iterate entities,
236 this is a fact. The compiler can make a lot of optimizations because of how
237 `EnTT` works, even more when components aren't used at all. This is exactly the
238 case for these benchmarks. On the other hand and if we consider real world
239 cases, `EnTT` is in the middle between a bit and much faster than the other
240 solutions around when users also access the components and not just the
241 entities, although it is not as fast as reported by these benchmarks.<br/>
242 This is why they are completely wrong and cannot be used to evaluate any of the
243 entity-component systems.
244 
245 If you decide to use `EnTT`, choose it because of its API, features and
246 performance, not because there is a benchmark somewhere that makes it seem the
247 fastest.
248 
249 Probably I'll try to get out of `EnTT` more features and even better performance
250 in the future, mainly for fun.<br/>
251 If you want to contribute and/or have any suggestion, feel free to make a PR or
252 open an issue to discuss your idea.
253 
254 # Build Instructions
255 
256 ## Requirements
257 
258 To be able to use `EnTT`, users must provide a full-featured compiler that
259 supports at least C++14.<br/>
260 The requirements below are mandatory to compile the tests and to extract the
261 documentation:
262 
263 * CMake version 3.2 or later.
264 * Doxygen version 1.8 or later.
265 
266 ## Library
267 
268 `EnTT` is a header-only library. This means that including the `entt.hpp`
269 header is enough to include the whole framework and use it. For those who are
270 interested only in the entity-component system, consider to include the sole
271 `entity/registry.hpp` header instead.<br/>
272 It's a matter of adding the following line to the top of a file:
273 
274 ```cpp
275 #include <entt/entt.hpp>
276 ```
277 
278 Use the line below to include only the entity-component system instead:
279 
280 ```cpp
281 #include <entt/entity/registry.hpp>
282 ```
283 
284 Then pass the proper `-I` argument to the compiler to add the `src` directory to
285 the include paths.
286 
287 ## Documentation
288 
289 The documentation is based on [doxygen](http://www.stack.nl/~dimitri/doxygen/).
290 To build it:
291 
292  $ cd build
293  $ cmake .. -DBUILD_DOCS=ON
294  $ make
295 
296 The API reference will be created in HTML format within the directory
297 `build/docs/html`. To navigate it with your favorite browser:
298 
299  $ cd build
300  $ your_favorite_browser docs/html/index.html
301 
302 The API reference is also available [online](https://skypjack.github.io/entt/)
303 for the latest version.
304 
305 ## Tests
306 
307 To compile and run the tests, `EnTT` requires *googletest*.<br/>
308 `cmake` will download and compile the library before compiling anything else.
309 In order to build without tests set CMake option `BUILD_TESTING=OFF`.
310 
311 To build the most basic set of tests:
312 
313 * `$ cd build`
314 * `$ cmake ..`
315 * `$ make`
316 * `$ make test`
317 
318 Note that benchmarks are not part of this set.
319 
320 # Crash Course: entity-component system
321 
322 ## Design choices
323 
324 ### A bitset-free entity-component system
325 
326 `EnTT` is a _bitset-free_ entity-component system that doesn't require users to
327 specify the component set at compile-time.<br/>
328 This is why users can instantiate the core class simply like:
329 
330 ```cpp
331 entt::DefaultRegistry registry;
332 ```
333 
334 In place of its more annoying and error-prone counterpart:
335 
336 ```cpp
337 entt::DefaultRegistry<Comp0, Comp1, ..., CompN> registry;
338 ```
339 
340 ### Pay per use
341 
342 `EnTT` is entirely designed around the principle that users have to pay only for
343 what they want.
344 
345 When it comes to using an entity-component system, the tradeoff is usually
346 between performance and memory usage. The faster it is, the more memory it uses.
347 However, slightly worse performance along non-critical paths are the right price
348 to pay to reduce memory usage and I've always wondered why this kind of tools do
349 not leave me the choice.<br/>
350 `EnTT` follows a completely different approach. It squeezes the best from the
351 basic data structures and gives users the possibility to pay more for higher
352 performance where needed.<br/>
353 The disadvantage of this approach is that users need to know the systems they
354 are working on and the tools they are using. Otherwise, the risk to ruin the
355 performance along critical paths is high.
356 
357 So far, this choice has proven to be a good one and I really hope it can be for
358 many others besides me.
359 
360 ## Vademecum
361 
362 The `Registry` to store, the views to iterate. That's all.
363 
364 An entity (the _E_ of an _ECS_) is an opaque identifier that users should just
365 use as-is and store around if needed. Do not try to inspect an entity
366 identifier, its format can change in future and a registry offers all the
367 functionalities to query them out-of-the-box. The underlying type of an entity
368 (either `std::uint16_t`, `std::uint32_t` or `std::uint64_t`) can be specified
369 when defining a registry (actually the `DefaultRegistry` is nothing more than a
370 `Registry` where the type of the entities is `std::uint32_t`).<br/>
371 Components (the _C_ of an _ECS_) should be plain old data structures or more
372 complex and movable data structures with a proper constructor. Actually, the
373 sole requirement of a component type is that it must be both move constructible
374 and move assignable. They are list initialized by using the parameters provided
375 to construct the component itself. No need to register components or their types
376 neither with the registry nor with the entity-component system at all.<br/>
377 Systems (the _S_ of an _ECS_) are just plain functions, functors, lambdas or
378 whatever users want. They can accept a `Registry` or a view of any type and use
379 them the way they prefer. No need to register systems or their types neither
380 with the registry nor with the entity-component system at all.
381 
382 The following sections will explain in short how to use the entity-component
383 system, the core part of the whole framework.<br/>
384 In fact, the framework is composed of many other classes in addition to those
385 describe below. For more details, please refer to the inline documentation.
386 
387 ## The Registry, the Entity and the Component
388 
389 A registry can store and manage entities, as well as create views to iterate the
390 underlying data structures.<br/>
391 `Registry` is a class template that lets users decide what's the preferred type
392 to represent an entity. Because `std::uint32_t` is large enough for almost all
393 the cases, there exists also an alias named `DefaultRegistry` for
394 `Registry<std::uint32_t>`.
395 
396 Entities are represented by _entity identifiers_. An entity identifier is an
397 opaque type that users should not inspect or modify in any way. It carries
398 information about the entity itself and its version.
399 
400 A registry can be used both to construct and destroy entities:
401 
402 ```cpp
403 // constructs a naked entity with no components and returns its identifier
404 auto entity = registry.create();
405 
406 // destroys an entity and all its components
407 registry.destroy(entity);
408 ```
409 
410 Entities can also be destroyed _by type_, that is by specifying the types of the
411 tags or components that identify them:
412 
413 ```cpp
414 // destroys the entity that owns the given tag, if any
415 registry.destroy<MyTag>(entt::tag_t{});
416 
417 // destroys the entities that own the given components, if any
418 registry.destroy<AComponent, AnotherComponent>();
419 ```
420 
421 When an entity is destroyed, the registry can freely reuse it internally with a
422 slightly different identifier. In particular, the version of an entity is
423 increased each and every time it's discarded.<br/>
424 In case entity identifiers are stored around, the registry offers all the
425 functionalities required to test them and get out of the them all the
426 information they carry:
427 
428 ```cpp
429 // returns true if the entity is still valid, false otherwise
430 bool b = registry.valid(entity);
431 
432 // gets the version contained in the entity identifier
433 auto version = registry.version(entity);
434 
435 // gets the actual version for the given entity
436 auto curr = registry.current(entity);
437 ```
438 
439 Components can be assigned to or removed from entities at any time with a few
440 calls to member functions of the registry. As for the entities, the registry
441 offers also a set of functionalities users can use to work with the components.
442 
443 The `assign` member function template creates, initializes and assigns to an
444 entity the given component. It accepts a variable number of arguments to
445 construct the component itself if present:
446 
447 ```cpp
448 registry.assign<Position>(entity, 0., 0.);
449 
450 // ...
451 
452 Velocity &velocity = registry.assign<Velocity>(entity);
453 velocity.dx = 0.;
454 velocity.dy = 0.;
455 ```
456 
457 If an entity already has the given component, the `replace` member function
458 template can be used to replace it:
459 
460 ```cpp
461 registry.replace<Position>(entity, 0., 0.);
462 
463 // ...
464 
465 Velocity &velocity = registry.replace<Velocity>(entity);
466 velocity.dx = 0.;
467 velocity.dy = 0.;
468 ```
469 
470 In case users want to assign a component to an entity, but it's unknown whether
471 the entity already has it or not, `accommodate` does the work in a single call
472 (there is a performance penalty to pay for this mainly due to the fact that it
473 has to check if the entity already has the given component or not):
474 
475 ```cpp
476 registry.accommodate<Position>(entity, 0., 0.);
477 
478 // ...
479 
480 Velocity &velocity = registry.accommodate<Velocity>(entity);
481 velocity.dx = 0.;
482 velocity.dy = 0.;
483 ```
484 
485 Note that `accommodate` is a slightly faster alternative for the following
486 `if/else` statement and nothing more:
487 
488 ```cpp
489 if(registry.has<Comp>(entity)) {
490  registry.replace<Comp>(entity, arg1, argN);
491 } else {
492  registry.assign<Comp>(entity, arg1, argN);
493 }
494 ```
495 
496 As already shown, if in doubt about whether or not an entity has one or more
497 components, the `has` member function template may be useful:
498 
499 ```cpp
500 bool b = registry.has<Position, Velocity>(entity);
501 ```
502 
503 On the other side, if the goal is to delete a single component, the `remove`
504 member function template is the way to go when it's certain that the entity owns
505 a copy of the component:
506 
507 ```cpp
508 registry.remove<Position>(entity);
509 ```
510 
511 Otherwise consider to use the `reset` member function. It behaves similarly to
512 `remove` but with a strictly defined behavior (and a performance penalty is the
513 price to pay for this). In particular it removes the component if and only if it
514 exists, otherwise it returns safely to the caller:
515 
516 ```cpp
517 registry.reset<Position>(entity);
518 ```
519 
520 There exist also two other _versions_ of the `reset` member function:
521 
522 * If no entity is passed to it, `reset` will remove the given component from
523  each entity that has it:
524 
525  ```cpp
526  registry.reset<Position>();
527  ```
528 
529 * If neither the entity nor the component are specified, all the entities still
530  in use and their components are destroyed:
531 
532  ```cpp
533  registry.reset();
534  ```
535 
536 Finally, references to components can be retrieved simply by doing this:
537 
538 ```cpp
539 const auto &cregistry = registry;
540 
541 // const and non-const reference
542 const Position &position = cregistry.get<Position>(entity);
543 Position &position = registry.get<Position>(entity);
544 
545 // const and non-const references
546 std::tuple<const Position &, const Velocity &> tup = cregistry.get<Position, Velocity>(entity);
547 std::tuple<Position &, Velocity &> tup = registry.get<Position, Velocity>(entity);
548 ```
549 
550 The `get` member function template gives direct access to the component of an
551 entity stored in the underlying data structures of the registry.
552 
553 ### Single instance components
554 
555 In those cases where all what is needed is a single instance component, tags are
556 the right tool to achieve the purpose.<br/>
557 Tags undergo the same requirements of components. They can be either plain old
558 data structures or more complex and movable data structures with a proper
559 constructor.<br/>
560 Actually, the same type can be used both as a tag and as a component and the
561 registry will not complain about it. It is up to users to properly manage their
562 own types. In some cases, the tag `tag_t` must also be used in order to
563 disambiguate overloads of member functions.
564 
565 Attaching tags to entities and removing them is trivial:
566 
567 ```cpp
568 auto player = registry.create();
569 auto camera = registry.create();
570 
571 // attaches a default-initialized tag to an entity
572 registry.assign<PlayingCharacter>(entt::tag_t{}, player);
573 
574 // attaches a tag to an entity and initializes it
575 registry.assign<Camera>(entt::tag_t{}, camera, player);
576 
577 // removes tags from their owners
578 registry.remove<PlayingCharacter>();
579 registry.remove<Camera>();
580 ```
581 
582 In case a tag already has an owner, its content can be updated by means of the
583 `replace` member function template and the ownership of the tag can be
584 transferred to another entity using the `move` member function template:
585 
586 ```
587 // replaces the content of the given tag
588 Point &point = registry.replace<Point>(entt::tag_t{}, 1.f, 1.f);
589 
590 // transfers the ownership of the tag to another entity
591 entity_type prev = registry.move<Point>(next);
592 ```
593 
594 If in doubt about whether or not a tag already has an owner, the `has` member
595 function template may be useful:
596 
597 ```cpp
598 bool b = registry.has<PlayingCharacter>();
599 ```
600 
601 References to tags can be retrieved simply by doing this:
602 
603 ```cpp
604 const auto &cregistry = registry;
605 
606 // either a non-const reference ...
607 PlayingCharacter &player = registry.get<PlayingCharacter>();
608 
609 // ... or a const one
610 const Camera &camera = cregistry.get<Camera>();
611 ```
612 
613 The `get` member function template gives direct access to the tag as stored in
614 the underlying data structures of the registry.
615 
616 As shown above, in almost all the cases the entity identifier isn't required.
617 Since a single instance component can have only one associated entity, it
618 doesn't make much sense to mention it explicitly.<br/>
619 To find out who the owner is, just do the following:
620 
621 ```cpp
622 auto player = registry.attachee<PlayingCharacter>();
623 ```
624 
625 Note that iterating tags isn't possible for obvious reasons. Tags give direct
626 access to single entities and nothing more.
627 
628 ### Observe changes
629 
630 Because of how the registry works internally, it stores a couple of signal
631 handlers for each pool in order to notify some of its data structures on the
632 construction and destruction of components.<br/>
633 These signal handlers are also exposed and made available to users. This is the
634 basic brick to build fancy things like dependencies and reactive systems.
635 
636 To get a sink to be used to connect and disconnect listeners so as to be
637 notified on the creation of a component, use the `construction` member function:
638 
639 ```cpp
640 // connects a free function
641 registry.construction<Position>().connect<&MyFreeFunction>();
642 
643 // connects a member function
644 registry.construction<Position>().connect<MyClass, &MyClass::member>(&instance);
645 
646 // disconnects a free function
647 registry.construction<Position>().disconnect<&MyFreeFunction>();
648 
649 // disconnects a member function
650 registry.construction<Position>().disconnect<MyClass, &MyClass::member>(&instance);
651 ```
652 
653 To be notified when components are destroyed, use the `destruction` member
654 function instead.
655 
656 The function type of a listener is the same in both cases:
657 
658 ```cpp
659 void(Registry<Entity> &, Entity);
660 ```
661 
662 In other terms, a listener is provided with the registry that triggered the
663 notification and the entity affected by the change. Note also that:
664 
665 * Listeners are invoked **after** components have been assigned to entities.
666 * Listeners are invoked **before** components have been removed from entities.
667 * The order of invocation of the listeners isn't guaranteed in any case.
668 
669 There are also some limitations on what a listener can and cannot do. In
670 particular:
671 
672 * Connecting and disconnecting other functions from within the body of a
673  listener should be avoided. It can lead to undefined behavior in some cases.
674 * Assigning and removing components and tags from within the body of a listener
675  that observes the destruction of instances of a given type should be avoided.
676  It can lead to undefined behavior in some cases. This type of listeners is
677  intended to provide users with an easy way to perform cleanup and nothing
678  more.
679 
680 To a certain extent, these limitations do not apply. However, it is risky to try
681 to force them and users should respect the limitations unless they know exactly
682 what they are doing. Subtle bugs are the price to pay in case of errors
683 otherwise.
684 
685 In general, events and therefore listeners must not be used as replacements for
686 systems. They should not contain much logic and interactions with a registry
687 should be kept to a minimum, if possible. Note also that the greater the number
688 of listeners, the greater the performance hit when components are created or
689 destroyed.
690 
691 #### Who let the tags out?
692 
693 As an extension, signals are also provided with tags. Although they are not
694 strictly required internally, it makes sense that a user expects signal support
695 even when it comes to tags actually.<br/>
696 Signals for tags undergo exactly the same requirements of those introduced for
697 components. Also the function type for a listener is the same and it's invoked
698 with the same guarantees discussed above.
699 
700 To get the sinks for a tag just use tag `tag_t` to disambiguate overloads of
701 member functions as in the following example:
702 
703 ```cpp
704 registry.construction<MyTag>(entt::tag_t{}).connect<&MyFreeFunction>();
705 registry.destruction<MyTag>(entt::tag_t{}).connect<MyClass, &MyClass::member>(&instance);
706 ```
707 
708 Listeners for tags and components are managed separately and do not influence
709 each other in any case. Therefore, note that the greater the number of listeners
710 for a type, the greater the performance hit when a tag of the given type is
711 created or destroyed.
712 
713 ### Runtime components
714 
715 Defining components at runtime is useful to support plugin systems and mods in
716 general. However, it seems impossible with a tool designed around a bunch of
717 templates. Indeed it's not that difficult.<br/>
718 Of course, some features cannot be easily exported into a runtime
719 environment. As an example, sorting a group of components defined at runtime
720 isn't for free if compared to most of the other operations. However, the basic
721 functionalities of an entity-component system such as `EnTT` fit the problem
722 perfectly and can also be used to manage runtime components if required.<br/>
723 All that is necessary to do it is to know the identifiers of the components. An
724 identifier is nothing more than a number or similar that can be used at runtime
725 to work with the type system.
726 
727 In `EnTT`, identifiers are easily accessible:
728 
729 ```cpp
730 entt::DefaultRegistry registry;
731 
732 // standard component identifier
733 auto ctype = registry.component<Position>();
734 
735 // single instance component identifier
736 auto ttype = registry.tag<PlayingCharacter>();
737 ```
738 
739 Once the identifiers are made available, almost everything becomes pretty
740 simple.
741 
742 #### A journey through a plugin
743 
744 `EnTT` comes with an example (actually a test) that shows how to integrate
745 compile-time and runtime components in a stack based JavaScript environment. It
746 uses [`Duktape`](https://github.com/svaarala/duktape) under the hood, mainly
747 because I wanted to learn how it works at the time I was writing the code.
748 
749 The code is not production-ready and overall performance can be highly improved.
750 However, I sacrificed optimizations in favor of a more readable piece of code. I
751 hope I succeeded.<br/>
752 Note also that this isn't neither the only nor (probably) the best way to do it.
753 In fact, the right way depends on the scripting language and the problem one is
754 facing in general.<br/>
755 That being said, feel free to use it at your own risk.
756 
757 The basic idea is that of creating a compile-time component aimed to map all the
758 runtime components assigned to an entity.<br/>
759 Identifiers come in use to address the right function from a map when invoked
760 from the runtime environment and to filter entities when iterating.<br/>
761 With a bit of gymnastic, one can narrow views and improve the performance to
762 some extent but it was not the goal of the example.
763 
764 ### Sorting: is it possible?
765 
766 It goes without saying that sorting entities and components is possible with
767 `EnTT`.<br/>
768 In fact, there are two functions that respond to slightly different needs:
769 
770 * Components can be sorted directly:
771 
772  ```cpp
773  registry.sort<Renderable>([](const auto &lhs, const auto &rhs) {
774  return lhs.z < rhs.z;
775 
776  });
777  ```
778 
779  There exists also the possibility to use a custom sort function object, as
780  long as it adheres to the requirements described in the inline
781  documentation.<br/>
782  This is possible mainly because users can get much more with a custom sort
783  function object if the pattern of usage is known. As an example, in case of an
784  almost sorted pool, quick sort could be much, much slower than insertion sort.
785 
786 * Components can be sorted according to the order imposed by another component:
787 
788  ```cpp
789  registry.sort<Movement, Physics>();
790  ```
791 
792  In this case, instances of `Movement` are arranged in memory so that cache
793  misses are minimized when the two components are iterated together.
794 
795 ### Snapshot: complete vs continuous
796 
797 The `Registry` class offers basic support to serialization.<br/>
798 It doesn't convert components and tags to bytes directly, there wasn't the need
799 of another tool for serialization out there. Instead, it accepts an opaque
800 object with a suitable interface (namely an _archive_) to serialize its internal
801 data structures and restore them later. The way types and instances are
802 converted to a bunch of bytes is completely in charge to the archive and thus to
803 final users.
804 
805 The goal of the serialization part is to allow users to make both a dump of the
806 entire registry or a narrower snapshot, that is to select only the components
807 and the tags in which they are interested.<br/>
808 Intuitively, the use cases are different. As an example, the first approach is
809 suitable for local save/restore functionalities while the latter is suitable for
810 creating client-server applications and for transferring somehow parts of the
811 representation side to side.
812 
813 To take a snapshot of the registry, use the `snapshot` member function. It
814 returns a temporary object properly initialized to _save_ the whole registry or
815 parts of it.
816 
817 Example of use:
818 
819 ```cpp
820 OutputArchive output;
821 
822 registry.snapshot()
823  .entities(output)
824  .destroyed(output)
825  .component<AComponent, AnotherComponent>(output)
826  .tag<MyTag>(output);
827 ```
828 
829 It isn't necessary to invoke all these functions each and every time. What
830 functions to use in which case mostly depends on the goal and there is not a
831 golden rule to do that.
832 
833 The `entities` member function asks the registry to serialize all the entities
834 that are still in use along with their versions. On the other side, the
835 `destroyed` member function tells to the registry to serialize the entities that
836 have been destroyed and are no longer in use.<br/>
837 These two functions can be used to save and restore the whole set of entities
838 with the versions they had during serialization.
839 
840 The `component` member function is a function template the aim of which is to
841 store aside components. The presence of a template parameter list is a
842 consequence of a couple of design choices from the past and in the present:
843 
844 * First of all, there is no reason to force a user to serialize all the
845  components at once and most of the times it isn't desiderable. As an example,
846  in case the stuff for the HUD in a game is put into the registry for some
847  reasons, its components can be freely discarded during a serialization step
848  because probably the software already knows how to reconstruct the HUD
849  correctly from scratch.
850 
851 * Furthermore, the registry makes heavy use of _type-erasure_ techniques
852  internally and doesn't know at any time what types of components it contains.
853  Therefore being explicit at the call point is mandatory.
854 
855 There exists also another version of the `component` member function that
856 accepts a range of entities to serialize. This version is a bit slower than the
857 other one, mainly because it iterates the range of entities more than once for
858 internal purposes. However, it can be used to filter out those entities that
859 shouldn't be serialized for some reasons.<br/>
860 As an example:
861 
862 ```cpp
863 const auto view = registry.view<Serialize>();
864 OutputArchive output;
865 
866 registry.snapshot()
867  .component<AComponent, AnotherComponent>(output, view.cbegin(), view.cend());
868 ```
869 
870 The `tag` member function is similar to the previous one, apart from the fact
871 that it works with tags and not with components.<br/>
872 Note also that both `component` and `tag` store items along with entities. It
873 means that they work properly without a call to the `entities` member function.
874 
875 Once a snapshot is created, there exist mainly two _ways_ to load it: as a whole
876 and in a kind of _continuous mode_.<br/>
877 The following sections describe both loaders and archives in details.
878 
879 #### Snapshot loader
880 
881 A snapshot loader requires that the destination registry be empty and loads all
882 the data at once while keeping intact the identifiers that the entities
883 originally had.<br/>
884 To do that, the registry offers a member function named `restore` that returns a
885 temporary object properly initialized to _restore_ a snapshot.
886 
887 Example of use:
888 
889 ```cpp
890 InputArchive input;
891 
892 registry.restore()
893  .entities(input)
894  .destroyed(input)
895  .component<AComponent, AnotherComponent>(input)
896  .tag<MyTag>(input)
897  .orphans();
898 ```
899 
900 It isn't necessary to invoke all these functions each and every time. What
901 functions to use in which case mostly depends on the goal and there is not a
902 golden rule to do that. For obvious reasons, what is important is that the data
903 are restored in exactly the same order in which they were serialized.
904 
905 The `entities` and `destroyed` member functions restore the sets of entities and
906 the versions that the entities originally had at the source.
907 
908 The `component` member function restores all and only the components specified
909 and assigns them to the right entities. Note that the template parameter list
910 must be exactly the same used during the serialization. The same applies to the
911 `tag` member function.
912 
913 The `orphans` member function literally destroys those entities that have
914 neither components nor tags. It's usually useless if the snapshot is a full dump
915 of the source. However, in case all the entities are serialized but only few
916 components and tags are saved, it could happen that some of the entities have
917 neither components nor tags once restored. The best users can do to deal with
918 them is to destroy those entities and thus update their versions.
919 
920 #### Continuous loader
921 
922 A continuous loader is designed to load data from a source registry to a
923 (possibly) non-empty destination. The loader can accommodate in a registry more
924 than one snapshot in a sort of _continuous loading_ that updates the
925 destination one step at a time.<br/>
926 Identifiers that entities originally had are not transferred to the target.
927 Instead, the loader maps remote identifiers to local ones while restoring a
928 snapshot. Because of that, this kind of loader offers a way to update
929 automatically identifiers that are part of components or tags (as an example, as
930 data members or gathered in a container).<br/>
931 Another difference with the snapshot loader is that the continuous loader does
932 not need to work with the private data structures of a registry. Furthermore, it
933 has an internal state that must persist over time. Therefore, there is no reason
934 to create it by means of a registry, or to limit its lifetime to that of a
935 temporary object.
936 
937 Example of use:
938 
939 ```cpp
940 entt::ContinuousLoader<entity_type> loader{registry};
941 InputArchive input;
942 
943 loader.entities(input)
944  .destroyed(input)
945  .component<AComponent, AnotherComponent, DirtyComponent>(input, &DirtyComponent::parent, &DirtyComponent::child)
946  .tag<MyTag, DirtyTag>(input, &DirtyTag::container)
947  .orphans()
948  .shrink();
949 ```
950 
951 It isn't necessary to invoke all these functions each and every time. What
952 functions to use in which case mostly depends on the goal and there is not a
953 golden rule to do that. For obvious reasons, what is important is that the data
954 are restored in exactly the same order in which they were serialized.
955 
956 The `entities` and `destroyed` member functions restore groups of entities and
957 map each entity to a local counterpart when required. In other terms, for each
958 remote entity identifier not yet registered by the loader, the latter creates a
959 local identifier so that it can keep the local entity in sync with the remote
960 one.
961 
962 The `component` and `tag` member functions restore all and only the components
963 and the tags specified and assign them to the right entities.<br/>
964 In case the component or the tag contains entities itself (either as data
965 members of type `entity_type` or as containers of entities), the loader can
966 update them automatically. To do that, it's enough to specify the data members
967 to update as shown in the example.
968 
969 The `orphans` member function literally destroys those entities that have
970 neither components nor tags after a restore. It has exactly the same purpose
971 described in the previous section and works the same way.
972 
973 Finally, `shrink` helps to purge local entities that no longer have a remote
974 conterpart. Users should invoke this member function after restoring each
975 snapshot, unless they know exactly what they are doing.
976 
977 #### Archives
978 
979 Archives must publicly expose a predefined set of member functions. The API is
980 straightforward and consists only of a group of function call operators that
981 are invoked by the snapshot class and the loaders.
982 
983 In particular:
984 
985 * An output archive, the one used when creating a snapshot, must expose a
986  function call operator with the following signature to store entities:
987 
988  ```cpp
989  void operator()(Entity);
990  ```
991 
992  Where `Entity` is the type of the entities used by the registry. Note that all
993  the member functions of the snapshot class make also an initial call to this
994  endpoint to save the _size_ of the set they are going to store.<br/>
995  In addition, an archive must accept a pair of entity and either component or
996  tag for each type to be serialized. Therefore, given a type `T`, the archive
997  must contain a function call operator with the following signature:
998 
999  ```cpp
1000  void operator()(Entity, const T &);
1001  ```
1002 
1003  The output archive can freely decide how to serialize the data. The register
1004  is not affected at all by the decision.
1005 
1006 * An input archive, the one used when restoring a snapshot, must expose a
1007  function call operator with the following signature to load entities:
1008 
1009  ```cpp
1010  void operator()(Entity &);
1011  ```
1012 
1013  Where `Entity` is the type of the entities used by the registry. Each time the
1014  function is invoked, the archive must read the next element from the
1015  underlying storage and copy it in the given variable. Note that all the member
1016  functions of a loader class make also an initial call to this endpoint to read
1017  the _size_ of the set they are going to load.<br/>
1018  In addition, the archive must accept a pair of entity and either component or
1019  tag for each type to be restored. Therefore, given a type `T`, the archive
1020  must contain a function call operator with the following signature:
1021 
1022  ```cpp
1023  void operator()(Entity &, T &);
1024  ```
1025 
1026  Every time such an operator is invoked, the archive must read the next
1027  elements from the underlying storage and copy them in the given variables.
1028 
1029 #### One example to rule them all
1030 
1031 `EnTT` comes with some examples (actually some tests) that show how to integrate
1032 a well known library for serialization as an archive. It uses
1033 [`Cereal C++`](https://uscilab.github.io/cereal/) under the hood, mainly
1034 because I wanted to learn how it works at the time I was writing the code.
1035 
1036 The code is not production-ready and it isn't neither the only nor (probably)
1037 the best way to do it. However, feel free to use it at your own risk.
1038 
1039 The basic idea is to store everything in a group of queues in memory, then bring
1040 everything back to the registry with different loaders.
1041 
1042 ### Prototype
1043 
1044 A prototype defines a type of an application in terms of its parts. They can be
1045 used to assign components to entities of a registry at once.<br/>
1046 Roughly speaking, in most cases prototypes can be considered just as templates
1047 to use to initialize entities according to _concepts_. In fact, users can create
1048 how many prototypes they want, each one initialized differently from the others.
1049 
1050 The following is an example of use of a prototype:
1051 
1052 ```cpp
1053 entt::DefaultRegistry registry;
1054 entt::DefaultPrototype prototype{registry};
1055 
1056 prototype.set<Position>(100.f, 100.f);
1057 prototype.set<Velocity>(0.f, 0.f);
1058 
1059 // ...
1060 
1061 const auto entity = prototype();
1062 ```
1063 
1064 To assign and remove components from a prototype, it offers two dedicated member
1065 functions named `set` and `unset`. The `has` member function can be used to know
1066 if a given prototype contains one or more components and the `get` member
1067 function can be used to retrieve the components.
1068 
1069 Creating an entity from a prototype is straightforward:
1070 
1071 * To create a new entity from scratch and assign it a prototype, this is the way
1072  to go:
1073  ```cpp
1074  const auto entity = prototype();
1075  ```
1076  It is equivalent to the following invokation:
1077  ```cpp
1078  const auto entity = prototype.create();
1079  ```
1080 
1081 * In case we want to initialize an already existing entity, we can provide the
1082  `operator()` directly with the entity identifier:
1083  ```cpp
1084  prototype(entity);
1085  ```
1086  It is equivalent to the following invokation:
1087  ```cpp
1088  prototype.assign(entity);
1089  ```
1090  Note that existing components aren't overwritten in this case. Only those
1091  components that the entity doesn't own yet are copied over. All the other
1092  components remain unchanged.
1093 
1094 * Finally, to assign or replace all the components for an entity, thus
1095  overwriting existing ones:
1096  ```cpp
1097  prototype.accommodate(entity);
1098  ```
1099 
1100 In the examples above, the prototype uses its underlying registry to create
1101 entities and components both for its purposes and when it's cloned. To use a
1102 different repository to clone a prototype, all the member functions accept also
1103 a reference to a valid registry as a first argument.
1104 
1105 Prototypes are a very useful tool that can save a lot of typing sometimes.
1106 Furthermore, the codebase may be easier to maintain, since updating a prototype
1107 is much less error prone than jumping around in the codebase to update all the
1108 snippets copied and pasted around to initialize entities and components.
1109 
1110 ### Helpers
1111 
1112 The so called _helpers_ are small classes and functions mainly designed to offer
1113 built-in support for the most basic functionalities.<br/>
1114 The list of helpers will grow longer as time passes and new ideas come out.
1115 
1116 #### Dependency function
1117 
1118 A _dependency function_ is a predefined listener, actually a function template
1119 to use to automatically assign components to an entity when a type has a
1120 dependency on some other types.<br/>
1121 The following adds components `AType` and `AnotherType` whenever `MyType` is
1122 assigned to an entity:
1123 
1124 ```cpp
1125 entt::dependency<AType, AnotherType>(registry.construction<MyType>());
1126 ```
1127 
1128 A component is assigned to an entity and thus default initialized only in case
1129 the entity itself hasn't it yet. It means that already existent components won't
1130 be overriden.<br/>
1131 A dependency can easily be broken by means of the same function template:
1132 
1133 ```cpp
1134 entt::dependency<AType, AnotherType>(entt::break_t{}, registry.construction<MyType>());
1135 ```
1136 
1137 ### Null entity
1138 
1139 In `EnTT`, there exists a sort of _null entity_ made available to users that is
1140 accessible via the `entt::null` variable.<br/>
1141 The framework guarantees that the following expression always returns false:
1142 
1143 ```cpp
1144 registry.valid(entt::null);
1145 ```
1146 
1147 In other terms, a registry will reject the null entity in all cases because it
1148 isn't considered valid. It means that the null entity cannot own components or
1149 tags for obvious reasons.<br/>
1150 The type of the null entity is internal and should not be used for any purpose
1151 other than defining the null entity itself. However, there exist implicit
1152 conversions from the null entity to identifiers of any allowed type:
1153 
1154 ```cpp
1155 typename entt::DefaultRegistry::entity_type null = entt::null;
1156 ```
1157 
1158 Similarly, the null entity can be compared to any other identifier:
1159 
1160 ```cpp
1161 const auto entity = registry.create();
1162 const bool null = (entity == entt::null);
1163 ```
1164 
1165 ## View: to persist or not to persist?
1166 
1167 First of all, it is worth answering an obvious question: why views?<br/>
1168 Roughly speaking, they are a good tool to enforce single responsibility. A
1169 system that has access to a registry can create and destroy entities, as well as
1170 assign and remove components. On the other side, a system that has access to a
1171 view can only iterate entities and their components, then read or update the
1172 data members of the latter.<br/>
1173 It is a subtle difference that can help designing a better software sometimes.
1174 
1175 There are mainly four kinds of views: standard (also known as `View`),
1176 persistent (also known as `PersistentView`), raw (also known as `RawView`) and
1177 runtime (also known as `RuntimeView`).<br/>
1178 All of them have pros and cons to take in consideration. In particular:
1179 
1180 * Standard views:
1181 
1182  Pros:
1183 
1184  * They work out-of-the-box and don't require any dedicated data structure.
1185  * Creating and destroying them isn't expensive at all because they don't have
1186  any type of initialization.
1187  * They are the best tool for iterating entities for a single component.
1188  * They are the best tool for iterating entities for multiple components when
1189  one of the components is assigned to a significantly low number of entities.
1190  * They don't affect any other operations of the registry.
1191 
1192  Cons:
1193 
1194  * Their performance tend to degenerate when the number of components to
1195  iterate grows up and the most of the entities have all of them.
1196 
1197 * Persistent views:
1198 
1199  Pros:
1200 
1201  * Once prepared, creating and destroying them isn't expensive at all because
1202  they don't have any type of initialization.
1203  * They are the best tool for iterating entities for multiple components when
1204  most entities have them all.
1205 
1206  Cons:
1207 
1208  * They have dedicated data structures and thus affect the memory usage to a
1209  minimal extent.
1210  * If not previously prepared, the first time they are used they go through an
1211  initialization step that could take a while.
1212  * They affect to a minimum the creation and destruction of entities and
1213  components. In other terms: the more persistent views there will be, the
1214  less performing will be creating and destroying entities and components.
1215 
1216 * Raw views:
1217 
1218  Pros:
1219 
1220  * They work out-of-the-box and don't require any dedicated data structure.
1221  * Creating and destroying them isn't expensive at all because they don't have
1222  any type of initialization.
1223  * They are the best tool for iterating components when it is not necessary to
1224  know which entities they belong to.
1225  * They don't affect any other operations of the registry.
1226 
1227  Cons:
1228 
1229  * They can be used to iterate only one type of component at a time.
1230  * They don't return the entity to which a component belongs to the caller.
1231 
1232 * Runtime views:
1233 
1234  Pros:
1235 
1236  * Their lists of components are defined at runtime and not at compile-time.
1237  * Creating and destroying them isn't expensive at all because they don't have
1238  any type of initialization.
1239  * They are the best tool for things like plugin systems and mods in general.
1240  * They don't affect any other operations of the registry.
1241 
1242  Cons:
1243 
1244  * Their performances are definitely lower than those of all the other views,
1245  although they are still usable and sufficient for most of the purposes.
1246 
1247 To sum up and as a rule of thumb:
1248 
1249 * Use a raw view to iterate components only (no entities) for a given type.
1250 * Use a standard view to iterate entities and components for a single type.
1251 * Use a standard view to iterate entities and components for multiple types when
1252  the number of types is low. Standard views are really optimized and persistent
1253  views won't add much in this case.
1254 * Use a standard view to iterate entities and components for multiple types when
1255  a significantly low number of entities have one of the components.
1256 * Use a standard view in all those cases where a persistent view would give a
1257  boost to performance but the iteration isn't performed frequently.
1258 * Prepare and use a persistent view when you want to iterate only entities for
1259  multiple components.
1260 * Prepare and use a persistent view when you want to iterate entities for
1261  multiple components and each component is assigned to a great number of
1262  entities but the intersection between the sets of entities is small.
1263 * Prepare and use a persistent view in all the cases where a standard view
1264  wouldn't fit well otherwise.
1265 * Finally, in case you don't know at compile-time what are the components to
1266  use, choose a runtime view and set them during execution.
1267 
1268 To easily iterate entities and components, all the views offer the common
1269 `begin` and `end` member functions that allow users to use a view in a typical
1270 range-for loop. Almost all the views offer also a *more functional* `each`
1271 member function that accepts a callback for convenience.<br/>
1272 Continue reading for more details or refer to the inline documentation.
1273 
1274 ### Standard View
1275 
1276 A standard view behaves differently if it's constructed for a single component
1277 or if it has been requested to iterate multiple components. Even the API is
1278 different in the two cases.<br/>
1279 All that they share is the way they are created by means of a registry:
1280 
1281 ```cpp
1282 // single component standard view
1283 auto single = registry.view<Position>();
1284 
1285 // multi component standard view
1286 auto multi = registry.view<Position, Velocity>();
1287 ```
1288 
1289 For all that remains, it's worth discussing them separately.<br/>
1290 
1291 #### Single component standard view
1292 
1293 Single component standard views are specialized in order to give a boost in
1294 terms of performance in all the situation. This kind of views can access the
1295 underlying data structures directly and avoid superfluous checks.<br/>
1296 They offer a bunch of functionalities to get the number of entities they are
1297 going to return and a raw access to the entity list as well as to the component
1298 list. It's also possible to ask a view if it contains a given entity.<br/>
1299 Refer to the inline documentation for all the details.
1300 
1301 There is no need to store views around for they are extremely cheap to
1302 construct, even though they can be copied without problems and reused freely. In
1303 fact, they return newly created and correctly initialized iterators whenever
1304 `begin` or `end` are invoked.<br/>
1305 To iterate a single component standard view, either use it in a range-for loop:
1306 
1307 ```cpp
1308 auto view = registry.view<Renderable>();
1309 
1310 for(auto entity: view) {
1311  Renderable &renderable = view.get(entity);
1312 
1313  // ...
1314 }
1315 ```
1316 
1317 Or rely on the `each` member function to iterate entities and get all their
1318 components at once:
1319 
1320 ```cpp
1321 registry.view<Renderable>().each([](auto entity, auto &renderable) {
1322  // ...
1323 });
1324 ```
1325 
1326 The `each` member function is highly optimized. Unless users want to iterate
1327 only entities, using `each` should be the preferred approach.
1328 
1329 **Note**: prefer the `get` member function of a view instead of the `get` member
1330 function template of a registry during iterations, if possible. However, keep in
1331 mind that it works only with the components of the view itself.
1332 
1333 #### Multi component standard view
1334 
1335 Multi component standard views iterate entities that have at least all the given
1336 components in their bags. During construction, these views look at the number of
1337 entities available for each component and pick up a reference to the smallest
1338 set of candidates in order to speed up iterations.<br/>
1339 They offer fewer functionalities than their companion views for single
1340 component. In particular, a multi component standard view exposes utility
1341 functions to get the estimated number of entities it is going to return and to
1342 know whether it's empty or not. It's also possible to ask a view if it contains
1343 a given entity.<br/>
1344 Refer to the inline documentation for all the details.
1345 
1346 There is no need to store views around for they are extremely cheap to
1347 construct, even though they can be copied without problems and reused freely. In
1348 fact, they return newly created and correctly initialized iterators whenever
1349 `begin` or `end` are invoked.<br/>
1350 To iterate a multi component standard view, either use it in a range-for loop:
1351 
1352 ```cpp
1353 auto view = registry.view<Position, Velocity>();
1354 
1355 for(auto entity: view) {
1356  // a component at a time ...
1357  Position &position = view.get<Position>(entity);
1358  Velocity &velocity = view.get<Velocity>(entity);
1359 
1360  // ... or multiple components at once
1361  std::tuple<Position &, Velocity &> tup = view.get<Position, Velocity>(entity);
1362 
1363  // ...
1364 }
1365 ```
1366 
1367 Or rely on the `each` member function to iterate entities and get all their
1368 components at once:
1369 
1370 ```cpp
1371 registry.view<Position, Velocity>().each([](auto entity, auto &position, auto &velocity) {
1372  // ...
1373 });
1374 ```
1375 
1376 The `each` member function is highly optimized. Unless users want to iterate
1377 only entities or get only some of the components, using `each` should be the
1378 preferred approach.
1379 
1380 **Note**: prefer the `get` member function of a view instead of the `get` member
1381 function template of a registry during iterations, if possible. However, keep in
1382 mind that it works only with the components of the view itself.
1383 
1384 ### Persistent View
1385 
1386 A persistent view returns all the entities and only the entities that have at
1387 least the given components. Moreover, it's guaranteed that the entity list is
1388 tightly packed in memory for fast iterations.<br/>
1389 In general, persistent views don't stay true to the order of any set of
1390 components unless users explicitly sort them.
1391 
1392 Persistent views can be used only to iterate multiple components. To create this
1393 kind of views, the tag `persistent_t` must also be used in order to disambiguate
1394 overloads of the `view` member function:
1395 
1396 ```cpp
1397 auto view = registry.view<Position, Velocity>(entt::persistent_t{});
1398 ```
1399 
1400 There is no need to store views around for they are extremely cheap to
1401 construct, even though they can be copied without problems and reused freely. In
1402 fact, they return newly created and correctly initialized iterators whenever
1403 `begin` or `end` are invoked.<br/>
1404 That being said, persistent views perform an initialization step the very first
1405 time they are constructed and this could be quite costly. To avoid it, consider
1406 asking to the registry to _prepare_ them when no entities have been created yet:
1407 
1408 ```cpp
1409 registry.prepare<Position, Velocity>();
1410 ```
1411 
1412 If the registry is empty, preparation is extremely fast. Moreover the `prepare`
1413 member function template is idempotent. Feel free to invoke it even more than
1414 once: if the view has been already prepared before, the function returns
1415 immediately and does nothing.
1416 
1417 A persistent view offers a bunch of functionalities to get the number of
1418 entities it's going to return, a raw access to the entity list and the
1419 possibility to sort the underlying data structures according to the order of one
1420 of the components for which it has been constructed. It's also possible to ask a
1421 view if it contains a given entity.<br/>
1422 Refer to the inline documentation for all the details.
1423 
1424 To iterate a persistent view, either use it in a range-for loop:
1425 
1426 ```cpp
1427 auto view = registry.view<Position, Velocity>(entt::persistent_t{});
1428 
1429 for(auto entity: view) {
1430  // a component at a time ...
1431  Position &position = view.get<Position>(entity);
1432  Velocity &velocity = view.get<Velocity>(entity);
1433 
1434  // ... or multiple components at once
1435  std::tuple<Position &, Velocity &> tup = view.get<Position, Velocity>(entity);
1436 
1437  // ...
1438 }
1439 ```
1440 
1441 Or rely on the `each` member function to iterate entities and get all their
1442 components at once:
1443 
1444 ```cpp
1445 registry.view<Position, Velocity>(entt::persistent_t{}).each([](auto entity, auto &position, auto &velocity) {
1446  // ...
1447 });
1448 ```
1449 
1450 Performance are more or less the same. The best approach depends mainly on
1451 whether all the components have to be accessed or not.
1452 
1453 **Note**: prefer the `get` member function of a view instead of the `get` member
1454 function template of a registry during iterations, if possible. However, keep in
1455 mind that it works only with the components of the view itself.
1456 
1457 ### Raw View
1458 
1459 Raw views return all the components of a given type. This kind of views can
1460 access components directly and avoid extra indirections like when components are
1461 accessed via an entity identifier.<br/>
1462 They offer a bunch of functionalities to get the number of instances they are
1463 going to return and a raw access to the entity list as well as to the component
1464 list.<br/>
1465 Refer to the inline documentation for all the details.
1466 
1467 Raw views can be used only to iterate components for a single type. To create
1468 this kind of views, the tag `raw_t` must also be used in order to disambiguate
1469 overloads of the `view` member function:
1470 
1471 ```cpp
1472 auto view = registry.view<Renderable>(entt::raw_t{});
1473 ```
1474 
1475 There is no need to store views around for they are extremely cheap to
1476 construct, even though they can be copied without problems and reused freely. In
1477 fact, they return newly created and correctly initialized iterators whenever
1478 `begin` or `end` are invoked.<br/>
1479 To iterate a raw view, use it in a range-for loop:
1480 
1481 ```cpp
1482 auto view = registry.view<Renderable>(entt::raw_t{});
1483 
1484 for(auto &&component: raw) {
1485  // ...
1486 }
1487 ```
1488 
1489 Or rely on the `each` member function:
1490 
1491 ```cpp
1492 registry.view<Renderable>(entt::raw_t{}).each([](auto &renderable) {
1493  // ...
1494 });
1495 ```
1496 
1497 Performance are exactly the same in both cases.
1498 
1499 **Note**: raw views don't have a `get` member function for obvious reasons.
1500 
1501 ### Runtime View
1502 
1503 Runtime views iterate entities that have at least all the given components in
1504 their bags. During construction, these views look at the number of entities
1505 available for each component and pick up a reference to the smallest
1506 set of candidates in order to speed up iterations.<br/>
1507 They offer more or less the same functionalities of a multi component standard
1508 view. However, they don't expose a `get` member function and users should refer
1509 to the registry that generated the view to access components. In particular, a
1510 runtime view exposes utility functions to get the estimated number of entities
1511 it is going to return and to know whether it's empty or not. It's also possible
1512 to ask a view if it contains a given entity.<br/>
1513 Refer to the inline documentation for all the details.
1514 
1515 Runtime view are extremely cheap to construct and should not be stored around in
1516 any case. They should be used immediately after creation and then they should be
1517 thrown away. The reasons for this go far beyond the scope of this document.<br/>
1518 To iterate a runtime view, either use it in a range-for loop:
1519 
1520 ```cpp
1521 using component_type = typename decltype(registry)::component_type;
1522 component_type types[] = { registry.type<Position>(), registry.type<Velocity>() };
1523 
1524 auto view = registry.view(std::cbegin(types), std::cend(types));
1525 
1526 for(auto entity: view) {
1527  // a component at a time ...
1528  Position &position = registry.get<Position>(entity);
1529  Velocity &velocity = registry.get<Velocity>(entity);
1530 
1531  // ... or multiple components at once
1532  std::tuple<Position &, Velocity &> tup = view.get<Position, Velocity>(entity);
1533 
1534  // ...
1535 }
1536 ```
1537 
1538 Or rely on the `each` member function to iterate entities:
1539 
1540 ```cpp
1541 using component_type = typename decltype(registry)::component_type;
1542 component_type types[] = { registry.type<Position>(), registry.type<Velocity>() };
1543 
1544 auto view = registry.view(std::cbegin(types), std::cend(types)).each([](auto entity) {
1545  // ...
1546 });
1547 ```
1548 
1549 Performance are exactly the same in both cases.
1550 
1551 **Note**: runtime views are meant for all those cases where users don't know at
1552 compile-time what components to use to iterate entities. This is particularly
1553 well suited to plugin systems and mods in general. Where possible, don't use
1554 runtime views, as their performance are slightly inferior to those of the other
1555 views.
1556 
1557 
1558 ### Give me everything
1559 
1560 Views are narrow windows on the entire list of entities. They work by filtering
1561 entities according to their components.<br/>
1562 In some cases there may be the need to iterate all the entities still in use
1563 regardless of their components. The registry offers a specific member function
1564 to do that:
1565 
1566 ```cpp
1567 registry.each([](auto entity) {
1568  // ...
1569 });
1570 ```
1571 
1572 It returns to the caller all the entities that are still in use by means of the
1573 given function.<br/>
1574 As a rule of thumb, consider using a view if the goal is to iterate entities
1575 that have a determinate set of components. A view is usually much faster than
1576 combining this function with a bunch of custom tests.<br/>
1577 In all the other cases, this is the way to go.
1578 
1579 There exists also another member function to use to retrieve orphans. An orphan
1580 is an entity that is still in use and has neither assigned components nor
1581 tags.<br/>
1582 The signature of the function is the same of `each`:
1583 
1584 ```cpp
1585 registry.orphans([](auto entity) {
1586  // ...
1587 });
1588 ```
1589 
1590 To test the _orphanity_ of a single entity, use the member function `orphan`
1591 instead. It accepts a valid entity identifer as an argument and returns true in
1592 case the entity is an orphan, false otherwise.
1593 
1594 In general, all these functions can result in poor performance.<br/>
1595 `each` is fairly slow because of some checks it performs on each and every
1596 entity. For similar reasons, `orphans` can be even slower. Both functions should
1597 not be used frequently to avoid the risk of a performance hit.
1598 
1599 ## Iterations: what is allowed and what is not
1600 
1601 Most of the _ECS_ available out there have some annoying limitations (at least
1602 from my point of view): entities and components cannot be created nor destroyed
1603 during iterations.<br/>
1604 `EnTT` partially solves the problem with a few limitations:
1605 
1606 * Creating entities and components is allowed during iterations.
1607 * Deleting an entity or removing its components is allowed during iterations if
1608  it's the one currently returned by the view. For all the other entities,
1609  destroying them or removing their components isn't allowed and it can result
1610  in undefined behavior.
1611 
1612 Iterators are invalidated and the behavior is undefined if an entity is modified
1613 or destroyed and it's not the one currently returned by the view nor a newly
1614 created one.<br/>
1615 To work around it, possible approaches are:
1616 
1617 * Store aside the entities and the components to be removed and perform the
1618  operations at the end of the iteration.
1619 * Mark entities and components with a proper tag component that indicates they
1620  must be purged, then perform a second iteration to clean them up one by one.
1621 
1622 A notable side effect of this feature is that the number of required allocations
1623 is further reduced in most of the cases.
1624 
1625 ## Multithreading
1626 
1627 In general, the entire registry isn't thread safe as it is. Thread safety isn't
1628 something that users should want out of the box for several reasons. Just to
1629 mention one of them: performance.<br/>
1630 Views and consequently the approach adopted by `EnTT` are the great exception to
1631 the rule. It's true that views and thus their iterators aren't thread safe by
1632 themselves. Because of this users shouldn't try to iterate a set of components
1633 and modify the same set concurrently. However:
1634 
1635 * As long as a thread iterates the entities that have the component `X` or
1636  assign and removes that component from a set of entities, another thread can
1637  safely do the same with components `Y` and `Z` and everything will work like a
1638  charm. As a trivial example, users can freely execute the rendering system and
1639  iterate the renderable entities while updating a physic component concurrently
1640  on a separate thread.
1641 
1642 * Similarly, a single set of components can be iterated by multiple threads as
1643  long as the components are neither assigned nor removed in the meantime. In
1644  other words, a hypothetical movement system can start multiple threads, each
1645  of which will access the components that carry information about velocity and
1646  position for its entities.
1647 
1648 This kind of entity-component systems can be used in single threaded
1649 applications as well as along with async stuff or multiple threads. Moreover,
1650 typical thread based models for _ECS_ don't require a fully thread safe registry
1651 to work. Actually, users can reach the goal with the registry as it is while
1652 working with most of the common models.
1653 
1654 Because of the few reasons mentioned above and many others not mentioned, users
1655 are completely responsible for synchronization whether required. On the other
1656 hand, they could get away with it without having to resort to particular
1657 expedients.
1658 
1659 # Crash Course: core functionalities
1660 
1661 The `EnTT` framework comes with a bunch of core functionalities mostly used by
1662 the other parts of the library itself.<br/>
1663 Hardly users of the framework will include these features in their code, but
1664 it's worth describing what `EnTT` offers so as not to reinvent the wheel in case
1665 of need.
1666 
1667 ## Compile-time identifiers
1668 
1669 Sometimes it's useful to be able to give unique identifiers to types at
1670 compile-time.<br/>
1671 There are plenty of different solutions out there and I could have used one of
1672 them. However, I decided to spend my time to define a compact and versatile tool
1673 that fully embraces what the modern C++ has to offer.
1674 
1675 The _result of my efforts_ is the `Identifier` class template:
1676 
1677 ```cpp
1678 #include <ident.hpp>
1679 
1680 // defines the identifiers for the given types
1681 using ID = entt::Identifier<AType, AnotherType>;
1682 
1683 // ...
1684 
1685 switch(aTypeIdentifier) {
1686 case ID::get<AType>():
1687  // ...
1688  break;
1689 case ID::get<AnotherType>():
1690  // ...
1691  break;
1692 default:
1693  // ...
1694 }
1695 ```
1696 
1697 This is all what the class template has to offer: a static `get` member function
1698 that returns a numerical identifier for the given type. It can be used in any
1699 context where constant expressions are required.
1700 
1701 As long as the list remains unchanged, identifiers are also guaranteed to be the
1702 same for every run. In case they have been used in a production environment and
1703 a type has to be removed, one can just use a placeholder to left the other
1704 identifiers unchanged:
1705 
1706 ```cpp
1707 template<typename> struct IgnoreType {};
1708 
1709 using ID = entt::Identifier<
1710  ATypeStillValid,
1711  IgnoreType<ATypeNoLongerValid>,
1712  AnotherTypeStillValid
1713 >;
1714 ```
1715 
1716 A bit ugly to see, but it works at least.
1717 
1718 ## Runtime identifiers
1719 
1720 Sometimes it's useful to be able to give unique identifiers to types at
1721 runtime.<br/>
1722 There are plenty of different solutions out there and I could have used one of
1723 them. In fact, I adapted the most common one to my requirements and used it
1724 extensively within the entire framework.
1725 
1726 It's the `Family` class. Here is an example of use directly from the
1727 entity-component system:
1728 
1729 ```cpp
1730 using component_family = entt::Family<struct InternalRegistryComponentFamily>;
1731 
1732 // ...
1733 
1734 template<typename Component>
1735 component_type component() const noexcept {
1736  return component_family::type<Component>();
1737 }
1738 ```
1739 
1740 This is all what a _family_ has to offer: a `type` member function that returns
1741 a numerical identifier for the given type.
1742 
1743 Please, note that identifiers aren't guaranteed to be the same for every run.
1744 Indeed it mostly depends on the flow of execution.
1745 
1746 ## Hashed strings
1747 
1748 A hashed string is a zero overhead resource identifier. Users can use
1749 human-readable identifiers in the codebase while using their numeric
1750 counterparts at runtime, thus without affecting performance.<br/>
1751 The class has an implicit `constexpr` constructor that chews a bunch of
1752 characters. Once created, all what one can do with it is getting back the
1753 original string or converting it into a number.<br/>
1754 The good part is that a hashed string can be used wherever a constant expression
1755 is required and no _string-to-number_ conversion will take place at runtime if
1756 used carefully.
1757 
1758 Example of use:
1759 
1760 ```cpp
1761 auto load(entt::HashedString::hash_type resource) {
1762  // uses the numeric representation of the resource to load and return it
1763 }
1764 
1765 auto resource = load(entt::HashedString{"gui/background"});
1766 ```
1767 
1768 ### Conflicts
1769 
1770 The hashed string class uses internally FNV-1a to compute the numeric
1771 counterpart of a string. Because of the _pigeonhole principle_, conflicts are
1772 possible. This is a fact.<br/>
1773 There is no silver bullet to solve the problem of conflicts when dealing with
1774 hashing functions. In this case, the best solution seemed to be to give up.
1775 That's all.<br/>
1776 After all, human-readable resource identifiers aren't something strictly defined
1777 and over which users have not the control. Choosing a slightly different
1778 identifier is probably the best solution to make the conflict disappear in this
1779 case.
1780 
1781 ## Monostate
1782 
1783 The monostate pattern is often presented as an alternative to a singleton based
1784 configuration system. This is exactly its purpose in `EnTT`. Moreover, this
1785 implementation is thread safe by design (hopefully).<br/>
1786 Keys are represented by hashed strings, values are basic types like `int`s or
1787 `bool`s. Values of different types can be associated to each key, even more than
1788 one at a time. Because of this, users must pay attention to use the same type
1789 both during an assignment and when they try to read back their data. Otherwise,
1790 they will probably incur in unexpected results.
1791 
1792 Example of use:
1793 
1794 ```cpp
1795 entt::Monostate<entt::HashedString{"mykey"}>{} = true;
1796 entt::Monostate<"mykey"_hs>{} = 42;
1797 
1798 // ...
1799 
1800 const bool b = entt::Monostate<"mykey"_hs>{};
1801 const int i = entt::Monostate<entt::HashedString{"mykey"}>{};
1802 ```
1803 
1804 # Crash Course: service locator
1805 
1806 Usually service locators are tightly bound to the services they expose and it's
1807 hard to define a general purpose solution. This template based implementation
1808 tries to fill the gap and to get rid of the burden of defining a different
1809 specific locator for each application.<br/>
1810 This class is tiny, partially unsafe and thus risky to use. Moreover it doesn't
1811 fit probably most of the scenarios in which a service locator is required. Look
1812 at it as a small tool that can sometimes be useful if the user knows how to
1813 handle it.
1814 
1815 The API is straightforward. The basic idea is that services are implemented by
1816 means of interfaces and rely on polymorphism.<br/>
1817 The locator is instantiated with the base type of the service if any and a
1818 concrete implementation is provided along with all the parameters required to
1819 initialize it. As an example:
1820 
1821 ```cpp
1822 // the service has no base type, a locator is used to treat it as a kind of singleton
1823 entt::ServiceLocator<MyService>::set(params...);
1824 
1825 // sets up an opaque service
1826 entt::ServiceLocator<AudioInterface>::set<AudioImplementation>(params...);
1827 
1828 // resets (destroys) the service
1829 entt::ServiceLocator<AudioInterface>::reset();
1830 ```
1831 
1832 The locator can also be queried to know if an active service is currently set
1833 and to retrieve it if necessary (either as a pointer or as a reference):
1834 
1835 ```cpp
1836 // no service currently set
1837 auto empty = entt::ServiceLocator<AudioInterface>::empty();
1838 
1839 // gets a (possibly empty) shared pointer to the service ...
1840 std::shared_ptr<AudioInterface> ptr = entt::ServiceLocator<AudioInterface>::get();
1841 
1842 // ... or a reference, but it's undefined behaviour if the service isn't set yet
1843 AudioInterface &ref = entt::ServiceLocator<AudioInterface>::ref();
1844 ```
1845 
1846 A common use is to wrap the different locators in a container class, creating
1847 aliases for the various services:
1848 
1849 ```cpp
1850 struct Locator {
1851  using Camera = entt::ServiceLocator<CameraInterface>;
1852  using Audio = entt::ServiceLocator<AudioInterface>;
1853  // ...
1854 };
1855 
1856 // ...
1857 
1858 void init() {
1859  Locator::Camera::set<CameraNull>();
1860  Locator::Audio::set<AudioImplementation>(params...);
1861  // ...
1862 }
1863 ```
1864 
1865 # Crash Course: cooperative scheduler
1866 
1867 Sometimes processes are a useful tool to work around the strict definition of a
1868 system and introduce logic in a different way, usually without resorting to the
1869 introduction of other components.
1870 
1871 The `EnTT` framework offers a minimal support to this paradigm by introducing a
1872 few classes that users can use to define and execute cooperative processes.
1873 
1874 ## The process
1875 
1876 A typical process must inherit from the `Process` class template that stays true
1877 to the CRTP idiom. Moreover, derived classes must specify what's the intended
1878 type for elapsed times.
1879 
1880 A process should expose publicly the following member functions whether
1881 required (note that it isn't required to define a function unless the derived
1882 class wants to _override_ the default behavior):
1883 
1884 * `void update(Delta, void *);`
1885 
1886  It's invoked once per tick until a process is explicitly aborted or it
1887  terminates either with or without errors. Even though it's not mandatory to
1888  declare this member function, as a rule of thumb each process should at
1889  least define it to work properly. The `void *` parameter is an opaque pointer
1890  to user data (if any) forwarded directly to the process during an update.
1891 
1892 * `void init(void *);`
1893 
1894  It's invoked at the first tick, immediately before an update. The `void *`
1895  parameter is an opaque pointer to user data (if any) forwarded directly to the
1896  process during an update.
1897 
1898 * `void succeeded();`
1899 
1900  It's invoked in case of success, immediately after an update and during the
1901  same tick.
1902 
1903 * `void failed();`
1904 
1905  It's invoked in case of errors, immediately after an update and during the
1906  same tick.
1907 
1908 * `void aborted();`
1909 
1910  It's invoked only if a process is explicitly aborted. There is no guarantee
1911  that it executes in the same tick, this depends solely on whether the
1912  process is aborted immediately or not.
1913 
1914 Derived classes can also change the internal state of a process by invoking
1915 `succeed` and `fail`, as well as `pause` and `unpause` the process itself. All
1916 these are protected member functions made available to be able to manage the
1917 life cycle of a process from a derived class.
1918 
1919 Here is a minimal example for the sake of curiosity:
1920 
1921 ```cpp
1922 struct MyProcess: entt::Process<MyProcess, std::uint32_t> {
1923  using delta_type = std::uint32_t;
1924 
1925  void update(delta_type delta, void *) {
1926  remaining = delta > remaining ? delta_type{] : (remaining - delta);
1927 
1928  // ...
1929 
1930  if(!remaining) {
1931  succeed();
1932  }
1933  }
1934 
1935  void init(void *data) {
1936  remaining = *static_cast<delta_type *>(data);
1937  }
1938 
1939 private:
1940  delta_type remaining;
1941 };
1942 ```
1943 
1944 ### Adaptor
1945 
1946 Lambdas and functors can't be used directly with a scheduler for they are not
1947 properly defined processes with managed life cycles.<br/>
1948 This class helps in filling the gap and turning lambdas and functors into
1949 full featured processes usable by a scheduler.
1950 
1951 The function call operator has a signature similar to the one of the `update`
1952 function of a process but for the fact that it receives two extra arguments to
1953 call whenever a process is terminated with success or with an error:
1954 
1955 ```cpp
1956 void(Delta delta, void *data, auto succeed, auto fail);
1957 ```
1958 
1959 Parameters have the following meaning:
1960 
1961 * `delta` is the elapsed time.
1962 * `data` is an opaque pointer to user data if any, `nullptr` otherwise.
1963 * `succeed` is a function to call when a process terminates with success.
1964 * `fail` is a function to call when a process terminates with errors.
1965 
1966 Both `succeed` and `fail` accept no parameters at all.
1967 
1968 Note that usually users shouldn't worry about creating adaptors at all. A
1969 scheduler creates them internally each and every time a lambda or a functor is
1970 used as a process.
1971 
1972 ## The scheduler
1973 
1974 A cooperative scheduler runs different processes and helps managing their life
1975 cycles.
1976 
1977 Each process is invoked once per tick. If it terminates, it's removed
1978 automatically from the scheduler and it's never invoked again. Otherwise it's
1979 a good candidate to run once more the next tick.<br/>
1980 A process can also have a child. In this case, the process is replaced with
1981 its child when it terminates if it returns with success. In case of errors,
1982 both the process and its child are discarded. This way, it's easy to create
1983 chain of processes to run sequentially.
1984 
1985 Using a scheduler is straightforward. To create it, users must provide only the
1986 type for the elapsed times and no arguments at all:
1987 
1988 ```cpp
1989 Scheduler<std::uint32_t> scheduler;
1990 ```
1991 
1992 It has member functions to query its internal data structures, like `empty` or
1993 `size`, as well as a `clear` utility to reset it to a clean state:
1994 
1995 ```cpp
1996 // checks if there are processes still running
1997 const auto empty = scheduler.empty();
1998 
1999 // gets the number of processes still running
2000 Scheduler<std::uint32_t>::size_type size = scheduler.size();
2001 
2002 // resets the scheduler to its initial state and discards all the processes
2003 scheduler.clear();
2004 ```
2005 
2006 To attach a process to a scheduler there are mainly two ways:
2007 
2008 * If the process inherits from the `Process` class template, it's enough to
2009  indicate its type and submit all the parameters required to construct it to
2010  the `attach` member function:
2011 
2012  ```cpp
2013  scheduler.attach<MyProcess>("foobar");
2014  ```
2015 
2016 * Otherwise, in case of a lambda or a functor, it's enough to provide an
2017  instance of the class to the `attach` member function:
2018 
2019  ```cpp
2020  scheduler.attach([](auto...){ /* ... */ });
2021  ```
2022 
2023 In both cases, the return value is an opaque object that offers a `then` member
2024 function to use to create chains of processes to run sequentially.<br/>
2025 As a minimal example of use:
2026 
2027 ```cpp
2028 // schedules a task in the form of a lambda function
2029 scheduler.attach([](auto delta, void *, auto succeed, auto fail) {
2030  // ...
2031 })
2032 // appends a child in the form of another lambda function
2033 .then([](auto delta, void *, auto succeed, auto fail) {
2034  // ...
2035 })
2036 // appends a child in the form of a process class
2037 .then<MyProcess>();
2038 ```
2039 
2040 To update a scheduler and thus all its processes, the `update` member function
2041 is the way to go:
2042 
2043 ```cpp
2044 // updates all the processes, no user data are provided
2045 scheduler.update(delta);
2046 
2047 // updates all the processes and provides them with custom data
2048 scheduler.update(delta, &data);
2049 ```
2050 
2051 In addition to these functions, the scheduler offers an `abort` member function
2052 that can be used to discard all the running processes at once:
2053 
2054 ```cpp
2055 // aborts all the processes abruptly ...
2056 scheduler.abort(true);
2057 
2058 // ... or gracefully during the next tick
2059 scheduler.abort();
2060 ```
2061 
2062 # Crash Course: resource management
2063 
2064 Resource management is usually one of the most critical part of a software like
2065 a game. Solutions are often tuned to the particular application. There exist
2066 several approaches and all of them are perfectly fine as long as they fit the
2067 requirements of the piece of software in which they are used.<br/>
2068 Examples are loading everything on start, loading on request, predictive
2069 loading, and so on.
2070 
2071 The `EnTT` framework doesn't pretend to offer a _one-fits-all_ solution for the
2072 different cases. Instead, it offers a minimal and perhaps trivial cache that can
2073 be useful most of the time during prototyping and sometimes even in a production
2074 environment.<br/>
2075 For those interested in the subject, the plan is to improve it considerably over
2076 time in terms of performance, memory usage and functionalities. Hoping to make
2077 it, of course, one step at a time.
2078 
2079 ## The resource, the loader and the cache
2080 
2081 There are three main actors in the model: the resource, the loader and the
2082 cache.
2083 
2084 The _resource_ is whatever the user wants it to be. An image, a video, an audio,
2085 whatever. There are no limits.<br/>
2086 As a minimal example:
2087 
2088 ```cpp
2089 struct MyResource { const int value; };
2090 ```
2091 
2092 A _loader_ is a class the aim of which is to load a specific resource. It has to
2093 inherit directly from the dedicated base class as in the following example:
2094 
2095 ```cpp
2096 struct MyLoader final: entt::ResourceLoader<MyLoader, MyResource> {
2097  // ...
2098 };
2099 ```
2100 
2101 Where `MyResource` is the type of resources it creates.<br/>
2102 A resource loader must also expose a public const member function named `load`
2103 that accepts a variable number of arguments and returns a shared pointer to a
2104 resource.<br/>
2105 As an example:
2106 
2107 ```cpp
2108 struct MyLoader: entt::ResourceLoader<MyLoader, MyResource> {
2109  std::shared_ptr<MyResource> load(int value) const {
2110  // ...
2111  return std::shared_ptr<MyResource>(new MyResource{ value });
2112  }
2113 };
2114 ```
2115 
2116 In general, resource loaders should not have a state or retain data of any type.
2117 They should let the cache manage their resources instead.<br/>
2118 As a side note, base class and CRTP idiom aren't strictly required with the
2119 current implementation. One could argue that a cache can easily work with
2120 loaders of any type. However, future changes won't be breaking ones by forcing
2121 the use of a base class today and that's why the model is already in its place.
2122 
2123 Finally, a cache is a specialization of a class template tailored to a specific
2124 resource:
2125 
2126 ```cpp
2127 using MyResourceCache = entt::ResourceCache<MyResource>;
2128 
2129 // ...
2130 
2131 MyResourceCache cache{};
2132 ```
2133 
2134 The idea is to create different caches for different types of resources and to
2135 manage each one independently and in the most appropriate way.<br/>
2136 As a (very) trivial example, audio tracks can survive in most of the scenes of
2137 an application while meshes can be associated with a single scene and then
2138 discarded when the user leaves it.
2139 
2140 A cache offers a set of basic functionalities to query its internal state and to
2141 _organize_ it:
2142 
2143 ```cpp
2144 // gets the number of resources managed by a cache
2145 const auto size = cache.size();
2146 
2147 // checks if a cache contains at least a valid resource
2148 const auto empty = cache.empty();
2149 
2150 // clears a cache and discards its content
2151 cache.clear();
2152 ```
2153 
2154 Besides these member functions, it contains what is needed to load, use and
2155 discard resources of the given type.<br/>
2156 Before to explore this part of the interface, it makes sense to mention how
2157 resources are identified. The type of the identifiers to use is defined as:
2158 
2159 ```cpp
2160 entt::ResourceCache<Resource>::resource_type
2161 ```
2162 
2163 Where `resource_type` is an alias for `entt::HashedString`. Therefore, resource
2164 identifiers are created explicitly as in the following example:
2165 
2166 ```cpp
2167 constexpr auto identifier = entt::ResourceCache<Resource>::resource_type{"my/resource/identifier"};
2168 // this is equivalent to the following
2169 constexpr auto hs = entt::HashedString{"my/resource/identifier"};
2170 ```
2171 
2172 The class `HashedString` is described in a dedicated section, so I won't do in
2173 details here.
2174 
2175 Resources are loaded and thus stored in a cache through the `load` member
2176 function. It accepts the loader to use as a template parameter, the resource
2177 identifier and the parameters used to construct the resource as arguments:
2178 
2179 ```cpp
2180 // uses the identifier declared above
2181 cache.load<MyLoader>(identifier, 0);
2182 
2183 // uses a const char * directly as an identifier
2184 cache.load<MyLoader>("another/identifier", 42);
2185 ```
2186 
2187 The return value can be used to know if the resource has been loaded correctly.
2188 In case the loader returns an invalid pointer or the resource already exists in
2189 the cache, a false value is returned:
2190 
2191 ```cpp
2192 if(!cache.load<MyLoader>("another/identifier", 42)) {
2193  // ...
2194 }
2195 ```
2196 
2197 Unfortunately, in this case there is no way to know what was the problem
2198 exactly. However, before trying to load a resource or after an error, one can
2199 use the `contains` member function to know if a cache already contains a
2200 specific resource:
2201 
2202 ```cpp
2203 auto exists = cache.contains("my/identifier");
2204 ```
2205 
2206 There exists also a member function to use to force a reload of an already
2207 existing resource if needed:
2208 
2209 ```cpp
2210 auto result = cache.reload<MyLoader>("another/identifier", 42);
2211 ```
2212 
2213 As above, the function returns true in case of success, false otherwise. The
2214 sole difference in this case is that an error necessarily means that the loader
2215 has failed for some reasons to load the resource.<br/>
2216 Note that the `reload` member function is a kind of alias of the following
2217 snippet:
2218 
2219 ```cpp
2220 cache.discard(identifier);
2221 cache.load<MyLoader>(identifier, 42);
2222 ```
2223 
2224 Where the `discard` member function is used to get rid of a resource if loaded.
2225 In case the cache doesn't contain a resource for the given identifier, the
2226 function does nothing and returns immediately.
2227 
2228 So far, so good. Resources are finally loaded and stored within the cache.<br/>
2229 They are returned to users in the form of handles. To get one of them:
2230 
2231 ```cpp
2232 auto handle = cache.handle("my/identifier");
2233 ```
2234 
2235 The idea behind a handle is the same of the flyweight pattern. In other terms,
2236 resources aren't copied around. Instead, instances are shared between handles.
2237 Users of a resource owns a handle and it guarantees that a resource isn't
2238 destroyed until all the handles are destroyed, even if the resource itself is
2239 removed from the cache.<br/>
2240 Handles are tiny objects both movable and copyable. They returns the contained
2241 resource as a const reference on request:
2242 
2243 * By means of the `get` member function:
2244 
2245  ```cpp
2246  const auto &resource = handle.get();
2247  ```
2248 
2249 * Using the proper cast operator:
2250 
2251  ```cpp
2252  const auto &resource = handle;
2253  ```
2254 
2255 * Through the dereference operator:
2256 
2257  ```cpp
2258  const auto &resource = *handle;
2259  ```
2260 
2261 The resource can also be accessed directly using the arrow operator if required:
2262 
2263 ```cpp
2264 auto value = handle->value;
2265 ```
2266 
2267 To test if a handle is still valid, the cast operator to `bool` allows users to
2268 use it in a guard:
2269 
2270 ```cpp
2271 if(handle) {
2272  // ...
2273 }
2274 ```
2275 
2276 Finally, in case there is the need to load a resource and thus to get a handle
2277 without storing the resource itself in the cache, users can rely on the `temp`
2278 member function template.<br/>
2279 The declaration is similar to the one of `load` but for the fact that it doesn't
2280 return a boolean value. Instead, it returns a (possibly invalid) handle for the
2281 resource:
2282 
2283 ```cpp
2284 auto handle = cache.temp<MyLoader>("another/identifier", 42);
2285 ```
2286 
2287 Do not forget to test the handle for validity. Otherwise, getting the reference
2288 to the resource it points may result in undefined behavior.
2289 
2290 # Crash Course: events, signals and everything in between
2291 
2292 Signals are usually a core part of games and software architectures in
2293 general.<br/>
2294 Roughly speaking, they help to decouple the various parts of a system while
2295 allowing them to communicate with each other somehow.
2296 
2297 The so called _modern C++_ comes with a tool that can be useful in these terms,
2298 the `std::function`. As an example, it can be used to create delegates.<br/>
2299 However, there is no guarantee that an `std::function` does not perform
2300 allocations under the hood and this could be problematic sometimes. Furthermore,
2301 it solves a problem but may not adapt well to other requirements that may arise
2302 from time to time.
2303 
2304 In case that the flexibility and potential of an `std::function` are not
2305 required or where you are looking for something different, the `EnTT` framework
2306 offers a full set of classes to solve completely different problems.
2307 
2308 ## Signals
2309 
2310 Signal handlers work with naked pointers, function pointers and pointers to
2311 member functions. Listeners can be any kind of objects and the user is in charge
2312 of connecting and disconnecting them from a signal to avoid crashes due to
2313 different lifetimes. On the other side, performance shouldn't be affected that
2314 much by the presence of such a signal handler.<br/>
2315 A signal handler can be used as a private data member without exposing any
2316 _publish_ functionality to the clients of a class. The basic idea is to impose a
2317 clear separation between the signal itself and its _sink_ class, that is a tool
2318 to be used to connect and disconnect listeners on the fly.
2319 
2320 The API of a signal handler is straightforward. The most important thing is that
2321 it comes in two forms: with and without a collector. In case a signal is
2322 associated with a collector, all the values returned by the listeners can be
2323 literally _collected_ and used later by the caller. Otherwise it works just like
2324 a plain signal that emits events from time to time.<br/>
2325 
2326 **Note**: collectors are allowed only in case of function types whose the return
2327 type isn't `void` for obvious reasons.
2328 
2329 To create instances of signal handlers there exist mainly two ways:
2330 
2331 ```cpp
2332 // no collector type
2333 entt::SigH<void(int, char)> signal;
2334 
2335 // explicit collector type
2336 entt::SigH<void(int, char), MyCollector<bool>> collector;
2337 ```
2338 
2339 As expected, they offer all the basic functionalities required to know how many
2340 listeners they contain (`size`) or if they contain at least a listener (`empty`)
2341 and even to swap two signal handlers (`swap`).
2342 
2343 Besides them, there are member functions to use both to connect and disconnect
2344 listeners in all their forms by means of a sink:
2345 
2346 ```cpp
2347 void foo(int, char) { /* ... */ }
2348 
2349 struct S {
2350  void bar(int, char) { /* ... */ }
2351 };
2352 
2353 // ...
2354 
2355 S instance;
2356 
2357 signal.sink().connect<&foo>();
2358 signal.sink().connect<S, &S::bar>(&instance);
2359 
2360 // ...
2361 
2362 // disconnects a free function
2363 signal.sink().disconnect<&foo>();
2364 
2365 // disconnect a specific member function of an instance ...
2366 signal.sink().disconnect<S, &S::bar>(&instance);
2367 
2368 // ... or an instance as a whole
2369 signal.sink().disconnect(&instance);
2370 
2371 // discards all the listeners at once
2372 signal.sink().disconnect();
2373 ```
2374 
2375 Once listeners are attached (or even if there are no listeners at all), events
2376 and data in general can be published through a signal by means of the `publish`
2377 member function:
2378 
2379 ```cpp
2380 signal.publish(42, 'c');
2381 ```
2382 
2383 To collect data, the `collect` member function should be used instead. Below is
2384 a minimal example to show how to use it:
2385 
2386 ```cpp
2387 struct MyCollector {
2388  std::vector<int> vec{};
2389 
2390  bool operator()(int v) noexcept {
2391  vec.push_back(v);
2392  return true;
2393  }
2394 };
2395 
2396 int f() { return 0; }
2397 int g() { return 1; }
2398 
2399 // ...
2400 
2401 entt::SigH<int(), MyCollector<int>> signal;
2402 
2403 signal.sink().connect<&f>();
2404 signal.sink().connect<&g>();
2405 
2406 MyCollector collector = signal.collect();
2407 
2408 assert(collector.vec[0] == 0);
2409 assert(collector.vec[1] == 1);
2410 ```
2411 
2412 As shown above, a collector must expose a function operator that accepts as an
2413 argument a type to which the return type of the listeners can be converted.
2414 Moreover, it has to return a boolean value that is false to stop collecting
2415 data, true otherwise. This way one can avoid calling all the listeners in case
2416 it isn't necessary.
2417 
2418 ## Delegate
2419 
2420 A delegate can be used as general purpose invoker with no memory overhead for
2421 free functions and member functions provided along with an instance on which
2422 to invoke them.<br/>
2423 It does not claim to be a drop-in replacement for an `std::function`, so do not
2424 expect to use it whenever an `std::function` fits well. However, it can be used
2425 to send opaque delegates around to be used to invoke functions as needed.
2426 
2427 The interface is trivial. It offers a default constructor to create empty
2428 delegates:
2429 
2430 ```cpp
2431 entt::Delegate<int(int)> delegate{};
2432 ```
2433 
2434 All what is needed to create an instance is to specify the type of the function
2435 the delegate will _contain_, that is the signature of the free function or the
2436 member function one wants to assign to it.
2437 
2438 Attempting to use an empty delegate by invoking its function call operator
2439 results in undefined behavior, most likely a crash actually. Before to use a
2440 delegate, it must be initialized.<br/>
2441 There exist two functions to do that, both named `connect`:
2442 
2443 ```cpp
2444 int f(int i) { return i; }
2445 
2446 struct MyStruct {
2447  int f(int i) { return i }
2448 };
2449 
2450 // bind a free function to the delegate
2451 delegate.connect<&f>();
2452 
2453 // bind a member function to the delegate
2454 MyStruct instance;
2455 delegate.connect<MyStruct, &MyStruct::f>(&instance);
2456 ```
2457 
2458 It hasn't a `disconnect` counterpart. Instead, there exists a `reset` member
2459 function to clear it.<br/>
2460 The `empty` member function can be used to know if a delegate is empty:
2461 
2462 ```cpp
2463 const auto empty = delegate.empty();
2464 ```
2465 
2466 Finally, to invoke a delegate, the function call operator is the way to go as
2467 usual:
2468 
2469 ```cpp
2470 auto ret = delegate(42);
2471 ```
2472 
2473 Probably too much small and pretty poor of functionalities, but the delegate
2474 class can help in a lot of cases and it has shown that it is worth keeping it
2475 within the framework.
2476 
2477 ## Event dispatcher
2478 
2479 The event dispatcher class is designed so as to be used in a loop. It allows
2480 users both to trigger immediate events or to queue events to be published all
2481 together once per tick.<br/>
2482 This class shares part of its API with the one of the signal handler, but it
2483 doesn't require that all the types of events are specified when declared:
2484 
2485 ```cpp
2486 // define a general purpose dispatcher that works with naked pointers
2487 entt::Dispatcher dispatcher{};
2488 ```
2489 
2490 In order to register an instance of a class to a dispatcher, its type must
2491 expose one or more member functions of which the return types are `void` and the
2492 argument lists are `const E &`, for each type of event `E`.<br/>
2493 To ease the development, member functions that are named `receive` are
2494 automatically detected and have not to be explicitly specified when registered.
2495 In all the other cases, the name of the member function aimed to receive the
2496 event must be provided to the `connect` member function of the sink bound to the
2497 specific event:
2498 
2499 ```cpp
2500 struct AnEvent { int value; };
2501 struct AnotherEvent {};
2502 
2503 struct Listener
2504 {
2505  void receive(const AnEvent &) { /* ... */ }
2506  void method(const AnotherEvent &) { /* ... */ }
2507 };
2508 
2509 // ...
2510 
2511 Listener listener;
2512 dispatcher.sink<AnEvent>().connect(&listener);
2513 dispatcher.sink<AnotherEvent>().connect<Listener, &Listener::method>(&listener);
2514 ```
2515 
2516 The `disconnect` member function follows the same pattern and can be used to
2517 selectively remove listeners:
2518 
2519 ```cpp
2520 dispatcher.sink<AnEvent>().disconnect(&listener);
2521 dispatcher.sink<AnotherEvent>().disconnect<Listener, &Listener::method>(&listener);
2522 ```
2523 
2524 The `trigger` member function serves the purpose of sending an immediate event
2525 to all the listeners registered so far. It offers a convenient approach that
2526 relieves the user from having to create the event itself. Instead, it's enough
2527 to specify the type of event and provide all the parameters required to
2528 construct it.<br/>
2529 As an example:
2530 
2531 ```cpp
2532 dispatcher.trigger<AnEvent>(42);
2533 dispatcher.trigger<AnotherEvent>();
2534 ```
2535 
2536 Listeners are invoked immediately, order of execution isn't guaranteed. This
2537 method can be used to push around urgent messages like an _is terminating_
2538 notification on a mobile app.
2539 
2540 On the other hand, the `enqueue` member function queues messages together and
2541 allows to maintain control over the moment they are sent to listeners. The
2542 signature of this method is more or less the same of `trigger`:
2543 
2544 ```cpp
2545 dispatcher.enqueue<AnEvent>(42);
2546 dispatcher.enqueue<AnotherEvent>();
2547 ```
2548 
2549 Events are stored aside until the `update` member function is invoked, then all
2550 the messages that are still pending are sent to the listeners at once:
2551 
2552 ```cpp
2553 // emits all the events of the given type at once
2554 dispatcher.update<MyEvent>();
2555 
2556 // emits all the events queued so far at once
2557 dispatcher.update();
2558 ```
2559 
2560 This way users can embed the dispatcher in a loop and literally dispatch events
2561 once per tick to their systems.
2562 
2563 ## Event emitter
2564 
2565 A general purpose event emitter thought mainly for those cases where it comes to
2566 working with asynchronous stuff.<br/>
2567 Originally designed to fit the requirements of
2568 [`uvw`](https://github.com/skypjack/uvw) (a wrapper for `libuv` written in
2569 modern C++), it was adapted later to be included in this library.
2570 
2571 To create a custom emitter type, derived classes must inherit directly from the
2572 base class as:
2573 
2574 ```cpp
2575 struct MyEmitter: Emitter<MyEmitter> {
2576  // ...
2577 }
2578 ```
2579 
2580 The full list of accepted types of events isn't required. Handlers are created
2581 internally on the fly and thus each type of event is accepted by default.
2582 
2583 Whenever an event is published, an emitter provides the listeners with a
2584 reference to itself along with a const reference to the event. Therefore
2585 listeners have an handy way to work with it without incurring in the need of
2586 capturing a reference to the emitter itself.<br/>
2587 In addition, an opaque object is returned each time a connection is established
2588 between an emitter and a listener, allowing the caller to disconnect them at a
2589 later time.<br/>
2590 The opaque object used to handle connections is both movable and copyable. On
2591 the other side, an event emitter is movable but not copyable by default.
2592 
2593 To create new instances of an emitter, no arguments are required:
2594 
2595 ```cpp
2596 MyEmitter emitter{};
2597 ```
2598 
2599 Listeners must be movable and callable objects (free functions, lambdas,
2600 functors, `std::function`s, whatever) whose function type is:
2601 
2602 ```cpp
2603 void(const Event &, MyEmitter &)
2604 ```
2605 
2606 Where `Event` is the type of event they want to listen.<br/>
2607 There are two ways to attach a listener to an event emitter that differ
2608 slightly from each other:
2609 
2610 * To register a long-lived listener, use the `on` member function. It is meant
2611  to register a listener designed to be invoked more than once for the given
2612  event type.<br/>
2613  As an example:
2614 
2615  ```cpp
2616  auto conn = emitter.on<MyEvent>([](const MyEvent &event, MyEmitter &emitter) {
2617  // ...
2618  });
2619  ```
2620 
2621  The connection object can be freely discarded. Otherwise, it can be used later
2622  to disconnect the listener if required.
2623 
2624 * To register a short-lived listener, use the `once` member function. It is
2625  meant to register a listener designed to be invoked only once for the given
2626  event type. The listener is automatically disconnected after the first
2627  invocation.<br/>
2628  As an example:
2629 
2630  ```cpp
2631  auto conn = emitter.once<MyEvent>([](const MyEvent &event, MyEmitter &emitter) {
2632  // ...
2633  });
2634  ```
2635 
2636  The connection object can be freely discarded. Otherwise, it can be used later
2637  to disconnect the listener if required.
2638 
2639 In both cases, the connection object can be used with the `erase` member
2640 function:
2641 
2642 ```cpp
2643 emitter.erase(conn);
2644 ```
2645 
2646 There are also two member functions to use either to disconnect all the
2647 listeners for a given type of event or to clear the emitter:
2648 
2649 ```cpp
2650 // removes all the listener for the specific event
2651 emitter.clear<MyEvent>();
2652 
2653 // removes all the listeners registered so far
2654 emitter.clear();
2655 ```
2656 
2657 To send an event to all the listeners that are interested in it, the `publish`
2658 member function offers a convenient approach that relieves the user from having
2659 to create the event:
2660 
2661 ```cpp
2662 struct MyEvent { int i; };
2663 
2664 // ...
2665 
2666 emitter.publish<MyEvent>(42);
2667 ```
2668 
2669 Finally, the `empty` member function tests if there exists at least either a
2670 listener registered with the event emitter or to a given type of event:
2671 
2672 ```cpp
2673 bool empty;
2674 
2675 // checks if there is any listener registered for the specific event
2676 empty = emitter.empty<MyEvent>();
2677 
2678 // checks it there are listeners registered with the event emitter
2679 empty = emitter.empty();
2680 ```
2681 
2682 In general, the event emitter is a handy tool when the derived classes _wrap_
2683 asynchronous operations, because it introduces a _nice-to-have_ model based on
2684 events and listeners that kindly hides the complexity behind the scenes. However
2685 it is not limited to such uses.
2686 
2687 # Packaging Tools
2688 
2689 `EnTT` is available for some of the most known packaging tools. In particular:
2690 
2691 * [`vcpkg`](https://github.com/Microsoft/vcpkg/tree/master/ports/entt),
2692  Microsoft VC++ Packaging Tool.
2693 * [`Homebrew`](https://github.com/skypjack/homebrew-entt), the missing package
2694  manager for macOS.<br/>
2695  Available as a homebrew formula. Just type the following to install it:
2696  ```
2697  brew install skypjack/entt/entt
2698  ```
2699 
2700 Consider this list a work in progress and help me to make it longer.
2701 
2702 # EnTT in Action
2703 
2704 `EnTT` is widely used in private and commercial applications. I cannot even
2705 mention most of them because of some signatures I put on some documents time
2706 ago.<br/>
2707 Fortunately, there are also people who took the time to implement open source
2708 projects based on EnTT and did not hold back when it came to documenting them.
2709 
2710 Below an incomplete list of projects and articles:
2711 
2712 * [EnttPong](https://github.com/reworks/EnttPong): example game for `EnTT`
2713  framework.
2714 * [Space Battle: Huge edition](http://victor.madtriangles.com/code%20experiment/2018/06/11/post-ecs-battle-huge.html):
2715  huge space battle built entirely from scratch.
2716 * [Space Battle](https://github.com/vblanco20-1/ECS_SpaceBattle): huge space
2717  battle built on `UE4`.
2718 * [Experimenting with ECS in UE4](http://victor.madtriangles.com/code%20experiment/2018/03/25/post-ue4-ecs-battle.html):
2719  interesting article about `UE4` and `EnTT`.
2720 * [Implementing ECS architecture in UE4](https://forums.unrealengine.com/development-discussion/c-gameplay-programming/1449913-implementing-ecs-architecture-in-ue4-giant-space-battle):
2721  giant space battle.
2722 * [MatchOneEntt](https://github.com/mhaemmerle/MatchOneEntt): port of
2723  [Match One](https://github.com/sschmid/Match-One) for `Entitas-CSharp`.
2724 * [Randballs](https://github.com/gale93/randballs): simple `SFML` and `EnTT`
2725  playground.
2726 * ...
2727 
2728 If you know of other resources out there that are about `EnTT`, feel free to
2729 open an issue or a PR and I'll be glad to add them to the list.
2730 
2731 # Contributors
2732 
2733 If you want to participate, please see the guidelines for
2734 [contributing](https://github.com/skypjack/entt/blob/master/CONTRIBUTING)
2735 before to create issues or pull requests.<br/>
2736 Take also a look at the
2737 [contributors list](https://github.com/skypjack/entt/blob/master/AUTHORS) to
2738 know who has participated so far.
2739 
2740 # License
2741 
2742 Code and documentation Copyright (c) 2018 Michele Caini.<br/>
2743 Code released under
2744 [the MIT license](https://github.com/skypjack/entt/blob/master/LICENSE).
2745 Docs released under
2746 [Creative Commons](https://github.com/skypjack/entt/blob/master/docs/LICENSE).
2747 
2748 # Support
2749 
2750 ## Donation
2751 
2752 Developing and maintaining `EnTT` takes some time and lots of coffee. I'd like
2753 to add more and more functionalities in future and turn it in a full-featured
2754 framework.<br/>
2755 If you want to support this project, you can offer me an espresso. I'm from
2756 Italy, we're used to turning the best coffee ever in code. If you find that
2757 it's not enough, feel free to support me the way you prefer.<br/>
2758 Take a look at the donation button at the top of the page for more details or
2759 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).
2760 
2761 ## Hire me
2762 
2763 If you start using `EnTT` and need help, if you want a new feature and want me
2764 to give it the highest priority, if you have any other reason to contact me:
2765 do not hesitate. I'm available for hiring.<br/>
2766 Feel free to take a look at my [profile](https://github.com/skypjack) and
2767 contact me by mail.
+
1 ![EnTT: Gaming meets modern C++](https://user-images.githubusercontent.com/1812216/42513718-ee6e98d0-8457-11e8-9baf-8d83f61a3097.png)
2 
3 <!--
4 @cond TURN_OFF_DOXYGEN
5 -->
6 [![Build Status](https://travis-ci.org/skypjack/entt.svg?branch=master)](https://travis-ci.org/skypjack/entt)
7 [![Build status](https://ci.appveyor.com/api/projects/status/rvhaabjmghg715ck?svg=true)](https://ci.appveyor.com/project/skypjack/entt)
8 [![Coverage Status](https://coveralls.io/repos/github/skypjack/entt/badge.svg?branch=master)](https://coveralls.io/github/skypjack/entt?branch=master)
9 [![Gitter chat](https://badges.gitter.im/skypjack/entt.png)](https://gitter.im/skypjack/entt)
10 [![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)
11 
12 # Table of Contents
13 
14 * [Introduction](#introduction)
15 * [Build Instructions](#build-instructions)
16 * [Crash Course: entity-component system](#crash-course-entity-component-system)
17  * [Design choices](#design-choices)
18  * [A bitset-free entity-component system](#a-bitset-free-entity-component-system)
19  * [Pay per use](#pay-per-use)
20  * [Vademecum](#vademecum)
21  * [The Registry, the Entity and the Component](#the-registry-the-entity-and-the-component)
22  * [Single instance components](#single-instance-components)
23  * [Observe changes](#observe-changes)
24  * [Who let the tags out?](#who-let-the-tags-out)
25  * [Runtime components](#runtime-components)
26  * [A journey through a plugin](#a-journey-through-a-plugin)
27  * [Sorting: is it possible?](#sorting-is-it-possible)
28  * [Snapshot: complete vs continuous](#snapshot-complete-vs-continuous)
29  * [Snapshot loader](#snapshot-loader)
30  * [Continuous loader](#continuous-loader)
31  * [Archives](#archives)
32  * [One example to rule them all](#one-example-to-rule-them-all)
33  * [Prototype](#prototype)
34  * [Helpers](#helpers)
35  * [Dependency function](#dependency-function)
36  * [Labels](#labels)
37  * [Null entity](#null-entity)
38  * [View: to persist or not to persist?](#view-to-persist-or-not-to-persist)
39  * [Standard View](#standard-view)
40  * [Single component standard view](#single-component-standard-view)
41  * [Multi component standard view](#multi-component-standard-view)
42  * [Persistent View](#persistent-view)
43  * [Raw View](#raw-view)
44  * [Runtime View](#runtime-view)
45  * [Give me everything](#give-me-everything)
46  * [Iterations: what is allowed and what is not](#iterations-what-is-allowed-and-what-is-not)
47  * [Multithreading](#multithreading)
48 * [Crash Course: core functionalities](#crash-course-core-functionalities)
49  * [Compile-time identifiers](#compile-time-identifiers)
50  * [Runtime identifiers](#runtime-identifiers)
51  * [Hashed strings](#hashed-strings)
52  * [Monostate](#monostate)
53 * [Crash Course: service locator](#crash-course-service-locator)
54 * [Crash Course: cooperative scheduler](#crash-course-cooperative-scheduler)
55  * [The process](#the-process)
56  * [The scheduler](#the-scheduler)
57 * [Crash Course: resource management](#crash-course-resource-management)
58  * [The resource, the loader and the cache](#the-resource-the-loader-and-the-cache)
59 * [Crash Course: events, signals and everything in between](#crash-course-events-signals-and-everything-in-between)
60  * [Signals](#signals)
61  * [Delegate](#delegate)
62  * [Event dispatcher](#event-dispatcher)
63  * [Event emitter](#event-emitter)
64 * [Packaging Tools](#packaging-tools)
65 * [EnTT in Action](#entt-in-action)
66 * [License](#license)
67 * [Support](#support)
68  * [Donation](#donation)
69  * [Hire me](#hire-me)
70 <!--
71 @endcond TURN_OFF_DOXYGEN
72 -->
73 
74 # Introduction
75 
76 `EnTT` is a header-only, tiny and easy to use entity-component system (and much
77 more) written in modern C++.<br/>
78 The entity-component-system (also known as _ECS_) is an architectural pattern
79 used mostly in game development. For further details:
80 
81 * [Entity Systems Wiki](http://entity-systems.wikidot.com/)
82 * [Evolve Your Hierarchy](http://cowboyprogramming.com/2007/01/05/evolve-your-heirachy/)
83 * [ECS on Wikipedia](https://en.wikipedia.org/wiki/Entity%E2%80%93component%E2%80%93system)
84 
85 A long time ago, the sole entity-component system was part of the project. After
86 a while the codebase has grown and more and more classes have become part of the
87 repository.<br/>
88 Here is a brief, yet incomplete list of what it offers today:
89 
90 * Statically generated integer identifiers for types (assigned either at
91  compile-time or at runtime).
92 * A constexpr utility for human readable resource identifiers.
93 * A minimal configuration system built on top of the monostate pattern.
94 * An incredibly fast entity-component system based on sparse sets, with its own
95  views and a _pay for what you use_ policy to adjust performance and memory
96  usage according to users' requirements.
97 * Actor class for those who aren't confident with entity-component systems.
98 * The smallest and most basic implementation of a service locator ever seen.
99 * A cooperative scheduler for processes of any type.
100 * All what is needed for resource management (cache, loaders, handles).
101 * Delegates, signal handlers (with built-in support for collectors) and a tiny
102  event dispatcher.
103 * A general purpose event emitter, that is a CRTP idiom based class template.
104 * An event dispatcher for immediate and delayed events to integrate in loops.
105 * ...
106 * Any other business.
107 
108 Consider it a work in progress. The whole API is also fully documented in-code
109 for those who are brave enough to read it.
110 
111 Currently, `EnTT` is tested on Linux, Microsoft Windows and OS X. It has proven
112 to work also on both Android and iOS.<br/>
113 Most likely it will not be problematic on other systems as well, but has not
114 been sufficiently tested so far.
115 
116 ## Code Example
117 
118 ```cpp
119 #include <entt/entt.hpp>
120 #include <cstdint>
121 
122 struct Position {
123  float x;
124  float y;
125 };
126 
127 struct Velocity {
128  float dx;
129  float dy;
130 };
131 
132 void update(entt::DefaultRegistry &registry) {
133  auto view = registry.view<Position, Velocity>();
134 
135  for(auto entity: view) {
136  // gets only the components that are going to be used ...
137 
138  auto &velocity = view.get<Velocity>(entity);
139 
140  velocity.dx = 0.;
141  velocity.dy = 0.;
142 
143  // ...
144  }
145 }
146 
147 void update(std::uint64_t dt, entt::DefaultRegistry &registry) {
148  registry.view<Position, Velocity>().each([dt](auto entity, auto &position, auto &velocity) {
149  // gets all the components of the view at once ...
150 
151  position.x += velocity.dx * dt;
152  position.y += velocity.dy * dt;
153 
154  // ...
155  });
156 }
157 
158 int main() {
159  entt::DefaultRegistry registry;
160  std::uint64_t dt = 16;
161 
162  for(auto i = 0; i < 10; ++i) {
163  auto entity = registry.create();
164  registry.assign<Position>(entity, i * 1.f, i * 1.f);
165  if(i % 2 == 0) { registry.assign<Velocity>(entity, i * .1f, i * .1f); }
166  }
167 
168  update(dt, registry);
169  update(registry);
170 
171  // ...
172 }
173 ```
174 
175 ## Motivation
176 
177 I started working on `EnTT` because of the wrong reason: my goal was to design
178 an entity-component system that beated another well known open source solution
179 in terms of performance and used (possibly) less memory in the average
180 case.<br/>
181 In the end, I did it, but it wasn't much satisfying. Actually it wasn't
182 satisfying at all. The fastest and nothing more, fairly little indeed. When I
183 realized it, I tried hard to keep intact the great performance of `EnTT` and to
184 add all the features I wanted to see in *my own library* at the same time.
185 
186 Nowadays, `EnTT` is finally what I was looking for: still faster than its
187 _competitors_, lower memory usage in the average case, a really good API and an
188 amazing set of features. And even more, of course.
189 
190 ## Performance
191 
192 As it stands right now, `EnTT` is just fast enough for my requirements if
193 compared to my first choice (it was already amazingly fast actually).<br/>
194 Below is a comparison between the two (both of them compiled with GCC 7.3.0 on a
195 Dell XPS 13 out of the mid 2014):
196 
197 | Benchmark | EntityX (compile-time) | EnTT |
198 |-----------|-------------|-------------|
199 | Create 1M entities | 0.0147s | **0.0046s** |
200 | Destroy 1M entities | 0.0053s | **0.0045s** |
201 | 1M entities, one component | 0.0012s | **1.9e-07s** |
202 | 1M entities, two components | 0.0012s | **3.8e-07s** |
203 | 1M entities, two components<br/>Half of the entities have all the components | 0.0009s | **3.8e-07s** |
204 | 1M entities, two components<br/>One of the entities has all the components | 0.0008s | **1.0e-06s** |
205 | 1M entities, five components | 0.0010s | **7.0e-07s** |
206 | 1M entities, ten components | 0.0011s | **1.2e-06s** |
207 | 1M entities, ten components<br/>Half of the entities have all the components | 0.0010s | **1.2e-06s** |
208 | 1M entities, ten components<br/>One of the entities has all the components | 0.0008s | **1.2e-06s** |
209 | Sort 150k entities, one component<br/>Arrays are in reverse order | - | **0.0036s** |
210 | Sort 150k entities, enforce permutation<br/>Arrays are in reverse order | - | **0.0005s** |
211 | Sort 150k entities, one component<br/>Arrays are almost sorted, std::sort | - | **0.0035s** |
212 | Sort 150k entities, one component<br/>Arrays are almost sorted, insertion sort | - | **0.0007s** |
213 
214 Note: The default version of `EntityX` (`master` branch) wasn't added to the
215 comparison because it's already much slower than its compile-time counterpart.
216 
217 Pretty interesting, aren't them? In fact, these benchmarks are the same used by
218 `EntityX` to show _how fast it is_. To be honest, they aren't so good and these
219 results shouldn't be taken much seriously (they are completely unrealistic
220 indeed).<br/>
221 The proposed entity-component system is incredibly fast to iterate entities,
222 this is a fact. The compiler can make a lot of optimizations because of how
223 `EnTT` works, even more when components aren't used at all. This is exactly the
224 case for these benchmarks. On the other hand and if we consider real world
225 cases, `EnTT` is in the middle between a bit and much faster than the other
226 solutions around when users also access the components and not just the
227 entities, although it is not as fast as reported by these benchmarks.<br/>
228 This is why they are completely wrong and cannot be used to evaluate any of the
229 entity-component systems.
230 
231 If you decide to use `EnTT`, choose it because of its API, features and
232 performance, not because there is a benchmark somewhere that makes it seem the
233 fastest.
234 
235 Probably I'll try to get out of `EnTT` more features and even better performance
236 in the future, mainly for fun.<br/>
237 If you want to contribute and/or have any suggestion, feel free to make a PR or
238 open an issue to discuss your idea.
239 
240 # Build Instructions
241 
242 ## Requirements
243 
244 To be able to use `EnTT`, users must provide a full-featured compiler that
245 supports at least C++14.<br/>
246 The requirements below are mandatory to compile the tests and to extract the
247 documentation:
248 
249 * CMake version 3.2 or later.
250 * Doxygen version 1.8 or later.
251 
252 ## Library
253 
254 `EnTT` is a header-only library. This means that including the `entt.hpp` header
255 is enough to include the library as a whole and use it. For those who are
256 interested only in the entity-component system, consider to include the sole
257 `entity/registry.hpp` header instead.<br/>
258 It's a matter of adding the following line to the top of a file:
259 
260 ```cpp
261 #include <entt/entt.hpp>
262 ```
263 
264 Use the line below to include only the entity-component system instead:
265 
266 ```cpp
267 #include <entt/entity/registry.hpp>
268 ```
269 
270 Then pass the proper `-I` argument to the compiler to add the `src` directory to
271 the include paths.
272 
273 ### Side note: shared libraries
274 
275 To make sure that an application and a shared library that use both `EnTT` can
276 interact correctly when symbols are hidden by default, there are some tricks to
277 follow.<br/>
278 In particular and in order to avoid undefined behaviors, all the instantiation
279 of the `Family` class template shall be made explicit along with the system-wide
280 specifier to use to export them.
281 
282 At the time I'm writing this document, the classes that use internally the above
283 mentioned class template are `Dispatcher`, `Emitter` and `Registry`. Therefore
284 and as an example, if you use the `Registry` class template in your shared
285 library and want to set symbols visibility to _hidden_ by default, the following
286 lines are required to allow it to function properly with a client that also uses
287 the `Registry` somehow:
288 
289 * On GNU/Linux:
290 
291  ```cpp
292  namespace entt {
293  template class __attribute__((visibility("default"))) Family<struct InternalRegistryTagFamily>;
294  template class __attribute__((visibility("default"))) Family<struct InternalRegistryComponentFamily>;
295  template class __attribute__((visibility("default"))) Family<struct InternalRegistryHandlerFamily>;
296  }
297  ```
298 
299 * On Windows:
300 
301  ```cpp
302  namespace entt {
303  template class __declspec(dllexport) Family<struct InternalRegistryTagFamily>;
304  template class __declspec(dllexport) Family<struct InternalRegistryComponentFamily>;
305  template class __declspec(dllexport) Family<struct InternalRegistryHandlerFamily>;
306  }
307  ```
308 
309 Otherwise, the risk is that type identifiers are different between the shared
310 library and the application and this will prevent the whole thing from
311 functioning correctly for obvious reasons.
312 
313 ## Documentation
314 
315 The documentation is based on [doxygen](http://www.stack.nl/~dimitri/doxygen/).
316 To build it:
317 
318  $ cd build
319  $ cmake .. -DBUILD_DOCS=ON
320  $ make
321 
322 The API reference will be created in HTML format within the directory
323 `build/docs/html`. To navigate it with your favorite browser:
324 
325  $ cd build
326  $ your_favorite_browser docs/html/index.html
327 
328 <!--
329 @cond TURN_OFF_DOXYGEN
330 -->
331 The API reference is also available [online](https://skypjack.github.io/entt/)
332 for the latest version.
333 <!--
334 @endcond TURN_OFF_DOXYGEN
335 -->
336 
337 ## Tests
338 
339 To compile and run the tests, `EnTT` requires *googletest*.<br/>
340 `cmake` will download and compile the library before compiling anything else.
341 In order to build without tests set CMake option `BUILD_TESTING=OFF`.
342 
343 To build the most basic set of tests:
344 
345 * `$ cd build`
346 * `$ cmake ..`
347 * `$ make`
348 * `$ make test`
349 
350 Note that benchmarks are not part of this set.
351 
352 # Crash Course: entity-component system
353 
354 ## Design choices
355 
356 ### A bitset-free entity-component system
357 
358 `EnTT` is a _bitset-free_ entity-component system that doesn't require users to
359 specify the component set at compile-time.<br/>
360 This is why users can instantiate the core class simply like:
361 
362 ```cpp
363 entt::DefaultRegistry registry;
364 ```
365 
366 In place of its more annoying and error-prone counterpart:
367 
368 ```cpp
369 entt::DefaultRegistry<Comp0, Comp1, ..., CompN> registry;
370 ```
371 
372 ### Pay per use
373 
374 `EnTT` is entirely designed around the principle that users have to pay only for
375 what they want.
376 
377 When it comes to using an entity-component system, the tradeoff is usually
378 between performance and memory usage. The faster it is, the more memory it uses.
379 However, slightly worse performance along non-critical paths are the right price
380 to pay to reduce memory usage and I've always wondered why this kind of tools do
381 not leave me the choice.<br/>
382 `EnTT` follows a completely different approach. It squeezes the best from the
383 basic data structures and gives users the possibility to pay more for higher
384 performance where needed.<br/>
385 The disadvantage of this approach is that users need to know the systems they
386 are working on and the tools they are using. Otherwise, the risk to ruin the
387 performance along critical paths is high.
388 
389 So far, this choice has proven to be a good one and I really hope it can be for
390 many others besides me.
391 
392 ## Vademecum
393 
394 The `Registry` to store, the views to iterate. That's all.
395 
396 An entity (the _E_ of an _ECS_) is an opaque identifier that users should just
397 use as-is and store around if needed. Do not try to inspect an entity
398 identifier, its format can change in future and a registry offers all the
399 functionalities to query them out-of-the-box. The underlying type of an entity
400 (either `std::uint16_t`, `std::uint32_t` or `std::uint64_t`) can be specified
401 when defining a registry (actually the `DefaultRegistry` is nothing more than a
402 `Registry` where the type of the entities is `std::uint32_t`).<br/>
403 Components (the _C_ of an _ECS_) should be plain old data structures or more
404 complex and movable data structures with a proper constructor. Actually, the
405 sole requirement of a component type is that it must be both move constructible
406 and move assignable. They are list initialized by using the parameters provided
407 to construct the component itself. No need to register components or their types
408 neither with the registry nor with the entity-component system at all.<br/>
409 Systems (the _S_ of an _ECS_) are just plain functions, functors, lambdas or
410 whatever users want. They can accept a `Registry` or a view of any type and use
411 them the way they prefer. No need to register systems or their types neither
412 with the registry nor with the entity-component system at all.
413 
414 The following sections will explain in short how to use the entity-component
415 system, the core part of the whole library.<br/>
416 In fact, the project is composed of many other classes in addition to those
417 describe below. For more details, please refer to the inline documentation.
418 
419 ## The Registry, the Entity and the Component
420 
421 A registry can store and manage entities, as well as create views to iterate the
422 underlying data structures.<br/>
423 `Registry` is a class template that lets users decide what's the preferred type
424 to represent an entity. Because `std::uint32_t` is large enough for almost all
425 the cases, there exists also an alias named `DefaultRegistry` for
426 `Registry<std::uint32_t>`.
427 
428 Entities are represented by _entity identifiers_. An entity identifier is an
429 opaque type that users should not inspect or modify in any way. It carries
430 information about the entity itself and its version.
431 
432 A registry can be used both to construct and destroy entities:
433 
434 ```cpp
435 // constructs a naked entity with no components and returns its identifier
436 auto entity = registry.create();
437 
438 // destroys an entity and all its components
439 registry.destroy(entity);
440 ```
441 
442 Entities can also be destroyed _by type_, that is by specifying the types of the
443 tags or components that identify them:
444 
445 ```cpp
446 // destroys the entity that owns the given tag, if any
447 registry.destroy<MyTag>(entt::tag_t{});
448 
449 // destroys the entities that own the given components, if any
450 registry.destroy<AComponent, AnotherComponent>();
451 ```
452 
453 When an entity is destroyed, the registry can freely reuse it internally with a
454 slightly different identifier. In particular, the version of an entity is
455 increased each and every time it's discarded.<br/>
456 In case entity identifiers are stored around, the registry offers all the
457 functionalities required to test them and get out of the them all the
458 information they carry:
459 
460 ```cpp
461 // returns true if the entity is still valid, false otherwise
462 bool b = registry.valid(entity);
463 
464 // gets the version contained in the entity identifier
465 auto version = registry.version(entity);
466 
467 // gets the actual version for the given entity
468 auto curr = registry.current(entity);
469 ```
470 
471 Components can be assigned to or removed from entities at any time with a few
472 calls to member functions of the registry. As for the entities, the registry
473 offers also a set of functionalities users can use to work with the components.
474 
475 The `assign` member function template creates, initializes and assigns to an
476 entity the given component. It accepts a variable number of arguments to
477 construct the component itself if present:
478 
479 ```cpp
480 registry.assign<Position>(entity, 0., 0.);
481 
482 // ...
483 
484 Velocity &velocity = registry.assign<Velocity>(entity);
485 velocity.dx = 0.;
486 velocity.dy = 0.;
487 ```
488 
489 If an entity already has the given component, the `replace` member function
490 template can be used to replace it:
491 
492 ```cpp
493 registry.replace<Position>(entity, 0., 0.);
494 
495 // ...
496 
497 Velocity &velocity = registry.replace<Velocity>(entity);
498 velocity.dx = 0.;
499 velocity.dy = 0.;
500 ```
501 
502 In case users want to assign a component to an entity, but it's unknown whether
503 the entity already has it or not, `accommodate` does the work in a single call
504 (there is a performance penalty to pay for this mainly due to the fact that it
505 has to check if the entity already has the given component or not):
506 
507 ```cpp
508 registry.accommodate<Position>(entity, 0., 0.);
509 
510 // ...
511 
512 Velocity &velocity = registry.accommodate<Velocity>(entity);
513 velocity.dx = 0.;
514 velocity.dy = 0.;
515 ```
516 
517 Note that `accommodate` is a slightly faster alternative for the following
518 `if/else` statement and nothing more:
519 
520 ```cpp
521 if(registry.has<Comp>(entity)) {
522  registry.replace<Comp>(entity, arg1, argN);
523 } else {
524  registry.assign<Comp>(entity, arg1, argN);
525 }
526 ```
527 
528 As already shown, if in doubt about whether or not an entity has one or more
529 components, the `has` member function template may be useful:
530 
531 ```cpp
532 bool b = registry.has<Position, Velocity>(entity);
533 ```
534 
535 On the other side, if the goal is to delete a single component, the `remove`
536 member function template is the way to go when it's certain that the entity owns
537 a copy of the component:
538 
539 ```cpp
540 registry.remove<Position>(entity);
541 ```
542 
543 Otherwise consider to use the `reset` member function. It behaves similarly to
544 `remove` but with a strictly defined behavior (and a performance penalty is the
545 price to pay for this). In particular it removes the component if and only if it
546 exists, otherwise it returns safely to the caller:
547 
548 ```cpp
549 registry.reset<Position>(entity);
550 ```
551 
552 There exist also two other _versions_ of the `reset` member function:
553 
554 * If no entity is passed to it, `reset` will remove the given component from
555  each entity that has it:
556 
557  ```cpp
558  registry.reset<Position>();
559  ```
560 
561 * If neither the entity nor the component are specified, all the entities still
562  in use and their components are destroyed:
563 
564  ```cpp
565  registry.reset();
566  ```
567 
568 Finally, references to components can be retrieved simply by doing this:
569 
570 ```cpp
571 const auto &cregistry = registry;
572 
573 // const and non-const reference
574 const Position &position = cregistry.get<Position>(entity);
575 Position &position = registry.get<Position>(entity);
576 
577 // const and non-const references
578 std::tuple<const Position &, const Velocity &> tup = cregistry.get<Position, Velocity>(entity);
579 std::tuple<Position &, Velocity &> tup = registry.get<Position, Velocity>(entity);
580 ```
581 
582 The `get` member function template gives direct access to the component of an
583 entity stored in the underlying data structures of the registry.
584 
585 ### Single instance components
586 
587 In those cases where all what is needed is a single instance component, tags are
588 the right tool to achieve the purpose.<br/>
589 Tags undergo the same requirements of components. They can be either plain old
590 data structures or more complex and movable data structures with a proper
591 constructor.<br/>
592 Actually, the same type can be used both as a tag and as a component and the
593 registry will not complain about it. It is up to users to properly manage their
594 own types. In some cases, the tag `tag_t` must also be used in order to
595 disambiguate overloads of member functions.
596 
597 Attaching tags to entities and removing them is trivial:
598 
599 ```cpp
600 auto player = registry.create();
601 auto camera = registry.create();
602 
603 // attaches a default-initialized tag to an entity
604 registry.assign<PlayingCharacter>(entt::tag_t{}, player);
605 
606 // attaches a tag to an entity and initializes it
607 registry.assign<Camera>(entt::tag_t{}, camera, player);
608 
609 // removes tags from their owners
610 registry.remove<PlayingCharacter>();
611 registry.remove<Camera>();
612 ```
613 
614 In case a tag already has an owner, its content can be updated by means of the
615 `replace` member function template and the ownership of the tag can be
616 transferred to another entity using the `move` member function template:
617 
618 ```
619 // replaces the content of the given tag
620 Point &point = registry.replace<Point>(entt::tag_t{}, 1.f, 1.f);
621 
622 // transfers the ownership of the tag to another entity
623 entity_type prev = registry.move<Point>(next);
624 ```
625 
626 If in doubt about whether or not a tag already has an owner, the `has` member
627 function template may be useful:
628 
629 ```cpp
630 bool b = registry.has<PlayingCharacter>();
631 ```
632 
633 References to tags can be retrieved simply by doing this:
634 
635 ```cpp
636 const auto &cregistry = registry;
637 
638 // either a non-const reference ...
639 PlayingCharacter &player = registry.get<PlayingCharacter>();
640 
641 // ... or a const one
642 const Camera &camera = cregistry.get<Camera>();
643 ```
644 
645 The `get` member function template gives direct access to the tag as stored in
646 the underlying data structures of the registry.
647 
648 As shown above, in almost all the cases the entity identifier isn't required.
649 Since a single instance component can have only one associated entity, it
650 doesn't make much sense to mention it explicitly.<br/>
651 To find out who the owner is, just do the following:
652 
653 ```cpp
654 auto player = registry.attachee<PlayingCharacter>();
655 ```
656 
657 Note that iterating tags isn't possible for obvious reasons. Tags give direct
658 access to single entities and nothing more.
659 
660 ### Observe changes
661 
662 Because of how the registry works internally, it stores a couple of signal
663 handlers for each pool in order to notify some of its data structures on the
664 construction and destruction of components.<br/>
665 These signal handlers are also exposed and made available to users. This is the
666 basic brick to build fancy things like dependencies and reactive systems.
667 
668 To get a sink to be used to connect and disconnect listeners so as to be
669 notified on the creation of a component, use the `construction` member function:
670 
671 ```cpp
672 // connects a free function
673 registry.construction<Position>().connect<&MyFreeFunction>();
674 
675 // connects a member function
676 registry.construction<Position>().connect<MyClass, &MyClass::member>(&instance);
677 
678 // disconnects a free function
679 registry.construction<Position>().disconnect<&MyFreeFunction>();
680 
681 // disconnects a member function
682 registry.construction<Position>().disconnect<MyClass, &MyClass::member>(&instance);
683 ```
684 
685 To be notified when components are destroyed, use the `destruction` member
686 function instead.
687 
688 The function type of a listener is the same in both cases:
689 
690 ```cpp
691 void(Registry<Entity> &, Entity);
692 ```
693 
694 In other terms, a listener is provided with the registry that triggered the
695 notification and the entity affected by the change. Note also that:
696 
697 * Listeners are invoked **after** components have been assigned to entities.
698 * Listeners are invoked **before** components have been removed from entities.
699 * The order of invocation of the listeners isn't guaranteed in any case.
700 
701 There are also some limitations on what a listener can and cannot do. In
702 particular:
703 
704 * Connecting and disconnecting other functions from within the body of a
705  listener should be avoided. It can lead to undefined behavior in some cases.
706 * Assigning and removing components and tags from within the body of a listener
707  that observes the destruction of instances of a given type should be avoided.
708  It can lead to undefined behavior in some cases. This type of listeners is
709  intended to provide users with an easy way to perform cleanup and nothing
710  more.
711 
712 To a certain extent, these limitations do not apply. However, it is risky to try
713 to force them and users should respect the limitations unless they know exactly
714 what they are doing. Subtle bugs are the price to pay in case of errors
715 otherwise.
716 
717 In general, events and therefore listeners must not be used as replacements for
718 systems. They should not contain much logic and interactions with a registry
719 should be kept to a minimum, if possible. Note also that the greater the number
720 of listeners, the greater the performance hit when components are created or
721 destroyed.
722 
723 #### Who let the tags out?
724 
725 As an extension, signals are also provided with tags. Although they are not
726 strictly required internally, it makes sense that a user expects signal support
727 even when it comes to tags actually.<br/>
728 Signals for tags undergo exactly the same requirements of those introduced for
729 components. Also the function type for a listener is the same and it's invoked
730 with the same guarantees discussed above.
731 
732 To get the sinks for a tag just use tag `tag_t` to disambiguate overloads of
733 member functions as in the following example:
734 
735 ```cpp
736 registry.construction<MyTag>(entt::tag_t{}).connect<&MyFreeFunction>();
737 registry.destruction<MyTag>(entt::tag_t{}).connect<MyClass, &MyClass::member>(&instance);
738 ```
739 
740 Listeners for tags and components are managed separately and do not influence
741 each other in any case. Therefore, note that the greater the number of listeners
742 for a type, the greater the performance hit when a tag of the given type is
743 created or destroyed.
744 
745 ### Runtime components
746 
747 Defining components at runtime is useful to support plugin systems and mods in
748 general. However, it seems impossible with a tool designed around a bunch of
749 templates. Indeed it's not that difficult.<br/>
750 Of course, some features cannot be easily exported into a runtime
751 environment. As an example, sorting a group of components defined at runtime
752 isn't for free if compared to most of the other operations. However, the basic
753 functionalities of an entity-component system such as `EnTT` fit the problem
754 perfectly and can also be used to manage runtime components if required.<br/>
755 All that is necessary to do it is to know the identifiers of the components. An
756 identifier is nothing more than a number or similar that can be used at runtime
757 to work with the type system.
758 
759 In `EnTT`, identifiers are easily accessible:
760 
761 ```cpp
762 entt::DefaultRegistry registry;
763 
764 // standard component identifier
765 auto ctype = registry.type<Position>();
766 
767 // single instance component identifier
768 auto ttype = registry.type<PlayingCharacter>(entt::tag_t{});
769 ```
770 
771 Once the identifiers are made available, almost everything becomes pretty
772 simple.
773 
774 #### A journey through a plugin
775 
776 `EnTT` comes with an example (actually a test) that shows how to integrate
777 compile-time and runtime components in a stack based JavaScript environment. It
778 uses [`Duktape`](https://github.com/svaarala/duktape) under the hood, mainly
779 because I wanted to learn how it works at the time I was writing the code.
780 
781 The code is not production-ready and overall performance can be highly improved.
782 However, I sacrificed optimizations in favor of a more readable piece of code. I
783 hope I succeeded.<br/>
784 Note also that this isn't neither the only nor (probably) the best way to do it.
785 In fact, the right way depends on the scripting language and the problem one is
786 facing in general.<br/>
787 That being said, feel free to use it at your own risk.
788 
789 The basic idea is that of creating a compile-time component aimed to map all the
790 runtime components assigned to an entity.<br/>
791 Identifiers come in use to address the right function from a map when invoked
792 from the runtime environment and to filter entities when iterating.<br/>
793 With a bit of gymnastic, one can narrow views and improve the performance to
794 some extent but it was not the goal of the example.
795 
796 ### Sorting: is it possible?
797 
798 It goes without saying that sorting entities and components is possible with
799 `EnTT`.<br/>
800 In fact, there are two functions that respond to slightly different needs:
801 
802 * Components can be sorted directly:
803 
804  ```cpp
805  registry.sort<Renderable>([](const auto &lhs, const auto &rhs) {
806  return lhs.z < rhs.z;
807 
808  });
809  ```
810 
811  There exists also the possibility to use a custom sort function object, as
812  long as it adheres to the requirements described in the inline
813  documentation.<br/>
814  This is possible mainly because users can get much more with a custom sort
815  function object if the pattern of usage is known. As an example, in case of an
816  almost sorted pool, quick sort could be much, much slower than insertion sort.
817 
818 * Components can be sorted according to the order imposed by another component:
819 
820  ```cpp
821  registry.sort<Movement, Physics>();
822  ```
823 
824  In this case, instances of `Movement` are arranged in memory so that cache
825  misses are minimized when the two components are iterated together.
826 
827 ### Snapshot: complete vs continuous
828 
829 The `Registry` class offers basic support to serialization.<br/>
830 It doesn't convert components and tags to bytes directly, there wasn't the need
831 of another tool for serialization out there. Instead, it accepts an opaque
832 object with a suitable interface (namely an _archive_) to serialize its internal
833 data structures and restore them later. The way types and instances are
834 converted to a bunch of bytes is completely in charge to the archive and thus to
835 final users.
836 
837 The goal of the serialization part is to allow users to make both a dump of the
838 entire registry or a narrower snapshot, that is to select only the components
839 and the tags in which they are interested.<br/>
840 Intuitively, the use cases are different. As an example, the first approach is
841 suitable for local save/restore functionalities while the latter is suitable for
842 creating client-server applications and for transferring somehow parts of the
843 representation side to side.
844 
845 To take a snapshot of the registry, use the `snapshot` member function. It
846 returns a temporary object properly initialized to _save_ the whole registry or
847 parts of it.
848 
849 Example of use:
850 
851 ```cpp
852 OutputArchive output;
853 
854 registry.snapshot()
855  .entities(output)
856  .destroyed(output)
857  .component<AComponent, AnotherComponent>(output)
858  .tag<MyTag>(output);
859 ```
860 
861 It isn't necessary to invoke all these functions each and every time. What
862 functions to use in which case mostly depends on the goal and there is not a
863 golden rule to do that.
864 
865 The `entities` member function asks the registry to serialize all the entities
866 that are still in use along with their versions. On the other side, the
867 `destroyed` member function tells to the registry to serialize the entities that
868 have been destroyed and are no longer in use.<br/>
869 These two functions can be used to save and restore the whole set of entities
870 with the versions they had during serialization.
871 
872 The `component` member function is a function template the aim of which is to
873 store aside components. The presence of a template parameter list is a
874 consequence of a couple of design choices from the past and in the present:
875 
876 * First of all, there is no reason to force a user to serialize all the
877  components at once and most of the times it isn't desiderable. As an example,
878  in case the stuff for the HUD in a game is put into the registry for some
879  reasons, its components can be freely discarded during a serialization step
880  because probably the software already knows how to reconstruct the HUD
881  correctly from scratch.
882 
883 * Furthermore, the registry makes heavy use of _type-erasure_ techniques
884  internally and doesn't know at any time what types of components it contains.
885  Therefore being explicit at the call point is mandatory.
886 
887 There exists also another version of the `component` member function that
888 accepts a range of entities to serialize. This version is a bit slower than the
889 other one, mainly because it iterates the range of entities more than once for
890 internal purposes. However, it can be used to filter out those entities that
891 shouldn't be serialized for some reasons.<br/>
892 As an example:
893 
894 ```cpp
895 const auto view = registry.view<Serialize>();
896 OutputArchive output;
897 
898 registry.snapshot()
899  .component<AComponent, AnotherComponent>(output, view.cbegin(), view.cend());
900 ```
901 
902 The `tag` member function is similar to the previous one, apart from the fact
903 that it works with tags and not with components.<br/>
904 Note also that both `component` and `tag` store items along with entities. It
905 means that they work properly without a call to the `entities` member function.
906 
907 Once a snapshot is created, there exist mainly two _ways_ to load it: as a whole
908 and in a kind of _continuous mode_.<br/>
909 The following sections describe both loaders and archives in details.
910 
911 #### Snapshot loader
912 
913 A snapshot loader requires that the destination registry be empty and loads all
914 the data at once while keeping intact the identifiers that the entities
915 originally had.<br/>
916 To do that, the registry offers a member function named `restore` that returns a
917 temporary object properly initialized to _restore_ a snapshot.
918 
919 Example of use:
920 
921 ```cpp
922 InputArchive input;
923 
924 registry.restore()
925  .entities(input)
926  .destroyed(input)
927  .component<AComponent, AnotherComponent>(input)
928  .tag<MyTag>(input)
929  .orphans();
930 ```
931 
932 It isn't necessary to invoke all these functions each and every time. What
933 functions to use in which case mostly depends on the goal and there is not a
934 golden rule to do that. For obvious reasons, what is important is that the data
935 are restored in exactly the same order in which they were serialized.
936 
937 The `entities` and `destroyed` member functions restore the sets of entities and
938 the versions that the entities originally had at the source.
939 
940 The `component` member function restores all and only the components specified
941 and assigns them to the right entities. Note that the template parameter list
942 must be exactly the same used during the serialization. The same applies to the
943 `tag` member function.
944 
945 The `orphans` member function literally destroys those entities that have
946 neither components nor tags. It's usually useless if the snapshot is a full dump
947 of the source. However, in case all the entities are serialized but only few
948 components and tags are saved, it could happen that some of the entities have
949 neither components nor tags once restored. The best users can do to deal with
950 them is to destroy those entities and thus update their versions.
951 
952 #### Continuous loader
953 
954 A continuous loader is designed to load data from a source registry to a
955 (possibly) non-empty destination. The loader can accommodate in a registry more
956 than one snapshot in a sort of _continuous loading_ that updates the
957 destination one step at a time.<br/>
958 Identifiers that entities originally had are not transferred to the target.
959 Instead, the loader maps remote identifiers to local ones while restoring a
960 snapshot. Because of that, this kind of loader offers a way to update
961 automatically identifiers that are part of components or tags (as an example, as
962 data members or gathered in a container).<br/>
963 Another difference with the snapshot loader is that the continuous loader does
964 not need to work with the private data structures of a registry. Furthermore, it
965 has an internal state that must persist over time. Therefore, there is no reason
966 to create it by means of a registry, or to limit its lifetime to that of a
967 temporary object.
968 
969 Example of use:
970 
971 ```cpp
972 entt::ContinuousLoader<entity_type> loader{registry};
973 InputArchive input;
974 
975 loader.entities(input)
976  .destroyed(input)
977  .component<AComponent, AnotherComponent, DirtyComponent>(input, &DirtyComponent::parent, &DirtyComponent::child)
978  .tag<MyTag, DirtyTag>(input, &DirtyTag::container)
979  .orphans()
980  .shrink();
981 ```
982 
983 It isn't necessary to invoke all these functions each and every time. What
984 functions to use in which case mostly depends on the goal and there is not a
985 golden rule to do that. For obvious reasons, what is important is that the data
986 are restored in exactly the same order in which they were serialized.
987 
988 The `entities` and `destroyed` member functions restore groups of entities and
989 map each entity to a local counterpart when required. In other terms, for each
990 remote entity identifier not yet registered by the loader, the latter creates a
991 local identifier so that it can keep the local entity in sync with the remote
992 one.
993 
994 The `component` and `tag` member functions restore all and only the components
995 and the tags specified and assign them to the right entities.<br/>
996 In case the component or the tag contains entities itself (either as data
997 members of type `entity_type` or as containers of entities), the loader can
998 update them automatically. To do that, it's enough to specify the data members
999 to update as shown in the example.
1000 
1001 The `orphans` member function literally destroys those entities that have
1002 neither components nor tags after a restore. It has exactly the same purpose
1003 described in the previous section and works the same way.
1004 
1005 Finally, `shrink` helps to purge local entities that no longer have a remote
1006 conterpart. Users should invoke this member function after restoring each
1007 snapshot, unless they know exactly what they are doing.
1008 
1009 #### Archives
1010 
1011 Archives must publicly expose a predefined set of member functions. The API is
1012 straightforward and consists only of a group of function call operators that
1013 are invoked by the snapshot class and the loaders.
1014 
1015 In particular:
1016 
1017 * An output archive, the one used when creating a snapshot, must expose a
1018  function call operator with the following signature to store entities:
1019 
1020  ```cpp
1021  void operator()(Entity);
1022  ```
1023 
1024  Where `Entity` is the type of the entities used by the registry. Note that all
1025  the member functions of the snapshot class make also an initial call to this
1026  endpoint to save the _size_ of the set they are going to store.<br/>
1027  In addition, an archive must accept a pair of entity and either component or
1028  tag for each type to be serialized. Therefore, given a type `T`, the archive
1029  must contain a function call operator with the following signature:
1030 
1031  ```cpp
1032  void operator()(Entity, const T &);
1033  ```
1034 
1035  The output archive can freely decide how to serialize the data. The register
1036  is not affected at all by the decision.
1037 
1038 * An input archive, the one used when restoring a snapshot, must expose a
1039  function call operator with the following signature to load entities:
1040 
1041  ```cpp
1042  void operator()(Entity &);
1043  ```
1044 
1045  Where `Entity` is the type of the entities used by the registry. Each time the
1046  function is invoked, the archive must read the next element from the
1047  underlying storage and copy it in the given variable. Note that all the member
1048  functions of a loader class make also an initial call to this endpoint to read
1049  the _size_ of the set they are going to load.<br/>
1050  In addition, the archive must accept a pair of entity and either component or
1051  tag for each type to be restored. Therefore, given a type `T`, the archive
1052  must contain a function call operator with the following signature:
1053 
1054  ```cpp
1055  void operator()(Entity &, T &);
1056  ```
1057 
1058  Every time such an operator is invoked, the archive must read the next
1059  elements from the underlying storage and copy them in the given variables.
1060 
1061 #### One example to rule them all
1062 
1063 `EnTT` comes with some examples (actually some tests) that show how to integrate
1064 a well known library for serialization as an archive. It uses
1065 [`Cereal C++`](https://uscilab.github.io/cereal/) under the hood, mainly
1066 because I wanted to learn how it works at the time I was writing the code.
1067 
1068 The code is not production-ready and it isn't neither the only nor (probably)
1069 the best way to do it. However, feel free to use it at your own risk.
1070 
1071 The basic idea is to store everything in a group of queues in memory, then bring
1072 everything back to the registry with different loaders.
1073 
1074 ### Prototype
1075 
1076 A prototype defines a type of an application in terms of its parts. They can be
1077 used to assign components to entities of a registry at once.<br/>
1078 Roughly speaking, in most cases prototypes can be considered just as templates
1079 to use to initialize entities according to _concepts_. In fact, users can create
1080 how many prototypes they want, each one initialized differently from the others.
1081 
1082 The following is an example of use of a prototype:
1083 
1084 ```cpp
1085 entt::DefaultRegistry registry;
1086 entt::DefaultPrototype prototype{registry};
1087 
1088 prototype.set<Position>(100.f, 100.f);
1089 prototype.set<Velocity>(0.f, 0.f);
1090 
1091 // ...
1092 
1093 const auto entity = prototype();
1094 ```
1095 
1096 To assign and remove components from a prototype, it offers two dedicated member
1097 functions named `set` and `unset`. The `has` member function can be used to know
1098 if a given prototype contains one or more components and the `get` member
1099 function can be used to retrieve the components.
1100 
1101 Creating an entity from a prototype is straightforward:
1102 
1103 * To create a new entity from scratch and assign it a prototype, this is the way
1104  to go:
1105  ```cpp
1106  const auto entity = prototype();
1107  ```
1108  It is equivalent to the following invokation:
1109  ```cpp
1110  const auto entity = prototype.create();
1111  ```
1112 
1113 * In case we want to initialize an already existing entity, we can provide the
1114  `operator()` directly with the entity identifier:
1115  ```cpp
1116  prototype(entity);
1117  ```
1118  It is equivalent to the following invokation:
1119  ```cpp
1120  prototype.assign(entity);
1121  ```
1122  Note that existing components aren't overwritten in this case. Only those
1123  components that the entity doesn't own yet are copied over. All the other
1124  components remain unchanged.
1125 
1126 * Finally, to assign or replace all the components for an entity, thus
1127  overwriting existing ones:
1128  ```cpp
1129  prototype.accommodate(entity);
1130  ```
1131 
1132 In the examples above, the prototype uses its underlying registry to create
1133 entities and components both for its purposes and when it's cloned. To use a
1134 different repository to clone a prototype, all the member functions accept also
1135 a reference to a valid registry as a first argument.
1136 
1137 Prototypes are a very useful tool that can save a lot of typing sometimes.
1138 Furthermore, the codebase may be easier to maintain, since updating a prototype
1139 is much less error prone than jumping around in the codebase to update all the
1140 snippets copied and pasted around to initialize entities and components.
1141 
1142 ### Helpers
1143 
1144 The so called _helpers_ are small classes and functions mainly designed to offer
1145 built-in support for the most basic functionalities.<br/>
1146 The list of helpers will grow longer as time passes and new ideas come out.
1147 
1148 #### Dependency function
1149 
1150 A _dependency function_ is a predefined listener, actually a function template
1151 to use to automatically assign components to an entity when a type has a
1152 dependency on some other types.<br/>
1153 The following adds components `AType` and `AnotherType` whenever `MyType` is
1154 assigned to an entity:
1155 
1156 ```cpp
1157 entt::dependency<AType, AnotherType>(registry.construction<MyType>());
1158 ```
1159 
1160 A component is assigned to an entity and thus default initialized only in case
1161 the entity itself hasn't it yet. It means that already existent components won't
1162 be overriden.<br/>
1163 A dependency can easily be broken by means of the same function template:
1164 
1165 ```cpp
1166 entt::dependency<AType, AnotherType>(entt::break_t{}, registry.construction<MyType>());
1167 ```
1168 
1169 #### Labels
1170 
1171 There's nothing magical about the way labels can be assigned to entities while
1172 avoiding a performance hit at runtime. Nonetheless, the syntax can be annoying
1173 and that's why a more user-friendly shortcut is provided to do it.<br/>
1174 This shortcut is the alias template `entt::label`.
1175 
1176 If used in combination with hashed strings, it helps to use labels where types
1177 would be required otherwise. As an example:
1178 
1179 ```cpp
1180 registry.assign<entt::label<"enemy"_hs>>(entity);
1181 ```
1182 
1183 ### Null entity
1184 
1185 In `EnTT`, there exists a sort of _null entity_ made available to users that is
1186 accessible via the `entt::null` variable.<br/>
1187 The library guarantees that the following expression always returns false:
1188 
1189 ```cpp
1190 registry.valid(entt::null);
1191 ```
1192 
1193 In other terms, a registry will reject the null entity in all cases because it
1194 isn't considered valid. It means that the null entity cannot own components or
1195 tags for obvious reasons.<br/>
1196 The type of the null entity is internal and should not be used for any purpose
1197 other than defining the null entity itself. However, there exist implicit
1198 conversions from the null entity to identifiers of any allowed type:
1199 
1200 ```cpp
1201 typename entt::DefaultRegistry::entity_type null = entt::null;
1202 ```
1203 
1204 Similarly, the null entity can be compared to any other identifier:
1205 
1206 ```cpp
1207 const auto entity = registry.create();
1208 const bool null = (entity == entt::null);
1209 ```
1210 
1211 ## View: to persist or not to persist?
1212 
1213 First of all, it is worth answering an obvious question: why views?<br/>
1214 Roughly speaking, they are a good tool to enforce single responsibility. A
1215 system that has access to a registry can create and destroy entities, as well as
1216 assign and remove components. On the other side, a system that has access to a
1217 view can only iterate entities and their components, then read or update the
1218 data members of the latter.<br/>
1219 It is a subtle difference that can help designing a better software sometimes.
1220 
1221 There are mainly four kinds of views: standard (also known as `View`),
1222 persistent (also known as `PersistentView`), raw (also known as `RawView`) and
1223 runtime (also known as `RuntimeView`).<br/>
1224 All of them have pros and cons to take in consideration. In particular:
1225 
1226 * Standard views:
1227 
1228  Pros:
1229 
1230  * They work out-of-the-box and don't require any dedicated data structure.
1231  * Creating and destroying them isn't expensive at all because they don't have
1232  any type of initialization.
1233  * They are the best tool for iterating entities for a single component.
1234  * They are the best tool for iterating entities for multiple components when
1235  one of the components is assigned to a significantly low number of entities.
1236  * They don't affect any other operations of the registry.
1237 
1238  Cons:
1239 
1240  * Their performance tend to degenerate when the number of components to
1241  iterate grows up and the most of the entities have all of them.
1242 
1243 * Persistent views:
1244 
1245  Pros:
1246 
1247  * Once prepared, creating and destroying them isn't expensive at all because
1248  they don't have any type of initialization.
1249  * They are the best tool for iterating entities for multiple components when
1250  most entities have them all.
1251 
1252  Cons:
1253 
1254  * They have dedicated data structures and thus affect the memory usage to a
1255  minimal extent.
1256  * If not previously prepared, the first time they are used they go through an
1257  initialization step that could take a while.
1258  * They affect to a minimum the creation and destruction of entities and
1259  components. In other terms: the more persistent views there will be, the
1260  less performing will be creating and destroying entities and components.
1261 
1262 * Raw views:
1263 
1264  Pros:
1265 
1266  * They work out-of-the-box and don't require any dedicated data structure.
1267  * Creating and destroying them isn't expensive at all because they don't have
1268  any type of initialization.
1269  * They are the best tool for iterating components when it is not necessary to
1270  know which entities they belong to.
1271  * They don't affect any other operations of the registry.
1272 
1273  Cons:
1274 
1275  * They can be used to iterate only one type of component at a time.
1276  * They don't return the entity to which a component belongs to the caller.
1277 
1278 * Runtime views:
1279 
1280  Pros:
1281 
1282  * Their lists of components are defined at runtime and not at compile-time.
1283  * Creating and destroying them isn't expensive at all because they don't have
1284  any type of initialization.
1285  * They are the best tool for things like plugin systems and mods in general.
1286  * They don't affect any other operations of the registry.
1287 
1288  Cons:
1289 
1290  * Their performances are definitely lower than those of all the other views,
1291  although they are still usable and sufficient for most of the purposes.
1292 
1293 To sum up and as a rule of thumb:
1294 
1295 * Use a raw view to iterate components only (no entities) for a given type.
1296 * Use a standard view to iterate entities and components for a single type.
1297 * Use a standard view to iterate entities and components for multiple types when
1298  the number of types is low. Standard views are really optimized and persistent
1299  views won't add much in this case.
1300 * Use a standard view to iterate entities and components for multiple types when
1301  a significantly low number of entities have one of the components.
1302 * Use a standard view in all those cases where a persistent view would give a
1303  boost to performance but the iteration isn't performed frequently.
1304 * Prepare and use a persistent view when you want to iterate only entities for
1305  multiple components.
1306 * Prepare and use a persistent view when you want to iterate entities for
1307  multiple components and each component is assigned to a great number of
1308  entities but the intersection between the sets of entities is small.
1309 * Prepare and use a persistent view in all the cases where a standard view
1310  wouldn't fit well otherwise.
1311 * Finally, in case you don't know at compile-time what are the components to
1312  use, choose a runtime view and set them during execution.
1313 
1314 To easily iterate entities and components, all the views offer the common
1315 `begin` and `end` member functions that allow users to use a view in a typical
1316 range-for loop. Almost all the views offer also a *more functional* `each`
1317 member function that accepts a callback for convenience.<br/>
1318 Continue reading for more details or refer to the inline documentation.
1319 
1320 ### Standard View
1321 
1322 A standard view behaves differently if it's constructed for a single component
1323 or if it has been requested to iterate multiple components. Even the API is
1324 different in the two cases.<br/>
1325 All that they share is the way they are created by means of a registry:
1326 
1327 ```cpp
1328 // single component standard view
1329 auto single = registry.view<Position>();
1330 
1331 // multi component standard view
1332 auto multi = registry.view<Position, Velocity>();
1333 ```
1334 
1335 For all that remains, it's worth discussing them separately.<br/>
1336 
1337 #### Single component standard view
1338 
1339 Single component standard views are specialized in order to give a boost in
1340 terms of performance in all the situation. This kind of views can access the
1341 underlying data structures directly and avoid superfluous checks.<br/>
1342 They offer a bunch of functionalities to get the number of entities they are
1343 going to return and a raw access to the entity list as well as to the component
1344 list. It's also possible to ask a view if it contains a given entity.<br/>
1345 Refer to the inline documentation for all the details.
1346 
1347 There is no need to store views around for they are extremely cheap to
1348 construct, even though they can be copied without problems and reused freely. In
1349 fact, they return newly created and correctly initialized iterators whenever
1350 `begin` or `end` are invoked.<br/>
1351 To iterate a single component standard view, either use it in a range-for loop:
1352 
1353 ```cpp
1354 auto view = registry.view<Renderable>();
1355 
1356 for(auto entity: view) {
1357  Renderable &renderable = view.get(entity);
1358 
1359  // ...
1360 }
1361 ```
1362 
1363 Or rely on the `each` member function to iterate entities and get all their
1364 components at once:
1365 
1366 ```cpp
1367 registry.view<Renderable>().each([](auto entity, auto &renderable) {
1368  // ...
1369 });
1370 ```
1371 
1372 The `each` member function is highly optimized. Unless users want to iterate
1373 only entities, using `each` should be the preferred approach.
1374 
1375 **Note**: prefer the `get` member function of a view instead of the `get` member
1376 function template of a registry during iterations, if possible. However, keep in
1377 mind that it works only with the components of the view itself.
1378 
1379 #### Multi component standard view
1380 
1381 Multi component standard views iterate entities that have at least all the given
1382 components in their bags. During construction, these views look at the number of
1383 entities available for each component and pick up a reference to the smallest
1384 set of candidates in order to speed up iterations.<br/>
1385 They offer fewer functionalities than their companion views for single
1386 component. In particular, a multi component standard view exposes utility
1387 functions to get the estimated number of entities it is going to return and to
1388 know whether it's empty or not. It's also possible to ask a view if it contains
1389 a given entity.<br/>
1390 Refer to the inline documentation for all the details.
1391 
1392 There is no need to store views around for they are extremely cheap to
1393 construct, even though they can be copied without problems and reused freely. In
1394 fact, they return newly created and correctly initialized iterators whenever
1395 `begin` or `end` are invoked.<br/>
1396 To iterate a multi component standard view, either use it in a range-for loop:
1397 
1398 ```cpp
1399 auto view = registry.view<Position, Velocity>();
1400 
1401 for(auto entity: view) {
1402  // a component at a time ...
1403  Position &position = view.get<Position>(entity);
1404  Velocity &velocity = view.get<Velocity>(entity);
1405 
1406  // ... or multiple components at once
1407  std::tuple<Position &, Velocity &> tup = view.get<Position, Velocity>(entity);
1408 
1409  // ...
1410 }
1411 ```
1412 
1413 Or rely on the `each` member function to iterate entities and get all their
1414 components at once:
1415 
1416 ```cpp
1417 registry.view<Position, Velocity>().each([](auto entity, auto &position, auto &velocity) {
1418  // ...
1419 });
1420 ```
1421 
1422 The `each` member function is highly optimized. Unless users want to iterate
1423 only entities or get only some of the components, using `each` should be the
1424 preferred approach.
1425 
1426 **Note**: prefer the `get` member function of a view instead of the `get` member
1427 function template of a registry during iterations, if possible. However, keep in
1428 mind that it works only with the components of the view itself.
1429 
1430 ### Persistent View
1431 
1432 A persistent view returns all the entities and only the entities that have at
1433 least the given components. Moreover, it's guaranteed that the entity list is
1434 tightly packed in memory for fast iterations.<br/>
1435 In general, persistent views don't stay true to the order of any set of
1436 components unless users explicitly sort them.
1437 
1438 Persistent views can be used only to iterate multiple components. To create this
1439 kind of views, the tag `persistent_t` must also be used in order to disambiguate
1440 overloads of the `view` member function:
1441 
1442 ```cpp
1443 auto view = registry.view<Position, Velocity>(entt::persistent_t{});
1444 ```
1445 
1446 There is no need to store views around for they are extremely cheap to
1447 construct, even though they can be copied without problems and reused freely. In
1448 fact, they return newly created and correctly initialized iterators whenever
1449 `begin` or `end` are invoked.<br/>
1450 That being said, persistent views perform an initialization step the very first
1451 time they are constructed and this could be quite costly. To avoid it, consider
1452 asking to the registry to _prepare_ them when no entities have been created yet:
1453 
1454 ```cpp
1455 registry.prepare<Position, Velocity>();
1456 ```
1457 
1458 If the registry is empty, preparation is extremely fast. Moreover the `prepare`
1459 member function template is idempotent. Feel free to invoke it even more than
1460 once: if the view has been already prepared before, the function returns
1461 immediately and does nothing.
1462 
1463 A persistent view offers a bunch of functionalities to get the number of
1464 entities it's going to return, a raw access to the entity list and the
1465 possibility to sort the underlying data structures according to the order of one
1466 of the components for which it has been constructed. It's also possible to ask a
1467 view if it contains a given entity.<br/>
1468 Refer to the inline documentation for all the details.
1469 
1470 To iterate a persistent view, either use it in a range-for loop:
1471 
1472 ```cpp
1473 auto view = registry.view<Position, Velocity>(entt::persistent_t{});
1474 
1475 for(auto entity: view) {
1476  // a component at a time ...
1477  Position &position = view.get<Position>(entity);
1478  Velocity &velocity = view.get<Velocity>(entity);
1479 
1480  // ... or multiple components at once
1481  std::tuple<Position &, Velocity &> tup = view.get<Position, Velocity>(entity);
1482 
1483  // ...
1484 }
1485 ```
1486 
1487 Or rely on the `each` member function to iterate entities and get all their
1488 components at once:
1489 
1490 ```cpp
1491 registry.view<Position, Velocity>(entt::persistent_t{}).each([](auto entity, auto &position, auto &velocity) {
1492  // ...
1493 });
1494 ```
1495 
1496 Performance are more or less the same. The best approach depends mainly on
1497 whether all the components have to be accessed or not.
1498 
1499 **Note**: prefer the `get` member function of a view instead of the `get` member
1500 function template of a registry during iterations, if possible. However, keep in
1501 mind that it works only with the components of the view itself.
1502 
1503 ### Raw View
1504 
1505 Raw views return all the components of a given type. This kind of views can
1506 access components directly and avoid extra indirections like when components are
1507 accessed via an entity identifier.<br/>
1508 They offer a bunch of functionalities to get the number of instances they are
1509 going to return and a raw access to the entity list as well as to the component
1510 list.<br/>
1511 Refer to the inline documentation for all the details.
1512 
1513 Raw views can be used only to iterate components for a single type. To create
1514 this kind of views, the tag `raw_t` must also be used in order to disambiguate
1515 overloads of the `view` member function:
1516 
1517 ```cpp
1518 auto view = registry.view<Renderable>(entt::raw_t{});
1519 ```
1520 
1521 There is no need to store views around for they are extremely cheap to
1522 construct, even though they can be copied without problems and reused freely. In
1523 fact, they return newly created and correctly initialized iterators whenever
1524 `begin` or `end` are invoked.<br/>
1525 To iterate a raw view, use it in a range-for loop:
1526 
1527 ```cpp
1528 auto view = registry.view<Renderable>(entt::raw_t{});
1529 
1530 for(auto &&component: raw) {
1531  // ...
1532 }
1533 ```
1534 
1535 Or rely on the `each` member function:
1536 
1537 ```cpp
1538 registry.view<Renderable>(entt::raw_t{}).each([](auto &renderable) {
1539  // ...
1540 });
1541 ```
1542 
1543 Performance are exactly the same in both cases.
1544 
1545 **Note**: raw views don't have a `get` member function for obvious reasons.
1546 
1547 ### Runtime View
1548 
1549 Runtime views iterate entities that have at least all the given components in
1550 their bags. During construction, these views look at the number of entities
1551 available for each component and pick up a reference to the smallest
1552 set of candidates in order to speed up iterations.<br/>
1553 They offer more or less the same functionalities of a multi component standard
1554 view. However, they don't expose a `get` member function and users should refer
1555 to the registry that generated the view to access components. In particular, a
1556 runtime view exposes utility functions to get the estimated number of entities
1557 it is going to return and to know whether it's empty or not. It's also possible
1558 to ask a view if it contains a given entity.<br/>
1559 Refer to the inline documentation for all the details.
1560 
1561 Runtime view are extremely cheap to construct and should not be stored around in
1562 any case. They should be used immediately after creation and then they should be
1563 thrown away. The reasons for this go far beyond the scope of this document.<br/>
1564 To iterate a runtime view, either use it in a range-for loop:
1565 
1566 ```cpp
1567 using component_type = typename decltype(registry)::component_type;
1568 component_type types[] = { registry.type<Position>(), registry.type<Velocity>() };
1569 
1570 auto view = registry.view(std::cbegin(types), std::cend(types));
1571 
1572 for(auto entity: view) {
1573  // a component at a time ...
1574  Position &position = registry.get<Position>(entity);
1575  Velocity &velocity = registry.get<Velocity>(entity);
1576 
1577  // ... or multiple components at once
1578  std::tuple<Position &, Velocity &> tup = view.get<Position, Velocity>(entity);
1579 
1580  // ...
1581 }
1582 ```
1583 
1584 Or rely on the `each` member function to iterate entities:
1585 
1586 ```cpp
1587 using component_type = typename decltype(registry)::component_type;
1588 component_type types[] = { registry.type<Position>(), registry.type<Velocity>() };
1589 
1590 auto view = registry.view(std::cbegin(types), std::cend(types)).each([](auto entity) {
1591  // ...
1592 });
1593 ```
1594 
1595 Performance are exactly the same in both cases.
1596 
1597 **Note**: runtime views are meant for all those cases where users don't know at
1598 compile-time what components to use to iterate entities. This is particularly
1599 well suited to plugin systems and mods in general. Where possible, don't use
1600 runtime views, as their performance are slightly inferior to those of the other
1601 views.
1602 
1603 
1604 ### Give me everything
1605 
1606 Views are narrow windows on the entire list of entities. They work by filtering
1607 entities according to their components.<br/>
1608 In some cases there may be the need to iterate all the entities still in use
1609 regardless of their components. The registry offers a specific member function
1610 to do that:
1611 
1612 ```cpp
1613 registry.each([](auto entity) {
1614  // ...
1615 });
1616 ```
1617 
1618 It returns to the caller all the entities that are still in use by means of the
1619 given function.<br/>
1620 As a rule of thumb, consider using a view if the goal is to iterate entities
1621 that have a determinate set of components. A view is usually much faster than
1622 combining this function with a bunch of custom tests.<br/>
1623 In all the other cases, this is the way to go.
1624 
1625 There exists also another member function to use to retrieve orphans. An orphan
1626 is an entity that is still in use and has neither assigned components nor
1627 tags.<br/>
1628 The signature of the function is the same of `each`:
1629 
1630 ```cpp
1631 registry.orphans([](auto entity) {
1632  // ...
1633 });
1634 ```
1635 
1636 To test the _orphanity_ of a single entity, use the member function `orphan`
1637 instead. It accepts a valid entity identifer as an argument and returns true in
1638 case the entity is an orphan, false otherwise.
1639 
1640 In general, all these functions can result in poor performance.<br/>
1641 `each` is fairly slow because of some checks it performs on each and every
1642 entity. For similar reasons, `orphans` can be even slower. Both functions should
1643 not be used frequently to avoid the risk of a performance hit.
1644 
1645 ## Iterations: what is allowed and what is not
1646 
1647 Most of the _ECS_ available out there have some annoying limitations (at least
1648 from my point of view): entities and components cannot be created nor destroyed
1649 during iterations.<br/>
1650 `EnTT` partially solves the problem with a few limitations:
1651 
1652 * Creating entities and components is allowed during iterations.
1653 * Deleting an entity or removing its components is allowed during iterations if
1654  it's the one currently returned by the view. For all the other entities,
1655  destroying them or removing their components isn't allowed and it can result
1656  in undefined behavior.
1657 
1658 Iterators are invalidated and the behavior is undefined if an entity is modified
1659 or destroyed and it's not the one currently returned by the view nor a newly
1660 created one.<br/>
1661 To work around it, possible approaches are:
1662 
1663 * Store aside the entities and the components to be removed and perform the
1664  operations at the end of the iteration.
1665 * Mark entities and components with a proper tag component that indicates they
1666  must be purged, then perform a second iteration to clean them up one by one.
1667 
1668 A notable side effect of this feature is that the number of required allocations
1669 is further reduced in most of the cases.
1670 
1671 ## Multithreading
1672 
1673 In general, the entire registry isn't thread safe as it is. Thread safety isn't
1674 something that users should want out of the box for several reasons. Just to
1675 mention one of them: performance.<br/>
1676 Views and consequently the approach adopted by `EnTT` are the great exception to
1677 the rule. It's true that views and thus their iterators aren't thread safe by
1678 themselves. Because of this users shouldn't try to iterate a set of components
1679 and modify the same set concurrently. However:
1680 
1681 * As long as a thread iterates the entities that have the component `X` or
1682  assign and removes that component from a set of entities, another thread can
1683  safely do the same with components `Y` and `Z` and everything will work like a
1684  charm. As a trivial example, users can freely execute the rendering system and
1685  iterate the renderable entities while updating a physic component concurrently
1686  on a separate thread.
1687 
1688 * Similarly, a single set of components can be iterated by multiple threads as
1689  long as the components are neither assigned nor removed in the meantime. In
1690  other words, a hypothetical movement system can start multiple threads, each
1691  of which will access the components that carry information about velocity and
1692  position for its entities.
1693 
1694 This kind of entity-component systems can be used in single threaded
1695 applications as well as along with async stuff or multiple threads. Moreover,
1696 typical thread based models for _ECS_ don't require a fully thread safe registry
1697 to work. Actually, users can reach the goal with the registry as it is while
1698 working with most of the common models.
1699 
1700 Because of the few reasons mentioned above and many others not mentioned, users
1701 are completely responsible for synchronization whether required. On the other
1702 hand, they could get away with it without having to resort to particular
1703 expedients.
1704 
1705 # Crash Course: core functionalities
1706 
1707 `EnTT` comes with a bunch of core functionalities mostly used by the other parts
1708 of the library itself.<br/>
1709 Hardly users will include these features in their code, but it's worth
1710 describing what `EnTT` offers so as not to reinvent the wheel in case of need.
1711 
1712 ## Compile-time identifiers
1713 
1714 Sometimes it's useful to be able to give unique identifiers to types at
1715 compile-time.<br/>
1716 There are plenty of different solutions out there and I could have used one of
1717 them. However, I decided to spend my time to define a compact and versatile tool
1718 that fully embraces what the modern C++ has to offer.
1719 
1720 The _result of my efforts_ is the `Identifier` class template:
1721 
1722 ```cpp
1723 #include <ident.hpp>
1724 
1725 // defines the identifiers for the given types
1726 using ID = entt::Identifier<AType, AnotherType>;
1727 
1728 // ...
1729 
1730 switch(aTypeIdentifier) {
1731 case ID::get<AType>():
1732  // ...
1733  break;
1734 case ID::get<AnotherType>():
1735  // ...
1736  break;
1737 default:
1738  // ...
1739 }
1740 ```
1741 
1742 This is all what the class template has to offer: a static `get` member function
1743 that returns a numerical identifier for the given type. It can be used in any
1744 context where constant expressions are required.
1745 
1746 As long as the list remains unchanged, identifiers are also guaranteed to be the
1747 same for every run. In case they have been used in a production environment and
1748 a type has to be removed, one can just use a placeholder to left the other
1749 identifiers unchanged:
1750 
1751 ```cpp
1752 template<typename> struct IgnoreType {};
1753 
1754 using ID = entt::Identifier<
1755  ATypeStillValid,
1756  IgnoreType<ATypeNoLongerValid>,
1757  AnotherTypeStillValid
1758 >;
1759 ```
1760 
1761 A bit ugly to see, but it works at least.
1762 
1763 ## Runtime identifiers
1764 
1765 Sometimes it's useful to be able to give unique identifiers to types at
1766 runtime.<br/>
1767 There are plenty of different solutions out there and I could have used one of
1768 them. In fact, I adapted the most common one to my requirements and used it
1769 extensively within the entire library.
1770 
1771 It's the `Family` class. Here is an example of use directly from the
1772 entity-component system:
1773 
1774 ```cpp
1775 using component_family = entt::Family<struct InternalRegistryComponentFamily>;
1776 
1777 // ...
1778 
1779 template<typename Component>
1780 component_type component() const noexcept {
1781  return component_family::type<Component>();
1782 }
1783 ```
1784 
1785 This is all what a _family_ has to offer: a `type` member function that returns
1786 a numerical identifier for the given type.
1787 
1788 Please, note that identifiers aren't guaranteed to be the same for every run.
1789 Indeed it mostly depends on the flow of execution.
1790 
1791 ## Hashed strings
1792 
1793 A hashed string is a zero overhead resource identifier. Users can use
1794 human-readable identifiers in the codebase while using their numeric
1795 counterparts at runtime, thus without affecting performance.<br/>
1796 The class has an implicit `constexpr` constructor that chews a bunch of
1797 characters. Once created, all what one can do with it is getting back the
1798 original string or converting it into a number.<br/>
1799 The good part is that a hashed string can be used wherever a constant expression
1800 is required and no _string-to-number_ conversion will take place at runtime if
1801 used carefully.
1802 
1803 Example of use:
1804 
1805 ```cpp
1806 auto load(entt::HashedString::hash_type resource) {
1807  // uses the numeric representation of the resource to load and return it
1808 }
1809 
1810 auto resource = load(entt::HashedString{"gui/background"});
1811 ```
1812 
1813 There is also a _user defined literal_ dedicated to hashed strings to make them
1814 more user-friendly:
1815 
1816 ```cpp
1817 constexpr auto str = "text"_hs;
1818 ```
1819 
1820 ### Conflicts
1821 
1822 The hashed string class uses internally FNV-1a to compute the numeric
1823 counterpart of a string. Because of the _pigeonhole principle_, conflicts are
1824 possible. This is a fact.<br/>
1825 There is no silver bullet to solve the problem of conflicts when dealing with
1826 hashing functions. In this case, the best solution seemed to be to give up.
1827 That's all.<br/>
1828 After all, human-readable resource identifiers aren't something strictly defined
1829 and over which users have not the control. Choosing a slightly different
1830 identifier is probably the best solution to make the conflict disappear in this
1831 case.
1832 
1833 ## Monostate
1834 
1835 The monostate pattern is often presented as an alternative to a singleton based
1836 configuration system. This is exactly its purpose in `EnTT`. Moreover, this
1837 implementation is thread safe by design (hopefully).<br/>
1838 Keys are represented by hashed strings, values are basic types like `int`s or
1839 `bool`s. Values of different types can be associated to each key, even more than
1840 one at a time. Because of this, users must pay attention to use the same type
1841 both during an assignment and when they try to read back their data. Otherwise,
1842 they will probably incur in unexpected results.
1843 
1844 Example of use:
1845 
1846 ```cpp
1847 entt::Monostate<entt::HashedString{"mykey"}>{} = true;
1848 entt::Monostate<"mykey"_hs>{} = 42;
1849 
1850 // ...
1851 
1852 const bool b = entt::Monostate<"mykey"_hs>{};
1853 const int i = entt::Monostate<entt::HashedString{"mykey"}>{};
1854 ```
1855 
1856 # Crash Course: service locator
1857 
1858 Usually service locators are tightly bound to the services they expose and it's
1859 hard to define a general purpose solution. This template based implementation
1860 tries to fill the gap and to get rid of the burden of defining a different
1861 specific locator for each application.<br/>
1862 This class is tiny, partially unsafe and thus risky to use. Moreover it doesn't
1863 fit probably most of the scenarios in which a service locator is required. Look
1864 at it as a small tool that can sometimes be useful if the user knows how to
1865 handle it.
1866 
1867 The API is straightforward. The basic idea is that services are implemented by
1868 means of interfaces and rely on polymorphism.<br/>
1869 The locator is instantiated with the base type of the service if any and a
1870 concrete implementation is provided along with all the parameters required to
1871 initialize it. As an example:
1872 
1873 ```cpp
1874 // the service has no base type, a locator is used to treat it as a kind of singleton
1875 entt::ServiceLocator<MyService>::set(params...);
1876 
1877 // sets up an opaque service
1878 entt::ServiceLocator<AudioInterface>::set<AudioImplementation>(params...);
1879 
1880 // resets (destroys) the service
1881 entt::ServiceLocator<AudioInterface>::reset();
1882 ```
1883 
1884 The locator can also be queried to know if an active service is currently set
1885 and to retrieve it if necessary (either as a pointer or as a reference):
1886 
1887 ```cpp
1888 // no service currently set
1889 auto empty = entt::ServiceLocator<AudioInterface>::empty();
1890 
1891 // gets a (possibly empty) shared pointer to the service ...
1892 std::shared_ptr<AudioInterface> ptr = entt::ServiceLocator<AudioInterface>::get();
1893 
1894 // ... or a reference, but it's undefined behaviour if the service isn't set yet
1895 AudioInterface &ref = entt::ServiceLocator<AudioInterface>::ref();
1896 ```
1897 
1898 A common use is to wrap the different locators in a container class, creating
1899 aliases for the various services:
1900 
1901 ```cpp
1902 struct Locator {
1903  using Camera = entt::ServiceLocator<CameraInterface>;
1904  using Audio = entt::ServiceLocator<AudioInterface>;
1905  // ...
1906 };
1907 
1908 // ...
1909 
1910 void init() {
1911  Locator::Camera::set<CameraNull>();
1912  Locator::Audio::set<AudioImplementation>(params...);
1913  // ...
1914 }
1915 ```
1916 
1917 # Crash Course: cooperative scheduler
1918 
1919 Sometimes processes are a useful tool to work around the strict definition of a
1920 system and introduce logic in a different way, usually without resorting to the
1921 introduction of other components.
1922 
1923 `EnTT` offers a minimal support to this paradigm by introducing a few classes
1924 that users can use to define and execute cooperative processes.
1925 
1926 ## The process
1927 
1928 A typical process must inherit from the `Process` class template that stays true
1929 to the CRTP idiom. Moreover, derived classes must specify what's the intended
1930 type for elapsed times.
1931 
1932 A process should expose publicly the following member functions whether
1933 required (note that it isn't required to define a function unless the derived
1934 class wants to _override_ the default behavior):
1935 
1936 * `void update(Delta, void *);`
1937 
1938  It's invoked once per tick until a process is explicitly aborted or it
1939  terminates either with or without errors. Even though it's not mandatory to
1940  declare this member function, as a rule of thumb each process should at
1941  least define it to work properly. The `void *` parameter is an opaque pointer
1942  to user data (if any) forwarded directly to the process during an update.
1943 
1944 * `void init(void *);`
1945 
1946  It's invoked at the first tick, immediately before an update. The `void *`
1947  parameter is an opaque pointer to user data (if any) forwarded directly to the
1948  process during an update.
1949 
1950 * `void succeeded();`
1951 
1952  It's invoked in case of success, immediately after an update and during the
1953  same tick.
1954 
1955 * `void failed();`
1956 
1957  It's invoked in case of errors, immediately after an update and during the
1958  same tick.
1959 
1960 * `void aborted();`
1961 
1962  It's invoked only if a process is explicitly aborted. There is no guarantee
1963  that it executes in the same tick, this depends solely on whether the
1964  process is aborted immediately or not.
1965 
1966 Derived classes can also change the internal state of a process by invoking
1967 `succeed` and `fail`, as well as `pause` and `unpause` the process itself. All
1968 these are protected member functions made available to be able to manage the
1969 life cycle of a process from a derived class.
1970 
1971 Here is a minimal example for the sake of curiosity:
1972 
1973 ```cpp
1974 struct MyProcess: entt::Process<MyProcess, std::uint32_t> {
1975  using delta_type = std::uint32_t;
1976 
1977  void update(delta_type delta, void *) {
1978  remaining = delta > remaining ? delta_type{] : (remaining - delta);
1979 
1980  // ...
1981 
1982  if(!remaining) {
1983  succeed();
1984  }
1985  }
1986 
1987  void init(void *data) {
1988  remaining = *static_cast<delta_type *>(data);
1989  }
1990 
1991 private:
1992  delta_type remaining;
1993 };
1994 ```
1995 
1996 ### Adaptor
1997 
1998 Lambdas and functors can't be used directly with a scheduler for they are not
1999 properly defined processes with managed life cycles.<br/>
2000 This class helps in filling the gap and turning lambdas and functors into
2001 full featured processes usable by a scheduler.
2002 
2003 The function call operator has a signature similar to the one of the `update`
2004 function of a process but for the fact that it receives two extra arguments to
2005 call whenever a process is terminated with success or with an error:
2006 
2007 ```cpp
2008 void(Delta delta, void *data, auto succeed, auto fail);
2009 ```
2010 
2011 Parameters have the following meaning:
2012 
2013 * `delta` is the elapsed time.
2014 * `data` is an opaque pointer to user data if any, `nullptr` otherwise.
2015 * `succeed` is a function to call when a process terminates with success.
2016 * `fail` is a function to call when a process terminates with errors.
2017 
2018 Both `succeed` and `fail` accept no parameters at all.
2019 
2020 Note that usually users shouldn't worry about creating adaptors at all. A
2021 scheduler creates them internally each and every time a lambda or a functor is
2022 used as a process.
2023 
2024 ## The scheduler
2025 
2026 A cooperative scheduler runs different processes and helps managing their life
2027 cycles.
2028 
2029 Each process is invoked once per tick. If it terminates, it's removed
2030 automatically from the scheduler and it's never invoked again. Otherwise it's
2031 a good candidate to run once more the next tick.<br/>
2032 A process can also have a child. In this case, the process is replaced with
2033 its child when it terminates if it returns with success. In case of errors,
2034 both the process and its child are discarded. This way, it's easy to create
2035 chain of processes to run sequentially.
2036 
2037 Using a scheduler is straightforward. To create it, users must provide only the
2038 type for the elapsed times and no arguments at all:
2039 
2040 ```cpp
2041 Scheduler<std::uint32_t> scheduler;
2042 ```
2043 
2044 It has member functions to query its internal data structures, like `empty` or
2045 `size`, as well as a `clear` utility to reset it to a clean state:
2046 
2047 ```cpp
2048 // checks if there are processes still running
2049 const auto empty = scheduler.empty();
2050 
2051 // gets the number of processes still running
2052 Scheduler<std::uint32_t>::size_type size = scheduler.size();
2053 
2054 // resets the scheduler to its initial state and discards all the processes
2055 scheduler.clear();
2056 ```
2057 
2058 To attach a process to a scheduler there are mainly two ways:
2059 
2060 * If the process inherits from the `Process` class template, it's enough to
2061  indicate its type and submit all the parameters required to construct it to
2062  the `attach` member function:
2063 
2064  ```cpp
2065  scheduler.attach<MyProcess>("foobar");
2066  ```
2067 
2068 * Otherwise, in case of a lambda or a functor, it's enough to provide an
2069  instance of the class to the `attach` member function:
2070 
2071  ```cpp
2072  scheduler.attach([](auto...){ /* ... */ });
2073  ```
2074 
2075 In both cases, the return value is an opaque object that offers a `then` member
2076 function to use to create chains of processes to run sequentially.<br/>
2077 As a minimal example of use:
2078 
2079 ```cpp
2080 // schedules a task in the form of a lambda function
2081 scheduler.attach([](auto delta, void *, auto succeed, auto fail) {
2082  // ...
2083 })
2084 // appends a child in the form of another lambda function
2085 .then([](auto delta, void *, auto succeed, auto fail) {
2086  // ...
2087 })
2088 // appends a child in the form of a process class
2089 .then<MyProcess>();
2090 ```
2091 
2092 To update a scheduler and thus all its processes, the `update` member function
2093 is the way to go:
2094 
2095 ```cpp
2096 // updates all the processes, no user data are provided
2097 scheduler.update(delta);
2098 
2099 // updates all the processes and provides them with custom data
2100 scheduler.update(delta, &data);
2101 ```
2102 
2103 In addition to these functions, the scheduler offers an `abort` member function
2104 that can be used to discard all the running processes at once:
2105 
2106 ```cpp
2107 // aborts all the processes abruptly ...
2108 scheduler.abort(true);
2109 
2110 // ... or gracefully during the next tick
2111 scheduler.abort();
2112 ```
2113 
2114 # Crash Course: resource management
2115 
2116 Resource management is usually one of the most critical part of a software like
2117 a game. Solutions are often tuned to the particular application. There exist
2118 several approaches and all of them are perfectly fine as long as they fit the
2119 requirements of the piece of software in which they are used.<br/>
2120 Examples are loading everything on start, loading on request, predictive
2121 loading, and so on.
2122 
2123 `EnTT` doesn't pretend to offer a _one-fits-all_ solution for the different
2124 cases. Instead, it offers a minimal and perhaps trivial cache that can be useful
2125 most of the time during prototyping and sometimes even in a production
2126 environment.<br/>
2127 For those interested in the subject, the plan is to improve it considerably over
2128 time in terms of performance, memory usage and functionalities. Hoping to make
2129 it, of course, one step at a time.
2130 
2131 ## The resource, the loader and the cache
2132 
2133 There are three main actors in the model: the resource, the loader and the
2134 cache.
2135 
2136 The _resource_ is whatever the user wants it to be. An image, a video, an audio,
2137 whatever. There are no limits.<br/>
2138 As a minimal example:
2139 
2140 ```cpp
2141 struct MyResource { const int value; };
2142 ```
2143 
2144 A _loader_ is a class the aim of which is to load a specific resource. It has to
2145 inherit directly from the dedicated base class as in the following example:
2146 
2147 ```cpp
2148 struct MyLoader final: entt::ResourceLoader<MyLoader, MyResource> {
2149  // ...
2150 };
2151 ```
2152 
2153 Where `MyResource` is the type of resources it creates.<br/>
2154 A resource loader must also expose a public const member function named `load`
2155 that accepts a variable number of arguments and returns a shared pointer to a
2156 resource.<br/>
2157 As an example:
2158 
2159 ```cpp
2160 struct MyLoader: entt::ResourceLoader<MyLoader, MyResource> {
2161  std::shared_ptr<MyResource> load(int value) const {
2162  // ...
2163  return std::shared_ptr<MyResource>(new MyResource{ value });
2164  }
2165 };
2166 ```
2167 
2168 In general, resource loaders should not have a state or retain data of any type.
2169 They should let the cache manage their resources instead.<br/>
2170 As a side note, base class and CRTP idiom aren't strictly required with the
2171 current implementation. One could argue that a cache can easily work with
2172 loaders of any type. However, future changes won't be breaking ones by forcing
2173 the use of a base class today and that's why the model is already in its place.
2174 
2175 Finally, a cache is a specialization of a class template tailored to a specific
2176 resource:
2177 
2178 ```cpp
2179 using MyResourceCache = entt::ResourceCache<MyResource>;
2180 
2181 // ...
2182 
2183 MyResourceCache cache{};
2184 ```
2185 
2186 The idea is to create different caches for different types of resources and to
2187 manage each one independently and in the most appropriate way.<br/>
2188 As a (very) trivial example, audio tracks can survive in most of the scenes of
2189 an application while meshes can be associated with a single scene and then
2190 discarded when the user leaves it.
2191 
2192 A cache offers a set of basic functionalities to query its internal state and to
2193 _organize_ it:
2194 
2195 ```cpp
2196 // gets the number of resources managed by a cache
2197 const auto size = cache.size();
2198 
2199 // checks if a cache contains at least a valid resource
2200 const auto empty = cache.empty();
2201 
2202 // clears a cache and discards its content
2203 cache.clear();
2204 ```
2205 
2206 Besides these member functions, it contains what is needed to load, use and
2207 discard resources of the given type.<br/>
2208 Before to explore this part of the interface, it makes sense to mention how
2209 resources are identified. The type of the identifiers to use is defined as:
2210 
2211 ```cpp
2212 entt::ResourceCache<Resource>::resource_type
2213 ```
2214 
2215 Where `resource_type` is an alias for `entt::HashedString`. Therefore, resource
2216 identifiers are created explicitly as in the following example:
2217 
2218 ```cpp
2219 constexpr auto identifier = entt::ResourceCache<Resource>::resource_type{"my/resource/identifier"};
2220 // this is equivalent to the following
2221 constexpr auto hs = entt::HashedString{"my/resource/identifier"};
2222 ```
2223 
2224 The class `HashedString` is described in a dedicated section, so I won't do in
2225 details here.
2226 
2227 Resources are loaded and thus stored in a cache through the `load` member
2228 function. It accepts the loader to use as a template parameter, the resource
2229 identifier and the parameters used to construct the resource as arguments:
2230 
2231 ```cpp
2232 // uses the identifier declared above
2233 cache.load<MyLoader>(identifier, 0);
2234 
2235 // uses a const char * directly as an identifier
2236 cache.load<MyLoader>("another/identifier", 42);
2237 ```
2238 
2239 The return value can be used to know if the resource has been loaded correctly.
2240 In case the loader returns an invalid pointer or the resource already exists in
2241 the cache, a false value is returned:
2242 
2243 ```cpp
2244 if(!cache.load<MyLoader>("another/identifier", 42)) {
2245  // ...
2246 }
2247 ```
2248 
2249 Unfortunately, in this case there is no way to know what was the problem
2250 exactly. However, before trying to load a resource or after an error, one can
2251 use the `contains` member function to know if a cache already contains a
2252 specific resource:
2253 
2254 ```cpp
2255 auto exists = cache.contains("my/identifier");
2256 ```
2257 
2258 There exists also a member function to use to force a reload of an already
2259 existing resource if needed:
2260 
2261 ```cpp
2262 auto result = cache.reload<MyLoader>("another/identifier", 42);
2263 ```
2264 
2265 As above, the function returns true in case of success, false otherwise. The
2266 sole difference in this case is that an error necessarily means that the loader
2267 has failed for some reasons to load the resource.<br/>
2268 Note that the `reload` member function is a kind of alias of the following
2269 snippet:
2270 
2271 ```cpp
2272 cache.discard(identifier);
2273 cache.load<MyLoader>(identifier, 42);
2274 ```
2275 
2276 Where the `discard` member function is used to get rid of a resource if loaded.
2277 In case the cache doesn't contain a resource for the given identifier, the
2278 function does nothing and returns immediately.
2279 
2280 So far, so good. Resources are finally loaded and stored within the cache.<br/>
2281 They are returned to users in the form of handles. To get one of them:
2282 
2283 ```cpp
2284 auto handle = cache.handle("my/identifier");
2285 ```
2286 
2287 The idea behind a handle is the same of the flyweight pattern. In other terms,
2288 resources aren't copied around. Instead, instances are shared between handles.
2289 Users of a resource owns a handle and it guarantees that a resource isn't
2290 destroyed until all the handles are destroyed, even if the resource itself is
2291 removed from the cache.<br/>
2292 Handles are tiny objects both movable and copyable. They returns the contained
2293 resource as a const reference on request:
2294 
2295 * By means of the `get` member function:
2296 
2297  ```cpp
2298  const auto &resource = handle.get();
2299  ```
2300 
2301 * Using the proper cast operator:
2302 
2303  ```cpp
2304  const auto &resource = handle;
2305  ```
2306 
2307 * Through the dereference operator:
2308 
2309  ```cpp
2310  const auto &resource = *handle;
2311  ```
2312 
2313 The resource can also be accessed directly using the arrow operator if required:
2314 
2315 ```cpp
2316 auto value = handle->value;
2317 ```
2318 
2319 To test if a handle is still valid, the cast operator to `bool` allows users to
2320 use it in a guard:
2321 
2322 ```cpp
2323 if(handle) {
2324  // ...
2325 }
2326 ```
2327 
2328 Finally, in case there is the need to load a resource and thus to get a handle
2329 without storing the resource itself in the cache, users can rely on the `temp`
2330 member function template.<br/>
2331 The declaration is similar to the one of `load` but for the fact that it doesn't
2332 return a boolean value. Instead, it returns a (possibly invalid) handle for the
2333 resource:
2334 
2335 ```cpp
2336 auto handle = cache.temp<MyLoader>("another/identifier", 42);
2337 ```
2338 
2339 Do not forget to test the handle for validity. Otherwise, getting the reference
2340 to the resource it points may result in undefined behavior.
2341 
2342 # Crash Course: events, signals and everything in between
2343 
2344 Signals are usually a core part of games and software architectures in
2345 general.<br/>
2346 Roughly speaking, they help to decouple the various parts of a system while
2347 allowing them to communicate with each other somehow.
2348 
2349 The so called _modern C++_ comes with a tool that can be useful in these terms,
2350 the `std::function`. As an example, it can be used to create delegates.<br/>
2351 However, there is no guarantee that an `std::function` does not perform
2352 allocations under the hood and this could be problematic sometimes. Furthermore,
2353 it solves a problem but may not adapt well to other requirements that may arise
2354 from time to time.
2355 
2356 In case that the flexibility and potential of an `std::function` are not
2357 required or where you are looking for something different, `EnTT` offers a full
2358 set of classes to solve completely different problems.
2359 
2360 ## Signals
2361 
2362 Signal handlers work with naked pointers, function pointers and pointers to
2363 member functions. Listeners can be any kind of objects and the user is in charge
2364 of connecting and disconnecting them from a signal to avoid crashes due to
2365 different lifetimes. On the other side, performance shouldn't be affected that
2366 much by the presence of such a signal handler.<br/>
2367 A signal handler can be used as a private data member without exposing any
2368 _publish_ functionality to the clients of a class. The basic idea is to impose a
2369 clear separation between the signal itself and its _sink_ class, that is a tool
2370 to be used to connect and disconnect listeners on the fly.
2371 
2372 The API of a signal handler is straightforward. The most important thing is that
2373 it comes in two forms: with and without a collector. In case a signal is
2374 associated with a collector, all the values returned by the listeners can be
2375 literally _collected_ and used later by the caller. Otherwise it works just like
2376 a plain signal that emits events from time to time.<br/>
2377 
2378 **Note**: collectors are allowed only in case of function types whose the return
2379 type isn't `void` for obvious reasons.
2380 
2381 To create instances of signal handlers there exist mainly two ways:
2382 
2383 ```cpp
2384 // no collector type
2385 entt::SigH<void(int, char)> signal;
2386 
2387 // explicit collector type
2388 entt::SigH<void(int, char), MyCollector<bool>> collector;
2389 ```
2390 
2391 As expected, they offer all the basic functionalities required to know how many
2392 listeners they contain (`size`) or if they contain at least a listener (`empty`)
2393 and even to swap two signal handlers (`swap`).
2394 
2395 Besides them, there are member functions to use both to connect and disconnect
2396 listeners in all their forms by means of a sink:
2397 
2398 ```cpp
2399 void foo(int, char) { /* ... */ }
2400 
2401 struct S {
2402  void bar(int, char) { /* ... */ }
2403 };
2404 
2405 // ...
2406 
2407 S instance;
2408 
2409 signal.sink().connect<&foo>();
2410 signal.sink().connect<S, &S::bar>(&instance);
2411 
2412 // ...
2413 
2414 // disconnects a free function
2415 signal.sink().disconnect<&foo>();
2416 
2417 // disconnect a specific member function of an instance ...
2418 signal.sink().disconnect<S, &S::bar>(&instance);
2419 
2420 // ... or an instance as a whole
2421 signal.sink().disconnect(&instance);
2422 
2423 // discards all the listeners at once
2424 signal.sink().disconnect();
2425 ```
2426 
2427 Once listeners are attached (or even if there are no listeners at all), events
2428 and data in general can be published through a signal by means of the `publish`
2429 member function:
2430 
2431 ```cpp
2432 signal.publish(42, 'c');
2433 ```
2434 
2435 To collect data, the `collect` member function should be used instead. Below is
2436 a minimal example to show how to use it:
2437 
2438 ```cpp
2439 struct MyCollector {
2440  std::vector<int> vec{};
2441 
2442  bool operator()(int v) noexcept {
2443  vec.push_back(v);
2444  return true;
2445  }
2446 };
2447 
2448 int f() { return 0; }
2449 int g() { return 1; }
2450 
2451 // ...
2452 
2453 entt::SigH<int(), MyCollector<int>> signal;
2454 
2455 signal.sink().connect<&f>();
2456 signal.sink().connect<&g>();
2457 
2458 MyCollector collector = signal.collect();
2459 
2460 assert(collector.vec[0] == 0);
2461 assert(collector.vec[1] == 1);
2462 ```
2463 
2464 As shown above, a collector must expose a function operator that accepts as an
2465 argument a type to which the return type of the listeners can be converted.
2466 Moreover, it has to return a boolean value that is false to stop collecting
2467 data, true otherwise. This way one can avoid calling all the listeners in case
2468 it isn't necessary.
2469 
2470 ## Delegate
2471 
2472 A delegate can be used as general purpose invoker with no memory overhead for
2473 free functions and member functions provided along with an instance on which
2474 to invoke them.<br/>
2475 It does not claim to be a drop-in replacement for an `std::function`, so do not
2476 expect to use it whenever an `std::function` fits well. However, it can be used
2477 to send opaque delegates around to be used to invoke functions as needed.
2478 
2479 The interface is trivial. It offers a default constructor to create empty
2480 delegates:
2481 
2482 ```cpp
2483 entt::Delegate<int(int)> delegate{};
2484 ```
2485 
2486 All what is needed to create an instance is to specify the type of the function
2487 the delegate will _contain_, that is the signature of the free function or the
2488 member function one wants to assign to it.
2489 
2490 Attempting to use an empty delegate by invoking its function call operator
2491 results in undefined behavior, most likely a crash actually. Before to use a
2492 delegate, it must be initialized.<br/>
2493 There exist two functions to do that, both named `connect`:
2494 
2495 ```cpp
2496 int f(int i) { return i; }
2497 
2498 struct MyStruct {
2499  int f(int i) { return i }
2500 };
2501 
2502 // bind a free function to the delegate
2503 delegate.connect<&f>();
2504 
2505 // bind a member function to the delegate
2506 MyStruct instance;
2507 delegate.connect<MyStruct, &MyStruct::f>(&instance);
2508 ```
2509 
2510 It hasn't a `disconnect` counterpart. Instead, there exists a `reset` member
2511 function to clear it.<br/>
2512 The `empty` member function can be used to know if a delegate is empty:
2513 
2514 ```cpp
2515 const auto empty = delegate.empty();
2516 ```
2517 
2518 Finally, to invoke a delegate, the function call operator is the way to go as
2519 usual:
2520 
2521 ```cpp
2522 auto ret = delegate(42);
2523 ```
2524 
2525 Probably too much small and pretty poor of functionalities, but the delegate
2526 class can help in a lot of cases and it has shown that it is worth keeping it
2527 within the library.
2528 
2529 ## Event dispatcher
2530 
2531 The event dispatcher class is designed so as to be used in a loop. It allows
2532 users both to trigger immediate events or to queue events to be published all
2533 together once per tick.<br/>
2534 This class shares part of its API with the one of the signal handler, but it
2535 doesn't require that all the types of events are specified when declared:
2536 
2537 ```cpp
2538 // define a general purpose dispatcher that works with naked pointers
2539 entt::Dispatcher dispatcher{};
2540 ```
2541 
2542 In order to register an instance of a class to a dispatcher, its type must
2543 expose one or more member functions of which the return types are `void` and the
2544 argument lists are `const E &`, for each type of event `E`.<br/>
2545 To ease the development, member functions that are named `receive` are
2546 automatically detected and have not to be explicitly specified when registered.
2547 In all the other cases, the name of the member function aimed to receive the
2548 event must be provided to the `connect` member function of the sink bound to the
2549 specific event:
2550 
2551 ```cpp
2552 struct AnEvent { int value; };
2553 struct AnotherEvent {};
2554 
2555 struct Listener
2556 {
2557  void receive(const AnEvent &) { /* ... */ }
2558  void method(const AnotherEvent &) { /* ... */ }
2559 };
2560 
2561 // ...
2562 
2563 Listener listener;
2564 dispatcher.sink<AnEvent>().connect(&listener);
2565 dispatcher.sink<AnotherEvent>().connect<Listener, &Listener::method>(&listener);
2566 ```
2567 
2568 The `disconnect` member function follows the same pattern and can be used to
2569 selectively remove listeners:
2570 
2571 ```cpp
2572 dispatcher.sink<AnEvent>().disconnect(&listener);
2573 dispatcher.sink<AnotherEvent>().disconnect<Listener, &Listener::method>(&listener);
2574 ```
2575 
2576 The `trigger` member function serves the purpose of sending an immediate event
2577 to all the listeners registered so far. It offers a convenient approach that
2578 relieves the user from having to create the event itself. Instead, it's enough
2579 to specify the type of event and provide all the parameters required to
2580 construct it.<br/>
2581 As an example:
2582 
2583 ```cpp
2584 dispatcher.trigger<AnEvent>(42);
2585 dispatcher.trigger<AnotherEvent>();
2586 ```
2587 
2588 Listeners are invoked immediately, order of execution isn't guaranteed. This
2589 method can be used to push around urgent messages like an _is terminating_
2590 notification on a mobile app.
2591 
2592 On the other hand, the `enqueue` member function queues messages together and
2593 allows to maintain control over the moment they are sent to listeners. The
2594 signature of this method is more or less the same of `trigger`:
2595 
2596 ```cpp
2597 dispatcher.enqueue<AnEvent>(42);
2598 dispatcher.enqueue<AnotherEvent>();
2599 ```
2600 
2601 Events are stored aside until the `update` member function is invoked, then all
2602 the messages that are still pending are sent to the listeners at once:
2603 
2604 ```cpp
2605 // emits all the events of the given type at once
2606 dispatcher.update<MyEvent>();
2607 
2608 // emits all the events queued so far at once
2609 dispatcher.update();
2610 ```
2611 
2612 This way users can embed the dispatcher in a loop and literally dispatch events
2613 once per tick to their systems.
2614 
2615 ## Event emitter
2616 
2617 A general purpose event emitter thought mainly for those cases where it comes to
2618 working with asynchronous stuff.<br/>
2619 Originally designed to fit the requirements of
2620 [`uvw`](https://github.com/skypjack/uvw) (a wrapper for `libuv` written in
2621 modern C++), it was adapted later to be included in this library.
2622 
2623 To create a custom emitter type, derived classes must inherit directly from the
2624 base class as:
2625 
2626 ```cpp
2627 struct MyEmitter: Emitter<MyEmitter> {
2628  // ...
2629 }
2630 ```
2631 
2632 The full list of accepted types of events isn't required. Handlers are created
2633 internally on the fly and thus each type of event is accepted by default.
2634 
2635 Whenever an event is published, an emitter provides the listeners with a
2636 reference to itself along with a const reference to the event. Therefore
2637 listeners have an handy way to work with it without incurring in the need of
2638 capturing a reference to the emitter itself.<br/>
2639 In addition, an opaque object is returned each time a connection is established
2640 between an emitter and a listener, allowing the caller to disconnect them at a
2641 later time.<br/>
2642 The opaque object used to handle connections is both movable and copyable. On
2643 the other side, an event emitter is movable but not copyable by default.
2644 
2645 To create new instances of an emitter, no arguments are required:
2646 
2647 ```cpp
2648 MyEmitter emitter{};
2649 ```
2650 
2651 Listeners must be movable and callable objects (free functions, lambdas,
2652 functors, `std::function`s, whatever) whose function type is:
2653 
2654 ```cpp
2655 void(const Event &, MyEmitter &)
2656 ```
2657 
2658 Where `Event` is the type of event they want to listen.<br/>
2659 There are two ways to attach a listener to an event emitter that differ
2660 slightly from each other:
2661 
2662 * To register a long-lived listener, use the `on` member function. It is meant
2663  to register a listener designed to be invoked more than once for the given
2664  event type.<br/>
2665  As an example:
2666 
2667  ```cpp
2668  auto conn = emitter.on<MyEvent>([](const MyEvent &event, MyEmitter &emitter) {
2669  // ...
2670  });
2671  ```
2672 
2673  The connection object can be freely discarded. Otherwise, it can be used later
2674  to disconnect the listener if required.
2675 
2676 * To register a short-lived listener, use the `once` member function. It is
2677  meant to register a listener designed to be invoked only once for the given
2678  event type. The listener is automatically disconnected after the first
2679  invocation.<br/>
2680  As an example:
2681 
2682  ```cpp
2683  auto conn = emitter.once<MyEvent>([](const MyEvent &event, MyEmitter &emitter) {
2684  // ...
2685  });
2686  ```
2687 
2688  The connection object can be freely discarded. Otherwise, it can be used later
2689  to disconnect the listener if required.
2690 
2691 In both cases, the connection object can be used with the `erase` member
2692 function:
2693 
2694 ```cpp
2695 emitter.erase(conn);
2696 ```
2697 
2698 There are also two member functions to use either to disconnect all the
2699 listeners for a given type of event or to clear the emitter:
2700 
2701 ```cpp
2702 // removes all the listener for the specific event
2703 emitter.clear<MyEvent>();
2704 
2705 // removes all the listeners registered so far
2706 emitter.clear();
2707 ```
2708 
2709 To send an event to all the listeners that are interested in it, the `publish`
2710 member function offers a convenient approach that relieves the user from having
2711 to create the event:
2712 
2713 ```cpp
2714 struct MyEvent { int i; };
2715 
2716 // ...
2717 
2718 emitter.publish<MyEvent>(42);
2719 ```
2720 
2721 Finally, the `empty` member function tests if there exists at least either a
2722 listener registered with the event emitter or to a given type of event:
2723 
2724 ```cpp
2725 bool empty;
2726 
2727 // checks if there is any listener registered for the specific event
2728 empty = emitter.empty<MyEvent>();
2729 
2730 // checks it there are listeners registered with the event emitter
2731 empty = emitter.empty();
2732 ```
2733 
2734 In general, the event emitter is a handy tool when the derived classes _wrap_
2735 asynchronous operations, because it introduces a _nice-to-have_ model based on
2736 events and listeners that kindly hides the complexity behind the scenes. However
2737 it is not limited to such uses.
2738 
2739 # Packaging Tools
2740 
2741 `EnTT` is available for some of the most known packaging tools. In particular:
2742 
2743 * [`vcpkg`](https://github.com/Microsoft/vcpkg/tree/master/ports/entt),
2744  Microsoft VC++ Packaging Tool.
2745 * [`Homebrew`](https://github.com/skypjack/homebrew-entt), the missing package
2746  manager for macOS.<br/>
2747  Available as a homebrew formula. Just type the following to install it:
2748  ```
2749  brew install skypjack/entt/entt
2750  ```
2751 
2752 Consider this list a work in progress and help me to make it longer.
2753 
2754 # EnTT in Action
2755 
2756 `EnTT` is widely used in private and commercial applications. I cannot even
2757 mention most of them because of some signatures I put on some documents time
2758 ago.<br/>
2759 Fortunately, there are also people who took the time to implement open source
2760 projects based on EnTT and did not hold back when it came to documenting them.
2761 
2762 Below an incomplete list of projects and articles:
2763 
2764 * [Minecraft](https://minecraft.net/en-us/attribution/): of course, **that** Minecraft, by Mojang (see the open source attributions page).
2765 * [Face Smash](https://play.google.com/store/apps/details?id=com.gamee.facesmash):
2766  the emojis dominate the world, destroy them all with your facial expressions.
2767 * [EnttPong](https://github.com/reworks/EnttPong): example game with `EnTT`.
2768 * [Space Battle: Huge edition](http://victor.madtriangles.com/code%20experiment/2018/06/11/post-ecs-battle-huge.html):
2769  huge space battle built entirely from scratch.
2770 * [Space Battle](https://github.com/vblanco20-1/ECS_SpaceBattle): huge space
2771  battle built on `UE4`.
2772 * [Experimenting with ECS in UE4](http://victor.madtriangles.com/code%20experiment/2018/03/25/post-ue4-ecs-battle.html):
2773  interesting article about `UE4` and `EnTT`.
2774 * [Implementing ECS architecture in UE4](https://forums.unrealengine.com/development-discussion/c-gameplay-programming/1449913-implementing-ecs-architecture-in-ue4-giant-space-battle):
2775  giant space battle.
2776 * [MatchOneEntt](https://github.com/mhaemmerle/MatchOneEntt): port of
2777  [Match One](https://github.com/sschmid/Match-One) for `Entitas-CSharp`.
2778 * [Randballs](https://github.com/gale93/randballs): simple `SFML` and `EnTT`
2779  playground.
2780 * ...
2781 
2782 If you know of other resources out there that are about `EnTT`, feel free to
2783 open an issue or a PR and I'll be glad to add them to the list.
2784 
2785 <!--
2786 @cond TURN_OFF_DOXYGEN
2787 -->
2788 # Contributors
2789 
2790 `EnTT` was written initially as a faster alternative to other well known and
2791 open source entity-component systems. Nowadays this library is moving its first
2792 steps. Much more will come in the future and hopefully I'm going to work on it
2793 for a long time.<br/>
2794 Requests for features, PR, suggestions ad feedback are highly appreciated.
2795 
2796 If you find you can help me and want to contribute to the project with your
2797 experience or you do want to get part of the project for some other reasons,
2798 feel free to contact me directly (you can find the mail in the
2799 [profile](https://github.com/skypjack)).<br/>
2800 I can't promise that each and every contribution will be accepted, but I can
2801 assure that I'll do my best to take them all seriously.
2802 
2803 If you decide to participate, please see the guidelines for
2804 [contributing](docs/CONTRIBUTING.md) before to create issues or pull requests.<br/>
2805 Take also a look at the
2806 [contributors list](https://github.com/skypjack/entt/blob/master/AUTHORS) to
2807 know who has participated so far.
2808 <!--
2809 @endcond TURN_OFF_DOXYGEN
2810 -->
2811 
2812 # License
2813 
2814 Code and documentation Copyright (c) 2017-2018 Michele Caini.<br/>
2815 Logo Copyright (c) 2018 Richard Caseres.
2816 
2817 Code released under
2818 [the MIT license](https://github.com/skypjack/entt/blob/master/LICENSE).
2819 Documentation released under
2820 [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/).<br/>
2821 Logo released under
2822 [CC BY-SA 4.0](https://creativecommons.org/licenses/by-sa/4.0/).
2823 
2824 <!--
2825 @cond TURN_OFF_DOXYGEN
2826 -->
2827 # Support
2828 
2829 ## Donation
2830 
2831 Developing and maintaining `EnTT` takes some time and lots of coffee. I'd like
2832 to add more and more functionalities in future and turn it in a full-featured
2833 solution.<br/>
2834 If you want to support this project, you can offer me an espresso. I'm from
2835 Italy, we're used to turning the best coffee ever in code. If you find that
2836 it's not enough, feel free to support me the way you prefer.<br/>
2837 Take a look at the donation button at the top of the page for more details or
2838 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).
2839 
2840 ## Hire me
2841 
2842 If you start using `EnTT` and need help, if you want a new feature and want me
2843 to give it the highest priority, if you have any other reason to contact me:
2844 do not hesitate. I'm available for hiring.<br/>
2845 Feel free to take a look at my [profile](https://github.com/skypjack) and
2846 contact me by mail.
2847 <!--
2848 @endcond TURN_OFF_DOXYGEN
2849 -->
Generated by   diff --git a/actor_8hpp_source.html b/actor_8hpp_source.html index 44caf1d34..5e0fa7fcc 100644 --- a/actor_8hpp_source.html +++ b/actor_8hpp_source.html @@ -5,7 +5,7 @@ -entt: src/entt/entity/actor.hpp Source File +EnTT: src/entt/entity/actor.hpp Source File @@ -21,8 +21,8 @@ -
entt -  2.7.1 +
EnTT +  2.7.2
@@ -75,12 +75,12 @@ $(function() {
entt::Actor::Actor
Actor(Registry< Entity > &reg)
Constructs an actor by using the given registry.
Definition: actor.hpp:33
entt
EnTT default namespace.
Definition: algorithm.hpp:10
entt::Actor::entity
entity_type entity() const ENTT_NOEXCEPT
Returns the entity associated with an actor.
Definition: actor.hpp:189
-
entt::Registry::destroy
void destroy(tag_t)
Destroys the entity that owns the given tag, if any.
Definition: registry.hpp:438
+
entt::Registry::destroy
void destroy(tag_t)
Destroys the entity that owns the given tag, if any.
Definition: registry.hpp:483
entt::Actor::assign
Tag & assign(tag_t, Args &&... args)
Assigns the given tag to an actor.
Definition: actor.hpp:66
entt::Actor::assign
Component & assign(Args &&... args)
Assigns the given component to an actor.
Definition: actor.hpp:85
entt::Actor::operator=
Actor & operator=(const Actor &)=default
Default copy assignment operator.
entt::Actor::has
bool has(tag_t) const ENTT_NOEXCEPT
Checks if an actor owns the given tag.
Definition: actor.hpp:114
-
entt::Registry::create
entity_type create()
Creates a new entity and returns it.
Definition: registry.hpp:402
+
entt::Registry::create
entity_type create()
Creates a new entity and returns it.
Definition: registry.hpp:448
entt::Actor
Dedicated to those who aren&#39;t confident with entity-component systems.
Definition: actor.hpp:23
entt::tag_t
Tag class type used to disambiguate overloads.
Definition: utility.hpp:9
entt::Actor::~Actor
virtual ~Actor()
Default destructor.
Definition: actor.hpp:38
diff --git a/algorithm_8hpp_source.html b/algorithm_8hpp_source.html index 71439de8f..a5e59259a 100644 --- a/algorithm_8hpp_source.html +++ b/algorithm_8hpp_source.html @@ -5,7 +5,7 @@ -entt: src/entt/core/algorithm.hpp Source File +EnTT: src/entt/core/algorithm.hpp Source File @@ -21,8 +21,8 @@ -
entt -  2.7.1 +
EnTT +  2.7.2
@@ -67,11 +67,13 @@ $(function() {
algorithm.hpp
-
1 #ifndef ENTT_CORE_ALGORITHM_HPP
2 #define ENTT_CORE_ALGORITHM_HPP
3 
4 
5 #include <functional>
6 #include <algorithm>
7 #include <utility>
8 
9 
10 namespace entt {
11 
12 
21 struct StdSort {
35  template<typename It, typename Compare = std::less<>, typename... Args>
36  void operator()(It first, It last, Compare compare = Compare{}, Args &&... args) const {
37  std::sort(std::forward<Args>(args)..., std::move(first), std::move(last), std::move(compare));
38  }
39 };
40 
41 
43 struct InsertionSort {
55  template<typename It, typename Compare = std::less<>>
56  void operator()(It first, It last, Compare compare = Compare{}) const {
57  auto it = first + 1;
58 
59  while(it != last) {
60  auto value = *it;
61  auto pre = it;
62 
63  while(pre != first && compare(value, *(pre-1))) {
64  *pre = *(pre-1);
65  --pre;
66  }
67 
68  *pre = value;
69  ++it;
70  }
71  }
72 };
73 
74 
75 }
76 
77 
78 #endif // ENTT_CORE_ALGORITHM_HPP
entt
EnTT default namespace.
Definition: algorithm.hpp:10
+
1 #ifndef ENTT_CORE_ALGORITHM_HPP
2 #define ENTT_CORE_ALGORITHM_HPP
3 
4 
5 #include <functional>
6 #include <algorithm>
7 #include <utility>
8 
9 
10 namespace entt {
11 
12 
21 struct StdSort final {
35  template<typename It, typename Compare = std::less<>, typename... Args>
36  void operator()(It first, It last, Compare compare = Compare{}, Args &&... args) const {
37  std::sort(std::forward<Args>(args)..., std::move(first), std::move(last), std::move(compare));
38  }
39 };
40 
41 
43 struct InsertionSort final {
55  template<typename It, typename Compare = std::less<>>
56  void operator()(It first, It last, Compare compare = Compare{}) const {
57  auto it = first + 1;
58 
59  while(it != last) {
60  auto value = *it;
61  auto pre = it;
62 
63  while(pre != first && compare(value, *(pre-1))) {
64  *pre = *(pre-1);
65  --pre;
66  }
67 
68  *pre = value;
69  ++it;
70  }
71  }
72 };
73 
74 
76 struct OneShotBubbleSort final {
90  template<typename It, typename Compare = std::less<>>
91  void operator()(It first, It last, Compare compare = Compare{}) const {
92  if(first != last) {
93  auto it = first++;
94 
95  while(first != last) {
96  if(compare(*first, *it)) {
97  using std::swap;
98  std::swap(*first, *it);
99  }
100 
101  it = first++;
102  }
103  }
104  }
105 };
106 
107 
108 }
109 
110 
111 #endif // ENTT_CORE_ALGORITHM_HPP
entt::OneShotBubbleSort
Function object for performing bubble sort (single iteration).
Definition: algorithm.hpp:76
+
entt
EnTT default namespace.
Definition: algorithm.hpp:10
+
entt::OneShotBubbleSort::operator()
void operator()(It first, It last, Compare compare=Compare{}) const
Tries to sort the elements in a range.
Definition: algorithm.hpp:91
entt::InsertionSort
Function object for performing insertion sort.
Definition: algorithm.hpp:43
entt::StdSort
Function object to wrap std::sort in a class type.
Definition: algorithm.hpp:21
-
entt::InsertionSort::operator()
void operator()(It first, It last, Compare compare=Compare{}) const
Sorts the element in a range.
Definition: algorithm.hpp:56
-
entt::StdSort::operator()
void operator()(It first, It last, Compare compare=Compare{}, Args &&... args) const
Sorts the element in a range.
Definition: algorithm.hpp:36
+
entt::InsertionSort::operator()
void operator()(It first, It last, Compare compare=Compare{}) const
Sorts the elements in a range.
Definition: algorithm.hpp:56
+
entt::StdSort::operator()
void operator()(It first, It last, Compare compare=Compare{}, Args &&... args) const
Sorts the elements in a range.
Definition: algorithm.hpp:36
diff --git a/annotated.html b/annotated.html index 7c018f01c..b1e39d443 100644 --- a/annotated.html +++ b/annotated.html @@ -5,7 +5,7 @@ -entt: Class List +EnTT: Class List @@ -21,8 +21,8 @@ -
entt -  2.7.1 +
EnTT +  2.7.2
@@ -83,33 +83,34 @@ $(function() {  CIdentifierTypes identifiers  CInsertionSortFunction object for performing insertion sort  CMonostateMinimal implementation of the monostate pattern - Cpersistent_tPersistent view type used to disambiguate overloads - CPersistentViewPersistent view - CProcessBase class for processes - CProcessAdaptorAdaptor for lambdas and functors to turn them into processes - CPrototypePrototype container for concepts - Craw_tRaw view type used to disambiguate overloads - CRawViewRaw view - CRegistryFast and reliable entity-component system - CResourceCacheSimple cache for resources of a given type - CResourceHandleShared resource handle - CResourceLoaderBase class for resource loaders - CRuntimeViewRuntime view - CSchedulerCooperative scheduler for processes - CServiceLocatorService locator, nothing more - CSigHUnmanaged signal handler declaration - CSigH< Ret(Args...), Collector >Unmanaged signal handler definition - CSinkSink implementation - CSink< Ret(Args...)>Sink implementation - CSnapshotUtility class to create snapshots from a registry - CSnapshotLoaderUtility class to restore a snapshot as a whole - CSparseSetSparse set - CSparseSet< Entity >Basic sparse set implementation - CSparseSet< Entity, Type >Extended sparse set implementation - CStdSortFunction object to wrap std::sort in a class type - Ctag_tTag class type used to disambiguate overloads - CViewMulti component view - CView< Entity, Component >Single component view specialization + COneShotBubbleSortFunction object for performing bubble sort (single iteration) + Cpersistent_tPersistent view type used to disambiguate overloads + CPersistentViewPersistent view + CProcessBase class for processes + CProcessAdaptorAdaptor for lambdas and functors to turn them into processes + CPrototypePrototype container for concepts + Craw_tRaw view type used to disambiguate overloads + CRawViewRaw view + CRegistryFast and reliable entity-component system + CResourceCacheSimple cache for resources of a given type + CResourceHandleShared resource handle + CResourceLoaderBase class for resource loaders + CRuntimeViewRuntime view + CSchedulerCooperative scheduler for processes + CServiceLocatorService locator, nothing more + CSigHUnmanaged signal handler declaration + CSigH< Ret(Args...), Collector >Unmanaged signal handler definition + CSinkSink implementation + CSink< Ret(Args...)>Sink implementation + CSnapshotUtility class to create snapshots from a registry + CSnapshotLoaderUtility class to restore a snapshot as a whole + CSparseSetSparse set + CSparseSet< Entity >Basic sparse set implementation + CSparseSet< Entity, Type >Extended sparse set implementation + CStdSortFunction object to wrap std::sort in a class type + Ctag_tTag class type used to disambiguate overloads + CViewMulti component view + CView< Entity, Component >Single component view specialization
diff --git a/autotoc_md0.html b/autotoc_md0.html new file mode 100644 index 000000000..d051bcbbe --- /dev/null +++ b/autotoc_md0.html @@ -0,0 +1,84 @@ + + + + + + + +EnTT: Contributing + + + + + + + + + +
+
+ + + + + + +
+
EnTT +  2.7.2 +
+
+
+ + + + + + + + +
+
+ + +
+ +
+ +
+
+
+
Contributing
+
+
+

First of all, thank you very much for taking the time to contribute to the EnTT framework.
+ How to do it mostly depends on the type of contribution:

+
    +
  • If you have a question, please ensure there isn't already an answer for you by searching on GitHub under issues. Do not forget to search also through the closed ones. If you are unable to find a proper answer, feel free to open a new issue. Usually, questions are marked as such and closed in a few days.
    • +
  • If you want to fix a typo in the inline documentation or in the README file, if you want to add some new sections or if you want to help me with the language by reviewing what I wrote so far (I'm not a native speaker after all), please open a new pull request with your changes.
    • +
  • If you found a bug, please ensure there isn't already an answer for you by searching on GitHub under issues. If you are unable to find an open issue addressing the problem, feel free to open a new one. Please, do not forget to carefully describe how to reproduce the problem, then add all the informaion about the system on which you are experiencing it and point out the version of EnTT you are using (tag or commit).
    • +
  • If you found a bug and you wrote a patch to fix it, open a new pull request with your code. Please, add some tests to avoid regressions in future if possible, it would be really appreciated. Note that the EnTT framework has a coverage at 100% (at least it was at 100% at the time I wrote this file) and this is the reason for which you can be confident with using it in a production environment.
    • +
  • If you want to propose a new feature and you know how to code it, please do not issue directly a pull request. Before to do it, create a new issue to discuss your proposal. Other users could be interested in your idea and the discussion that will follow can refine it and therefore give us a better solution.
    • +
  • If you want to request a new feature, I'm available for hiring. Take a look at my profile and feel free to write me.
    • +
+
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/cache_8hpp_source.html b/cache_8hpp_source.html index c6b5089c0..0c28e23d4 100644 --- a/cache_8hpp_source.html +++ b/cache_8hpp_source.html @@ -5,7 +5,7 @@ -entt: src/entt/resource/cache.hpp Source File +EnTT: src/entt/resource/cache.hpp Source File @@ -21,8 +21,8 @@ -
entt -  2.7.1 +
EnTT +  2.7.2
diff --git a/classentt_1_1ContinuousLoader-members.html b/classentt_1_1ContinuousLoader-members.html index 8f4c6c2a9..972d2f3b7 100644 --- a/classentt_1_1ContinuousLoader-members.html +++ b/classentt_1_1ContinuousLoader-members.html @@ -5,7 +5,7 @@ -entt: Member List +EnTT: Member List @@ -21,8 +21,8 @@ -
entt -  2.7.1 +
EnTT +  2.7.2
diff --git a/classentt_1_1ContinuousLoader.html b/classentt_1_1ContinuousLoader.html index edc14625f..531379873 100644 --- a/classentt_1_1ContinuousLoader.html +++ b/classentt_1_1ContinuousLoader.html @@ -5,7 +5,7 @@ -entt: entt::ContinuousLoader< Entity > Class Template Reference +EnTT: entt::ContinuousLoader< Entity > Class Template Reference @@ -21,8 +21,8 @@ -
entt -  2.7.1 +
EnTT +  2.7.2
diff --git a/classentt_1_1Delegate.html b/classentt_1_1Delegate.html index 3501e4b1d..c14f27c1a 100644 --- a/classentt_1_1Delegate.html +++ b/classentt_1_1Delegate.html @@ -5,7 +5,7 @@ -entt: entt::Delegate< typename > Class Template Reference +EnTT: entt::Delegate< typename > Class Template Reference @@ -21,8 +21,8 @@ -
entt -  2.7.1 +
EnTT +  2.7.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 5881e039e..7d4a19679 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 @@ -5,7 +5,7 @@ -entt: Member List +EnTT: Member List @@ -21,8 +21,8 @@ -
entt -  2.7.1 +
EnTT +  2.7.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 b92cdc830..08b2f0166 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 @@ -5,7 +5,7 @@ -entt: entt::Delegate< Ret(Args...)> Class Template Reference +EnTT: entt::Delegate< Ret(Args...)> Class Template Reference @@ -21,8 +21,8 @@ -
entt -  2.7.1 +
EnTT +  2.7.2
diff --git a/classentt_1_1Dispatcher-members.html b/classentt_1_1Dispatcher-members.html index 2ddfa4f73..af5735ae8 100644 --- a/classentt_1_1Dispatcher-members.html +++ b/classentt_1_1Dispatcher-members.html @@ -5,7 +5,7 @@ -entt: Member List +EnTT: Member List @@ -21,8 +21,8 @@ -
entt -  2.7.1 +
EnTT +  2.7.2
diff --git a/classentt_1_1Dispatcher.html b/classentt_1_1Dispatcher.html index be1860c38..d95adf49a 100644 --- a/classentt_1_1Dispatcher.html +++ b/classentt_1_1Dispatcher.html @@ -5,7 +5,7 @@ -entt: entt::Dispatcher Class Reference +EnTT: entt::Dispatcher Class Reference @@ -21,8 +21,8 @@ -
entt -  2.7.1 +
EnTT +  2.7.2
diff --git a/classentt_1_1Emitter-members.html b/classentt_1_1Emitter-members.html index 01d76d896..b25ef2391 100644 --- a/classentt_1_1Emitter-members.html +++ b/classentt_1_1Emitter-members.html @@ -5,7 +5,7 @@ -entt: Member List +EnTT: Member List @@ -21,8 +21,8 @@ -
entt -  2.7.1 +
EnTT +  2.7.2
diff --git a/classentt_1_1Emitter.html b/classentt_1_1Emitter.html index 967b1616d..1b6320154 100644 --- a/classentt_1_1Emitter.html +++ b/classentt_1_1Emitter.html @@ -5,7 +5,7 @@ -entt: entt::Emitter< Derived > Class Template Reference +EnTT: entt::Emitter< Derived > Class Template Reference @@ -21,8 +21,8 @@ -
entt -  2.7.1 +
EnTT +  2.7.2
diff --git a/classentt_1_1Family-members.html b/classentt_1_1Family-members.html index 9cdfc06b8..1fd684b40 100644 --- a/classentt_1_1Family-members.html +++ b/classentt_1_1Family-members.html @@ -5,7 +5,7 @@ -entt: Member List +EnTT: Member List @@ -21,8 +21,8 @@ -
entt -  2.7.1 +
EnTT +  2.7.2
diff --git a/classentt_1_1Family.html b/classentt_1_1Family.html index 43d241d68..71b92e65f 100644 --- a/classentt_1_1Family.html +++ b/classentt_1_1Family.html @@ -5,7 +5,7 @@ -entt: entt::Family<... > Class Template Reference +EnTT: entt::Family<... > Class Template Reference @@ -21,8 +21,8 @@ -
entt -  2.7.1 +
EnTT +  2.7.2
diff --git a/classentt_1_1HashedString-members.html b/classentt_1_1HashedString-members.html index 9b861967b..65dbe27db 100644 --- a/classentt_1_1HashedString-members.html +++ b/classentt_1_1HashedString-members.html @@ -5,7 +5,7 @@ -entt: Member List +EnTT: Member List @@ -21,8 +21,8 @@ -
entt -  2.7.1 +
EnTT +  2.7.2
diff --git a/classentt_1_1HashedString.html b/classentt_1_1HashedString.html index 8f3b60363..c21d2ecc6 100644 --- a/classentt_1_1HashedString.html +++ b/classentt_1_1HashedString.html @@ -5,7 +5,7 @@ -entt: entt::HashedString Class Reference +EnTT: entt::HashedString Class Reference @@ -21,8 +21,8 @@ -
entt -  2.7.1 +
EnTT +  2.7.2
diff --git a/classentt_1_1Identifier-members.html b/classentt_1_1Identifier-members.html index 9145dc3b0..d422d6a98 100644 --- a/classentt_1_1Identifier-members.html +++ b/classentt_1_1Identifier-members.html @@ -5,7 +5,7 @@ -entt: Member List +EnTT: Member List @@ -21,8 +21,8 @@ -
entt -  2.7.1 +
EnTT +  2.7.2
diff --git a/classentt_1_1Identifier.html b/classentt_1_1Identifier.html index 1acbdcd14..db4e76125 100644 --- a/classentt_1_1Identifier.html +++ b/classentt_1_1Identifier.html @@ -5,7 +5,7 @@ -entt: entt::Identifier< Types > Class Template Reference +EnTT: entt::Identifier< Types > Class Template Reference @@ -21,8 +21,8 @@ -
entt -  2.7.1 +
EnTT +  2.7.2
diff --git a/classentt_1_1PersistentView-members.html b/classentt_1_1PersistentView-members.html index 723dc5708..f5837e4c8 100644 --- a/classentt_1_1PersistentView-members.html +++ b/classentt_1_1PersistentView-members.html @@ -5,7 +5,7 @@ -entt: Member List +EnTT: Member List @@ -21,8 +21,8 @@ -
entt -  2.7.1 +
EnTT +  2.7.2
diff --git a/classentt_1_1PersistentView.html b/classentt_1_1PersistentView.html index 8795e94c8..46c9c2077 100644 --- a/classentt_1_1PersistentView.html +++ b/classentt_1_1PersistentView.html @@ -5,7 +5,7 @@ -entt: entt::PersistentView< Entity, Component > Class Template Reference +EnTT: entt::PersistentView< Entity, Component > Class Template Reference @@ -21,8 +21,8 @@ -
entt -  2.7.1 +
EnTT +  2.7.2
diff --git a/classentt_1_1Process-members.html b/classentt_1_1Process-members.html index b731a009d..bd158ab67 100644 --- a/classentt_1_1Process-members.html +++ b/classentt_1_1Process-members.html @@ -5,7 +5,7 @@ -entt: Member List +EnTT: Member List @@ -21,8 +21,8 @@ -
entt -  2.7.1 +
EnTT +  2.7.2
diff --git a/classentt_1_1Process.html b/classentt_1_1Process.html index f931c25e7..65425e304 100644 --- a/classentt_1_1Process.html +++ b/classentt_1_1Process.html @@ -5,7 +5,7 @@ -entt: entt::Process< Derived, Delta > Class Template Reference +EnTT: entt::Process< Derived, Delta > Class Template Reference @@ -21,8 +21,8 @@ -
entt -  2.7.1 +
EnTT +  2.7.2
diff --git a/classentt_1_1Prototype-members.html b/classentt_1_1Prototype-members.html index ccba361e7..baa72dcaf 100644 --- a/classentt_1_1Prototype-members.html +++ b/classentt_1_1Prototype-members.html @@ -5,7 +5,7 @@ -entt: Member List +EnTT: Member List @@ -21,8 +21,8 @@ -
entt -  2.7.1 +
EnTT +  2.7.2
diff --git a/classentt_1_1Prototype.html b/classentt_1_1Prototype.html index 925978865..cb3583a3c 100644 --- a/classentt_1_1Prototype.html +++ b/classentt_1_1Prototype.html @@ -5,7 +5,7 @@ -entt: entt::Prototype< Entity > Class Template Reference +EnTT: entt::Prototype< Entity > Class Template Reference @@ -21,8 +21,8 @@ -
entt -  2.7.1 +
EnTT +  2.7.2
diff --git a/classentt_1_1RawView-members.html b/classentt_1_1RawView-members.html index caf6fc6f2..d0d2cb361 100644 --- a/classentt_1_1RawView-members.html +++ b/classentt_1_1RawView-members.html @@ -5,7 +5,7 @@ -entt: Member List +EnTT: Member List @@ -21,8 +21,8 @@ -
entt -  2.7.1 +
EnTT +  2.7.2
diff --git a/classentt_1_1RawView.html b/classentt_1_1RawView.html index 4d3a20816..412e57e50 100644 --- a/classentt_1_1RawView.html +++ b/classentt_1_1RawView.html @@ -5,7 +5,7 @@ -entt: entt::RawView< Entity, Component > Class Template Reference +EnTT: entt::RawView< Entity, Component > Class Template Reference @@ -21,8 +21,8 @@ -
entt -  2.7.1 +
EnTT +  2.7.2
@@ -189,7 +189,7 @@ class entt::RawView< Entity, Component > -

Definition at line 1300 of file view.hpp.

+

Definition at line 1295 of file view.hpp.

Member Function Documentation

◆ begin() [1/2]

@@ -221,7 +221,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 instance of the given type.
-

Definition at line 1414 of file view.hpp.

+

Definition at line 1409 of file view.hpp.

@@ -255,7 +255,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 instance of the given type.
-

Definition at line 1430 of file view.hpp.

+

Definition at line 1425 of file view.hpp.

@@ -289,7 +289,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 instance of the given type.
-

Definition at line 1398 of file view.hpp.

+

Definition at line 1393 of file view.hpp.

@@ -323,7 +323,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 element following the last instance of the given type.
-

Definition at line 1449 of file view.hpp.

+

Definition at line 1444 of file view.hpp.

@@ -357,7 +357,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 1382 of file view.hpp.

+

Definition at line 1377 of file view.hpp.

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

Definition at line 1524 of file view.hpp.

+

Definition at line 1519 of file view.hpp.

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

Definition at line 1543 of file view.hpp.

+

Definition at line 1538 of file view.hpp.

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

Checks whether the view is empty.

Returns
True if the view is empty, false otherwise.
-

Definition at line 1334 of file view.hpp.

+

Definition at line 1329 of file view.hpp.

@@ -519,7 +519,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 element following the last instance of the given type.
-

Definition at line 1468 of file view.hpp.

+

Definition at line 1463 of file view.hpp.

@@ -553,7 +553,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 element following the last instance of the given type.
-

Definition at line 1487 of file view.hpp.

+

Definition at line 1482 of file view.hpp.

@@ -592,7 +592,7 @@ template<typename Entity , typename Component >
Returns
A reference to the requested element.
-

Definition at line 1496 of file view.hpp.

+

Definition at line 1491 of file view.hpp.

@@ -631,7 +631,7 @@ template<typename Entity , typename Component >
Returns
A reference to the requested element.
-

Definition at line 1505 of file view.hpp.

+

Definition at line 1500 of file view.hpp.

@@ -665,7 +665,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 1350 of file view.hpp.

+

Definition at line 1345 of file view.hpp.

@@ -699,7 +699,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 1366 of file view.hpp.

+

Definition at line 1361 of file view.hpp.

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

Returns the number of instances of the given type.

Returns
Number of instances of the given component.
-

Definition at line 1326 of file view.hpp.

+

Definition at line 1321 of file view.hpp.

diff --git a/classentt_1_1Registry-members.html b/classentt_1_1Registry-members.html index 9853e4beb..a2c8cc986 100644 --- a/classentt_1_1Registry-members.html +++ b/classentt_1_1Registry-members.html @@ -5,7 +5,7 @@ -entt: Member List +EnTT: Member List @@ -21,8 +21,8 @@ -
entt -  2.7.1 +
EnTT +  2.7.2
@@ -71,27 +71,29 @@ $(function() {

This is the complete list of members for entt::Registry< Entity >, including all inherited members.

- - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + diff --git a/classentt_1_1Registry.html b/classentt_1_1Registry.html index 8b4d9caf6..ef5cf28f5 100644 --- a/classentt_1_1Registry.html +++ b/classentt_1_1Registry.html @@ -5,7 +5,7 @@ -entt: entt::Registry< Entity > Class Template Reference +EnTT: entt::Registry< Entity > Class Template Reference @@ -21,8 +21,8 @@ @@ -131,8 +131,11 @@ Public Member Functions - + + + + @@ -166,16 +169,19 @@ Public Member Functions - + - + - + + + + - + @@ -185,19 +191,19 @@ Public Member Functions - + - + - + - + @@ -205,7 +211,7 @@ Public Member Functions - + @@ -213,11 +219,11 @@ Public Member Functions - + - + @@ -229,19 +235,19 @@ Public Member Functions - + - + - + - + @@ -249,11 +255,11 @@ Public Member Functions - + - + @@ -261,7 +267,7 @@ Public Member Functions - + @@ -289,7 +295,7 @@ Public Member Functions - + @@ -303,7 +309,7 @@ Public Member Functions - + @@ -413,7 +419,7 @@ template<typename Component , typename... Args>

Assigns or replaces the given component for an entity.

Equivalent to the following snippet (pseudocode):

-
if(registry.has<Component>(entity)) {
registry.replace<Component>(entity, args...);
} else {
registry.assign<Component>(entity, args...);
}

Prefer this function anyway because it has slightly better performance.

+
if(registry.has<Component>(entity)) {
registry.replace<Component>(entity, args...);
} else {
registry.assign<Component>(entity, args...);
}

Prefer this function anyway because it has slightly better performance.

Warning
Attempting to use an invalid entity results in undefined behavior.
An assertion will abort the execution at runtime in debug mode in case of invalid entity.
Template Parameters
@@ -432,7 +438,39 @@ template<typename Component , typename... Args>
Returns
A reference to the newly created component.
-

Definition at line 911 of file registry.hpp.

+

Definition at line 956 of file registry.hpp.

+ + + + +

◆ alive()

+ +
+
+
+template<typename Entity>
+
accommodate(const entity_type entity, Args &&... args)entt::Registry< Entity >inline
assign(tag_t, const entity_type entity, Args &&... args)entt::Registry< Entity >inline
assign(const entity_type entity, Args &&... args)entt::Registry< Entity >inline
attachee() const ENTT_NOEXCEPTentt::Registry< Entity >inline
capacity() const ENTT_NOEXCEPTentt::Registry< Entity >inline
capacity() const ENTT_NOEXCEPTentt::Registry< Entity >inline
component_type typedefentt::Registry< Entity >
construction(tag_t) ENTT_NOEXCEPTentt::Registry< Entity >inline
construction() ENTT_NOEXCEPTentt::Registry< Entity >inline
contains() const ENTT_NOEXCEPTentt::Registry< Entity >inline
create()entt::Registry< Entity >inline
current(const entity_type entity) const ENTT_NOEXCEPTentt::Registry< Entity >inline
data() const ENTT_NOEXCEPTentt::Registry< Entity >inline
destroy(tag_t)entt::Registry< Entity >inline
destroy(const entity_type entity)entt::Registry< Entity >inline
destroy(Type...)entt::Registry< Entity >inline
destruction(tag_t) ENTT_NOEXCEPTentt::Registry< Entity >inline
destruction() ENTT_NOEXCEPTentt::Registry< Entity >inline
discard()entt::Registry< Entity >inline
each(Func func) constentt::Registry< Entity >inline
empty() const ENTT_NOEXCEPTentt::Registry< Entity >inline
empty() const ENTT_NOEXCEPTentt::Registry< Entity >inline
alive() const ENTT_NOEXCEPTentt::Registry< Entity >inline
assign(tag_t, const entity_type entity, Args &&... args)entt::Registry< Entity >inline
assign(const entity_type entity, Args &&... args)entt::Registry< Entity >inline
attachee() const ENTT_NOEXCEPTentt::Registry< Entity >inline
capacity() const ENTT_NOEXCEPTentt::Registry< Entity >inline
capacity() const ENTT_NOEXCEPTentt::Registry< Entity >inline
component_type typedefentt::Registry< Entity >
construction(tag_t) ENTT_NOEXCEPTentt::Registry< Entity >inline
construction() ENTT_NOEXCEPTentt::Registry< Entity >inline
contains() const ENTT_NOEXCEPTentt::Registry< Entity >inline
create()entt::Registry< Entity >inline
current(const entity_type entity) const ENTT_NOEXCEPTentt::Registry< Entity >inline
data() const ENTT_NOEXCEPTentt::Registry< Entity >inline
destroy(tag_t)entt::Registry< Entity >inline
destroy(const entity_type entity)entt::Registry< Entity >inline
destroy(Type...)entt::Registry< Entity >inline
destruction(tag_t) ENTT_NOEXCEPTentt::Registry< Entity >inline
destruction() ENTT_NOEXCEPTentt::Registry< Entity >inline
discard()entt::Registry< Entity >inline
each(Func func) constentt::Registry< Entity >inline
empty() const ENTT_NOEXCEPTentt::Registry< Entity >inline
empty() const ENTT_NOEXCEPTentt::Registry< Entity >inline
entity(const entity_type entity) const ENTT_NOEXCEPTentt::Registry< Entity >inline
entity_type typedefentt::Registry< Entity >
fast(const entity_type entity) const ENTT_NOEXCEPTentt::Registry< Entity >inline
get() const ENTT_NOEXCEPTentt::Registry< Entity >inline
-
entt -  2.7.1 +
EnTT +  2.7.2
 Returns the number of existing components of the given type. More...
 
size_type size () const ENTT_NOEXCEPT
 Returns the number of entities still in use. More...
 Returns the number of entities created so far. More...
 
size_type alive () const ENTT_NOEXCEPT
 Returns the number of entities still in use. More...
 
template<typename Component >
void reserve (const size_type cap)
 Increases the capacity of the pool for the given component. More...
const entity_type * data () const ENTT_NOEXCEPT
 Direct access to the list of entities of a given pool. More...
 
bool valid (const entity_type entity) const ENTT_NOEXCEPT
bool valid (const entity_type entity) const ENTT_NOEXCEPT
 Checks if an entity identifier refers to a valid entity. More...
 
bool fast (const entity_type entity) const ENTT_NOEXCEPT
bool fast (const entity_type entity) const ENTT_NOEXCEPT
 Checks if an entity identifier refers to a valid entity. More...
 
version_type version (const entity_type entity) const ENTT_NOEXCEPT
entity_type entity (const entity_type entity) const ENTT_NOEXCEPT
 Returns the entity identifier without the version. More...
 
version_type version (const entity_type entity) const ENTT_NOEXCEPT
 Returns the version stored along with an entity identifier. More...
 
version_type current (const entity_type entity) const ENTT_NOEXCEPT
version_type current (const entity_type entity) const ENTT_NOEXCEPT
 Returns the actual version for an entity identifier. More...
 
entity_type create ()
void destroy (tag_t)
 Destroys the entity that owns the given tag, if any. More...
 
void destroy (const entity_type entity)
void destroy (const entity_type entity)
 Destroys an entity and lets the registry recycle the identifier. More...
 
template<typename... Component, typename... Type>
void destroy (Type...)
 Destroys the entities that own he given components, if any. More...
 Destroys the entities that own the given components, if any. More...
 
template<typename Tag , typename... Args>
Tag & assign (tag_t, const entity_type entity, Args &&... args)
Tag & assign (tag_t, const entity_type entity, Args &&... args)
 Attaches the given tag to an entity. More...
 
template<typename Component , typename... Args>
Component & assign (const entity_type entity, Args &&... args)
Component & assign (const entity_type entity, Args &&... args)
 Assigns the given component to an entity. More...
 
template<typename Tag >
 Removes the given tag from its owner, if any. More...
 
template<typename Component >
void remove (const entity_type entity)
void remove (const entity_type entity)
 Removes the given component from an entity. More...
 
template<typename Tag >
 Checks if the given tag has an owner. More...
 
template<typename Tag >
bool has (tag_t, const entity_type entity) const ENTT_NOEXCEPT
bool has (tag_t, const entity_type entity) const ENTT_NOEXCEPT
 Checks if an entity owns the given tag. More...
 
template<typename... Component>
bool has (const entity_type entity) const ENTT_NOEXCEPT
bool has (const entity_type entity) const ENTT_NOEXCEPT
 Checks if an entity has all the given components. More...
 
template<typename Tag >
 Returns a reference to the given tag. More...
 
template<typename Component >
const Component & get (const entity_type entity) const ENTT_NOEXCEPT
const Component & get (const entity_type entity) const ENTT_NOEXCEPT
 Returns a reference to the given component for an entity. More...
 
template<typename Component >
Component & get (const entity_type entity) ENTT_NOEXCEPT
Component & get (const entity_type entity) ENTT_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 (const entity_type entity) const ENTT_NOEXCEPT
std::enable_if_t<(sizeof...(Component) > 1), std::tuple< const Component &... > > get (const entity_type entity) const ENTT_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 (const entity_type entity) ENTT_NOEXCEPT
std::enable_if_t<(sizeof...(Component) > 1), std::tuple< Component &... > > get (const entity_type entity) ENTT_NOEXCEPT
 Returns a reference to the given components for an entity. More...
 
template<typename Tag , typename... Args>
 Replaces the given tag. More...
 
template<typename Component , typename... Args>
Component & replace (const entity_type entity, Args &&... args)
Component & replace (const entity_type entity, Args &&... args)
 Replaces the given component for an entity. More...
 
template<typename Tag >
entity_type move (const entity_type entity) ENTT_NOEXCEPT
entity_type move (const entity_type entity) ENTT_NOEXCEPT
 Changes the owner of the given tag. More...
 
template<typename Tag >
 Gets the owner of the given tag, if any. More...
 
template<typename Component , typename... Args>
Component & accommodate (const entity_type entity, Args &&... args)
Component & accommodate (const entity_type entity, Args &&... args)
 Assigns or replaces the given component for an entity. More...
 
template<typename Tag >
 Sorts two pools of components in the same way. More...
 
template<typename Component >
void reset (const entity_type entity)
void reset (const entity_type entity)
 Resets the given component for an entity. More...
 
template<typename Component >
void each (Func func) const
 Iterates all the entities that are still in use. More...
 
bool orphan (const entity_type entity) const
bool orphan (const entity_type entity) const
 Checks if an entity is an orphan. More...
 
template<typename Func >
+ + + + +
+ + + + + + + +
size_type entt::Registry< Entity >::alive () const
+ 		+inline
+
+ +

Returns the number of entities still in use.

+
Returns
Number of entities still in use.
+ +

Definition at line 231 of file registry.hpp.

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

Definition at line 543 of file registry.hpp.

+

Definition at line 588 of file registry.hpp.

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

Definition at line 574 of file registry.hpp.

+

Definition at line 619 of file registry.hpp.

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

Definition at line 879 of file registry.hpp.

+

Definition at line 924 of file registry.hpp.

@@ -645,7 +683,7 @@ template<typename Component >
Returns
Capacity of the pool of the given component.
-

Definition at line 231 of file registry.hpp.

+

Definition at line 268 of file registry.hpp.

@@ -677,7 +715,7 @@ template<typename Entity>

Returns the number of entities that a registry has currently allocated space for.

Returns
Capacity of the registry.
-

Definition at line 240 of file registry.hpp.

+

Definition at line 277 of file registry.hpp.

@@ -723,7 +761,7 @@ template<typename Tag >
Returns
A temporary sink object.
-

Definition at line 944 of file registry.hpp.

+

Definition at line 989 of file registry.hpp.

@@ -768,7 +806,7 @@ template<typename Component >
Returns
A temporary sink object.
-

Definition at line 973 of file registry.hpp.

+

Definition at line 1018 of file registry.hpp.

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

Definition at line 1397 of file registry.hpp.

+

Definition at line 1422 of file registry.hpp.

@@ -847,7 +885,7 @@ template<typename Entity>

The returned entity has no components nor tags assigned.

Returns
A valid entity identifier.
-

Definition at line 402 of file registry.hpp.

+

Definition at line 448 of file registry.hpp.

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

Definition at line 379 of file registry.hpp.

+

Definition at line 425 of file registry.hpp.

@@ -931,7 +969,7 @@ template<typename Component >
Returns
A pointer to the array of entities.
-

Definition at line 316 of file registry.hpp.

+

Definition at line 353 of file registry.hpp.

@@ -973,7 +1011,7 @@ template<typename Tag > -

Definition at line 438 of file registry.hpp.

+

Definition at line 483 of file registry.hpp.

@@ -1016,7 +1054,7 @@ Attempting to use an invalid entity results in undefined behavior.
-

Definition at line 464 of file registry.hpp.

+

Definition at line 509 of file registry.hpp.

@@ -1048,10 +1086,10 @@ template<typename... Component, typename... Type>
-

Destroys the entities that own he given components, if any.

+

Destroys the entities that own the given components, if any.

Convenient shortcut to destroy a set of entities at once.
Syntactic sugar for the following snippet:

-
for(const auto entity: registry.view<Component...>(Type{}...)) {
registry.destroy(entity);
}
Template Parameters
+
for(const auto entity: registry.view<Component...>(Type{}...)) {
registry.destroy(entity);
}
Template Parameters
@@ -1059,7 +1097,7 @@ template<typename... Component, typename... Type> -

Definition at line 515 of file registry.hpp.

+

Definition at line 560 of file registry.hpp.

@@ -1105,7 +1143,7 @@ template<typename Tag >
Returns
A temporary sink object.
-

Definition at line 1002 of file registry.hpp.

+

Definition at line 1047 of file registry.hpp.

@@ -1150,7 +1188,7 @@ template<typename Component >
Returns
A temporary sink object.
-

Definition at line 1031 of file registry.hpp.

+

Definition at line 1076 of file registry.hpp.

@@ -1192,7 +1230,7 @@ template<typename... Component> -

Definition at line 1373 of file registry.hpp.

+

Definition at line 1409 of file registry.hpp.

@@ -1243,7 +1281,7 @@ template<typename Func > -

Definition at line 1204 of file registry.hpp.

+

Definition at line 1249 of file registry.hpp.

@@ -1283,7 +1321,7 @@ template<typename Component >
Returns
True if the pool of the given component is empty, false otherwise.
-

Definition at line 251 of file registry.hpp.

+

Definition at line 288 of file registry.hpp.

@@ -1315,7 +1353,46 @@ 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 259 of file registry.hpp.

+

Definition at line 296 of file registry.hpp.

+ + + + +

◆ entity()

+ +
+
+
+template<typename Entity>
+
ComponentTypes of components to use to search for the entities.
TypeType of view to use or empty to use a standard view.
+ + + + +
+ + + + + + + + +
entity_type entt::Registry< Entity >::entity (const entity_type entity) const
+ 		+inline
+
+ +

Returns the entity identifier without the version.

+
Parameters
+ + +
entityAn entity identifier, either valid or not.
+
+
+
Returns
The entity identifier without the version.
+ +

Definition at line 395 of file registry.hpp.

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

Definition at line 347 of file registry.hpp.

+

Definition at line 384 of file registry.hpp.

@@ -1400,7 +1477,7 @@ template<typename Tag >
Returns
A reference to the tag.
-

Definition at line 690 of file registry.hpp.

+

Definition at line 735 of file registry.hpp.

@@ -1442,7 +1519,7 @@ template<typename Tag >
Returns
A reference to the tag.
-

Definition at line 708 of file registry.hpp.

+

Definition at line 753 of file registry.hpp.

@@ -1491,7 +1568,7 @@ template<typename Component >
Returns
A reference to the component owned by the entity.
-

Definition at line 727 of file registry.hpp.

+

Definition at line 772 of file registry.hpp.

@@ -1540,7 +1617,7 @@ template<typename Component >
Returns
A reference to the component owned by the entity.
-

Definition at line 748 of file registry.hpp.

+

Definition at line 793 of file registry.hpp.

@@ -1589,7 +1666,7 @@ template<typename... Component>
Returns
References to the components owned by the entity.
-

Definition at line 768 of file registry.hpp.

+

Definition at line 813 of file registry.hpp.

@@ -1638,7 +1715,7 @@ template<typename... Component>
Returns
References to the components owned by the entity.
-

Definition at line 788 of file registry.hpp.

+

Definition at line 833 of file registry.hpp.

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

Definition at line 624 of file registry.hpp.

+

Definition at line 669 of file registry.hpp.

@@ -1722,7 +1799,7 @@ template<typename Tag >

Checks if an entity owns the given tag.

Syntactic sugar for the following snippet:

-
registry.has<Tag>() && registry.attachee<Tag>() == entity
Template Parameters
+
registry.has<Tag>() && registry.attachee<Tag>() == entity
Template Parameters
TagType of tag for which to perform the check.
@@ -1736,7 +1813,7 @@ template<typename Tag >
Returns
True if the entity owns the tag, false otherwise.
-

Definition at line 651 of file registry.hpp.

+

Definition at line 696 of file registry.hpp.

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

Definition at line 668 of file registry.hpp.

+

Definition at line 713 of file registry.hpp.

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

Definition at line 857 of file registry.hpp.

+

Definition at line 902 of file registry.hpp.

@@ -1937,7 +2014,7 @@ template<typename Entity>
Returns
True if the entity is an orphan, false otherwise.
-

Definition at line 1231 of file registry.hpp.

+

Definition at line 1276 of file registry.hpp.

@@ -1986,7 +2063,7 @@ template<typename Func > -

Definition at line 1265 of file registry.hpp.

+

Definition at line 1310 of file registry.hpp.

@@ -2028,7 +2105,7 @@ template<typename... Component> -

Definition at line 1329 of file registry.hpp.

+

Definition at line 1374 of file registry.hpp.

@@ -2070,7 +2147,7 @@ template<typename Component >
Returns
A pointer to the array of components of the given type.
-

Definition at line 278 of file registry.hpp.

+

Definition at line 315 of file registry.hpp.

@@ -2112,7 +2189,7 @@ template<typename Component >
Returns
A pointer to the array of components of the given type.
-

Definition at line 297 of file registry.hpp.

+

Definition at line 334 of file registry.hpp.

@@ -2151,7 +2228,7 @@ template<typename Tag > -

Definition at line 587 of file registry.hpp.

+

Definition at line 632 of file registry.hpp.

@@ -2199,7 +2276,7 @@ template<typename Component > -

Definition at line 610 of file registry.hpp.

+

Definition at line 655 of file registry.hpp.

@@ -2260,7 +2337,7 @@ template<typename Tag , typename... Args>
Returns
A reference to the tag.
-

Definition at line 811 of file registry.hpp.

+

Definition at line 856 of file registry.hpp.

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

Definition at line 836 of file registry.hpp.

+

Definition at line 881 of file registry.hpp.

@@ -2369,7 +2446,7 @@ template<typename Component > -

Definition at line 208 of file registry.hpp.

+

Definition at line 245 of file registry.hpp.

@@ -2408,7 +2485,7 @@ template<typename Entity> -

Definition at line 221 of file registry.hpp.

+

Definition at line 258 of file registry.hpp.

@@ -2457,7 +2534,7 @@ template<typename Component > -

Definition at line 1135 of file registry.hpp.

+

Definition at line 1180 of file registry.hpp.

@@ -2497,7 +2574,7 @@ template<typename Component > -

Definition at line 1156 of file registry.hpp.

+

Definition at line 1201 of file registry.hpp.

@@ -2529,7 +2606,7 @@ template<typename Entity>

Resets a whole registry.

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

-

Definition at line 1176 of file registry.hpp.

+

Definition at line 1221 of file registry.hpp.

@@ -2564,7 +2641,7 @@ template<typename Entity>
Warning
The loader returned by this function requires that the registry be empty. In case it isn't, all the data will be automatically deleted before to return.
Returns
A temporary object to use to load snasphosts.
-

Definition at line 1555 of file registry.hpp.

+

Definition at line 1580 of file registry.hpp.

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

Definition at line 186 of file registry.hpp.

+

Definition at line 215 of file registry.hpp.

@@ -2633,10 +2710,10 @@ template<typename Entity>
-

Returns the number of entities still in use.

-
Returns
Number of entities still in use.
+

Returns the number of entities created so far.

+
Returns
Number of entities created so far.
-

Definition at line 194 of file registry.hpp.

+

Definition at line 223 of file registry.hpp.

@@ -2670,7 +2747,7 @@ template<typename Entity> It can be used to save and restore its internal state or to keep two or more instances of this class in sync, as an example in a client-server architecture.

Returns
A temporary object to use to take snasphosts.
-

Definition at line 1526 of file registry.hpp.

+

Definition at line 1551 of file registry.hpp.

@@ -2748,7 +2825,7 @@ template<typename Component , typename Compare , typename Sort = StdSort, ty -

Definition at line 1078 of file registry.hpp.

+

Definition at line 1123 of file registry.hpp.

@@ -2797,7 +2874,7 @@ template<typename To , typename From > -

Definition at line 1114 of file registry.hpp.

+

Definition at line 1159 of file registry.hpp.

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

Definition at line 159 of file registry.hpp.

+

Definition at line 188 of file registry.hpp.

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

Definition at line 176 of file registry.hpp.

+

Definition at line 205 of file registry.hpp.

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

Definition at line 325 of file registry.hpp.

+

Definition at line 362 of file registry.hpp.

@@ -2958,9 +3035,9 @@ template<typename Entity> -
Returns
Version stored along with the given entity identifier.
+
Returns
The version stored along with the given entity identifier.
-

Definition at line 358 of file registry.hpp.

+

Definition at line 404 of file registry.hpp.

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

Definition at line 1308 of file registry.hpp.

+

Definition at line 1353 of file registry.hpp.

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

Definition at line 1443 of file registry.hpp.

+

Definition at line 1468 of file registry.hpp.

@@ -3134,7 +3211,7 @@ template<typename Component >
Returns
A newly created raw view.
-

Definition at line 1473 of file registry.hpp.

+

Definition at line 1498 of file registry.hpp.

@@ -3206,7 +3283,7 @@ template<typename It >
Returns
A newly created runtime view.
-

Definition at line 1505 of file registry.hpp.

+

Definition at line 1530 of file registry.hpp.

diff --git a/classentt_1_1ResourceCache-members.html b/classentt_1_1ResourceCache-members.html index 322c21226..645183e45 100644 --- a/classentt_1_1ResourceCache-members.html +++ b/classentt_1_1ResourceCache-members.html @@ -5,7 +5,7 @@ -entt: Member List +EnTT: Member List @@ -21,8 +21,8 @@ -
entt -  2.7.1 +
EnTT +  2.7.2
diff --git a/classentt_1_1ResourceCache.html b/classentt_1_1ResourceCache.html index e630535c8..683ae7c31 100644 --- a/classentt_1_1ResourceCache.html +++ b/classentt_1_1ResourceCache.html @@ -5,7 +5,7 @@ -entt: entt::ResourceCache< Resource > Class Template Reference +EnTT: entt::ResourceCache< Resource > Class Template Reference @@ -21,8 +21,8 @@ -
entt -  2.7.1 +
EnTT +  2.7.2
diff --git a/classentt_1_1ResourceHandle-members.html b/classentt_1_1ResourceHandle-members.html index f439b71b0..3c7052a34 100644 --- a/classentt_1_1ResourceHandle-members.html +++ b/classentt_1_1ResourceHandle-members.html @@ -5,7 +5,7 @@ -entt: Member List +EnTT: Member List @@ -21,8 +21,8 @@ -
entt -  2.7.1 +
EnTT +  2.7.2
diff --git a/classentt_1_1ResourceHandle.html b/classentt_1_1ResourceHandle.html index 8b66bea93..76b9a4517 100644 --- a/classentt_1_1ResourceHandle.html +++ b/classentt_1_1ResourceHandle.html @@ -5,7 +5,7 @@ -entt: entt::ResourceHandle< Resource > Class Template Reference +EnTT: entt::ResourceHandle< Resource > Class Template Reference @@ -21,8 +21,8 @@ -
entt -  2.7.1 +
EnTT +  2.7.2
diff --git a/classentt_1_1ResourceLoader-members.html b/classentt_1_1ResourceLoader-members.html index 6a9460ece..42f83681f 100644 --- a/classentt_1_1ResourceLoader-members.html +++ b/classentt_1_1ResourceLoader-members.html @@ -5,7 +5,7 @@ -entt: Member List +EnTT: Member List @@ -21,8 +21,8 @@ -
entt -  2.7.1 +
EnTT +  2.7.2
diff --git a/classentt_1_1ResourceLoader.html b/classentt_1_1ResourceLoader.html index 64e48db1a..c9902ed0a 100644 --- a/classentt_1_1ResourceLoader.html +++ b/classentt_1_1ResourceLoader.html @@ -5,7 +5,7 @@ -entt: entt::ResourceLoader< Loader, Resource > Class Template Reference +EnTT: entt::ResourceLoader< Loader, Resource > Class Template Reference @@ -21,8 +21,8 @@ -
entt -  2.7.1 +
EnTT +  2.7.2
diff --git a/classentt_1_1RuntimeView-members.html b/classentt_1_1RuntimeView-members.html index acbb9acff..e87fda638 100644 --- a/classentt_1_1RuntimeView-members.html +++ b/classentt_1_1RuntimeView-members.html @@ -5,7 +5,7 @@ -entt: Member List +EnTT: Member List @@ -21,8 +21,8 @@ -
entt -  2.7.1 +
EnTT +  2.7.2
diff --git a/classentt_1_1RuntimeView.html b/classentt_1_1RuntimeView.html index 4451a7016..d98051185 100644 --- a/classentt_1_1RuntimeView.html +++ b/classentt_1_1RuntimeView.html @@ -5,7 +5,7 @@ -entt: entt::RuntimeView< Entity > Class Template Reference +EnTT: entt::RuntimeView< Entity > Class Template Reference @@ -21,8 +21,8 @@ -
entt -  2.7.1 +
EnTT +  2.7.2
@@ -169,7 +169,7 @@ class entt::RuntimeView< Entity > -

Definition at line 1595 of file view.hpp.

+

Definition at line 1590 of file view.hpp.

Member Function Documentation

◆ begin() [1/2]

@@ -201,7 +201,7 @@ template<typename Entity >
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 1769 of file view.hpp.

+

Definition at line 1764 of file view.hpp.

@@ -235,7 +235,7 @@ template<typename Entity >
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 1787 of file view.hpp.

+

Definition at line 1782 of file view.hpp.

@@ -269,7 +269,7 @@ template<typename Entity >
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 1743 of file view.hpp.

+

Definition at line 1738 of file view.hpp.

@@ -303,7 +303,7 @@ template<typename Entity >
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 1806 of file view.hpp.

+

Definition at line 1801 of file view.hpp.

@@ -342,7 +342,7 @@ template<typename Entity >
Returns
True if the view contains the given entity, false otherwise.
-

Definition at line 1860 of file view.hpp.

+

Definition at line 1855 of file view.hpp.

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

Definition at line 1882 of file view.hpp.

+

Definition at line 1877 of file view.hpp.

@@ -422,7 +422,7 @@ template<typename Entity >

Checks if the view is definitely empty.

Returns
True if the view is definitely empty, false otherwise.
-

Definition at line 1725 of file view.hpp.

+

Definition at line 1720 of file view.hpp.

@@ -456,7 +456,7 @@ template<typename Entity >
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 1832 of file view.hpp.

+

Definition at line 1827 of file view.hpp.

@@ -490,7 +490,7 @@ template<typename Entity >
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 1851 of file view.hpp.

+

Definition at line 1846 of file view.hpp.

@@ -522,7 +522,7 @@ template<typename Entity >

Estimates the number of entities that have the given components.

Returns
Estimated number of entities that have the given components.
-

Definition at line 1717 of file view.hpp.

+

Definition at line 1712 of file view.hpp.

diff --git a/classentt_1_1Scheduler-members.html b/classentt_1_1Scheduler-members.html index 3a91079bb..47b8bf888 100644 --- a/classentt_1_1Scheduler-members.html +++ b/classentt_1_1Scheduler-members.html @@ -5,7 +5,7 @@ -entt: Member List +EnTT: Member List @@ -21,8 +21,8 @@ -
entt -  2.7.1 +
EnTT +  2.7.2
diff --git a/classentt_1_1Scheduler.html b/classentt_1_1Scheduler.html index a1e84145e..eb2f2b44e 100644 --- a/classentt_1_1Scheduler.html +++ b/classentt_1_1Scheduler.html @@ -5,7 +5,7 @@ -entt: entt::Scheduler< Delta > Class Template Reference +EnTT: entt::Scheduler< Delta > Class Template Reference @@ -21,8 +21,8 @@ -
entt -  2.7.1 +
EnTT +  2.7.2
diff --git a/classentt_1_1SigH.html b/classentt_1_1SigH.html index ffd0fc021..77bf951df 100644 --- a/classentt_1_1SigH.html +++ b/classentt_1_1SigH.html @@ -5,7 +5,7 @@ -entt: entt::SigH< Function, Collector > Class Template Reference +EnTT: entt::SigH< Function, Collector > Class Template Reference @@ -21,8 +21,8 @@ -
entt -  2.7.1 +
EnTT +  2.7.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 9f452b4cb..f8b64fcec 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 @@ -5,7 +5,7 @@ -entt: Member List +EnTT: Member List @@ -21,8 +21,8 @@ -
entt -  2.7.1 +
EnTT +  2.7.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 44c45ad03..ec633f7dc 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 @@ -5,7 +5,7 @@ -entt: entt::SigH< Ret(Args...), Collector > Class Template Reference +EnTT: entt::SigH< Ret(Args...), Collector > Class Template Reference @@ -21,8 +21,8 @@ -
entt -  2.7.1 +
EnTT +  2.7.2
@@ -81,15 +81,11 @@ $(function() { Inheritance diagram for entt::SigH< Ret(Args...), Collector >:
Inheritance graph
- -
[legend]
Collaboration diagram for entt::SigH< Ret(Args...), Collector >:
Collaboration graph
- -
[legend]
diff --git a/classentt_1_1Sink_3_01Ret_07Args_8_8_8_08_4-members.html b/classentt_1_1Sink_3_01Ret_07Args_8_8_8_08_4-members.html index a6e1082dd..14e2881e3 100644 --- a/classentt_1_1Sink_3_01Ret_07Args_8_8_8_08_4-members.html +++ b/classentt_1_1Sink_3_01Ret_07Args_8_8_8_08_4-members.html @@ -5,7 +5,7 @@ -entt: Member List +EnTT: Member List @@ -21,8 +21,8 @@ diff --git a/classentt_1_1Sink_3_01Ret_07Args_8_8_8_08_4.html b/classentt_1_1Sink_3_01Ret_07Args_8_8_8_08_4.html index 5cdcc906a..0f77fdf52 100644 --- a/classentt_1_1Sink_3_01Ret_07Args_8_8_8_08_4.html +++ b/classentt_1_1Sink_3_01Ret_07Args_8_8_8_08_4.html @@ -5,7 +5,7 @@ -entt: entt::Sink< Ret(Args...)> Class Template Reference +EnTT: entt::Sink< Ret(Args...)> Class Template Reference @@ -21,8 +21,8 @@ diff --git a/classentt_1_1Snapshot-members.html b/classentt_1_1Snapshot-members.html index c7777899e..ea716314b 100644 --- a/classentt_1_1Snapshot-members.html +++ b/classentt_1_1Snapshot-members.html @@ -5,7 +5,7 @@ -entt: Member List +EnTT: Member List @@ -21,8 +21,8 @@ diff --git a/classentt_1_1Snapshot.html b/classentt_1_1Snapshot.html index 5349ab086..4badf5c8b 100644 --- a/classentt_1_1Snapshot.html +++ b/classentt_1_1Snapshot.html @@ -5,7 +5,7 @@ -entt: entt::Snapshot< Entity > Class Template Reference +EnTT: entt::Snapshot< Entity > Class Template Reference @@ -21,8 +21,8 @@ diff --git a/classentt_1_1SnapshotLoader-members.html b/classentt_1_1SnapshotLoader-members.html index 05c53f3a1..644479de6 100644 --- a/classentt_1_1SnapshotLoader-members.html +++ b/classentt_1_1SnapshotLoader-members.html @@ -5,7 +5,7 @@ -entt: Member List +EnTT: Member List @@ -21,8 +21,8 @@ diff --git a/classentt_1_1SnapshotLoader.html b/classentt_1_1SnapshotLoader.html index 0dac6e300..3b5998c4e 100644 --- a/classentt_1_1SnapshotLoader.html +++ b/classentt_1_1SnapshotLoader.html @@ -5,7 +5,7 @@ -entt: entt::SnapshotLoader< Entity > Class Template Reference +EnTT: entt::SnapshotLoader< Entity > Class Template Reference @@ -21,8 +21,8 @@ diff --git a/classentt_1_1SparseSet.html b/classentt_1_1SparseSet.html index 12d4972b4..6175a3020 100644 --- a/classentt_1_1SparseSet.html +++ b/classentt_1_1SparseSet.html @@ -5,7 +5,7 @@ -entt: entt::SparseSet<... > Class Template Reference +EnTT: entt::SparseSet<... > Class Template Reference @@ -21,8 +21,8 @@ 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 7f96afe27..ac42f045f 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 @@ -5,7 +5,7 @@ -entt: Member List +EnTT: Member List @@ -21,8 +21,8 @@ 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 2b0abebd0..b1aa374bb 100644 --- a/classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html +++ b/classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html @@ -5,7 +5,7 @@ -entt: entt::SparseSet< Entity, Type > Class Template Reference +EnTT: entt::SparseSet< Entity, Type > Class Template Reference @@ -21,8 +21,8 @@ diff --git a/classentt_1_1SparseSet_3_01Entity_01_4-members.html b/classentt_1_1SparseSet_3_01Entity_01_4-members.html index 20c29b190..870d7297b 100644 --- a/classentt_1_1SparseSet_3_01Entity_01_4-members.html +++ b/classentt_1_1SparseSet_3_01Entity_01_4-members.html @@ -5,7 +5,7 @@ -entt: Member List +EnTT: Member List @@ -21,8 +21,8 @@ diff --git a/classentt_1_1SparseSet_3_01Entity_01_4.html b/classentt_1_1SparseSet_3_01Entity_01_4.html index 12497d901..52d17d155 100644 --- a/classentt_1_1SparseSet_3_01Entity_01_4.html +++ b/classentt_1_1SparseSet_3_01Entity_01_4.html @@ -5,7 +5,7 @@ -entt: entt::SparseSet< Entity > Class Template Reference +EnTT: entt::SparseSet< Entity > Class Template Reference @@ -21,8 +21,8 @@ diff --git a/classentt_1_1View-members.html b/classentt_1_1View-members.html index f8efa9a6a..9b0f3cd11 100644 --- a/classentt_1_1View-members.html +++ b/classentt_1_1View-members.html @@ -5,7 +5,7 @@ -entt: Member List +EnTT: Member List @@ -21,8 +21,8 @@ diff --git a/classentt_1_1View.html b/classentt_1_1View.html index 1c0d15983..01720714a 100644 --- a/classentt_1_1View.html +++ b/classentt_1_1View.html @@ -5,7 +5,7 @@ -entt: entt::View< Entity, Component > Class Template Reference +EnTT: entt::View< Entity, Component > Class Template Reference @@ -21,8 +21,8 @@ @@ -222,7 +222,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 681 of file view.hpp.

+

Definition at line 676 of file view.hpp.

@@ -256,7 +256,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 699 of file view.hpp.

+

Definition at line 694 of file view.hpp.

@@ -290,7 +290,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 662 of file view.hpp.

+

Definition at line 657 of file view.hpp.

@@ -324,7 +324,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 components.
-

Definition at line 718 of file view.hpp.

+

Definition at line 713 of file view.hpp.

@@ -363,7 +363,7 @@ template<typename Entity , typename... Component>
Returns
True if the view contains the given entity, false otherwise.
-

Definition at line 766 of file view.hpp.

+

Definition at line 761 of file view.hpp.

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

Definition at line 882 of file view.hpp.

+

Definition at line 877 of file view.hpp.

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

Definition at line 906 of file view.hpp.

+

Definition at line 901 of file view.hpp.

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

Checks if the view is definitely empty.

Returns
True if the view is definitely empty, false otherwise.
-

Definition at line 644 of file view.hpp.

+

Definition at line 639 of file view.hpp.

@@ -525,7 +525,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 components.
-

Definition at line 738 of file view.hpp.

+

Definition at line 733 of file view.hpp.

@@ -559,7 +559,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 components.
-

Definition at line 757 of file view.hpp.

+

Definition at line 752 of file view.hpp.

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

Definition at line 790 of file view.hpp.

+

Definition at line 785 of file view.hpp.

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

Definition at line 813 of file view.hpp.

+

Definition at line 808 of file view.hpp.

@@ -709,7 +709,7 @@ template<typename... Comp>
Returns
The components assigned to the entity.
-

Definition at line 836 of file view.hpp.

+

Definition at line 831 of file view.hpp.

@@ -759,7 +759,7 @@ template<typename... Comp>
Returns
The components assigned to the entity.
-

Definition at line 860 of file view.hpp.

+

Definition at line 855 of file view.hpp.

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

Estimates the number of entities that have the given components.

Returns
Estimated number of entities that have the given components.
-

Definition at line 636 of file view.hpp.

+

Definition at line 631 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 65d898d42..c39ebdb07 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 @@ -5,7 +5,7 @@ -entt: Member List +EnTT: Member List @@ -21,8 +21,8 @@ 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 ff58066e9..9d7c6f954 100644 --- a/classentt_1_1View_3_01Entity_00_01Component_01_4.html +++ b/classentt_1_1View_3_01Entity_00_01Component_01_4.html @@ -5,7 +5,7 @@ -entt: entt::View< Entity, Component > Class Template Reference +EnTT: entt::View< Entity, Component > Class Template Reference @@ -21,8 +21,8 @@ @@ -195,7 +195,7 @@ class entt::View< Entity, Component > -

Definition at line 956 of file view.hpp.

+

Definition at line 951 of file view.hpp.

Member Function Documentation

◆ begin() [1/2]

@@ -227,7 +227,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 1075 of file view.hpp.

+

Definition at line 1070 of file view.hpp.

@@ -261,7 +261,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 1093 of file view.hpp.

+

Definition at line 1088 of file view.hpp.

@@ -295,7 +295,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 1057 of file view.hpp.

+

Definition at line 1052 of file view.hpp.

@@ -329,7 +329,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 1112 of file view.hpp.

+

Definition at line 1107 of file view.hpp.

@@ -368,7 +368,7 @@ template<typename Entity , typename Component >
Returns
True if the view contains the given entity, false otherwise.
-

Definition at line 1168 of file view.hpp.

+

Definition at line 1163 of file view.hpp.

@@ -402,7 +402,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 1039 of file view.hpp.

+

Definition at line 1034 of file view.hpp.

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

Definition at line 1227 of file view.hpp.

+

Definition at line 1222 of file view.hpp.

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

Definition at line 1249 of file view.hpp.

+

Definition at line 1244 of file view.hpp.

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

Checks whether the view is empty.

Returns
True if the view is empty, false otherwise.
-

Definition at line 991 of file view.hpp.

+

Definition at line 986 of file view.hpp.

@@ -564,7 +564,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 1131 of file view.hpp.

+

Definition at line 1126 of file view.hpp.

@@ -598,7 +598,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 1150 of file view.hpp.

+

Definition at line 1145 of file view.hpp.

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

Definition at line 1187 of file view.hpp.

+

Definition at line 1182 of file view.hpp.

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

Definition at line 1207 of file view.hpp.

+

Definition at line 1202 of file view.hpp.

@@ -721,7 +721,7 @@ template<typename Entity , typename Component >
Returns
A reference to the requested element.
-

Definition at line 1159 of file view.hpp.

+

Definition at line 1154 of file view.hpp.

@@ -755,7 +755,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 1007 of file view.hpp.

+

Definition at line 1002 of file view.hpp.

@@ -789,7 +789,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 1023 of file view.hpp.

+

Definition at line 1018 of file view.hpp.

@@ -821,7 +821,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 983 of file view.hpp.

+

Definition at line 978 of file view.hpp.

diff --git a/classes.html b/classes.html index 8b173fdc5..0245a9c47 100644 --- a/classes.html +++ b/classes.html @@ -5,7 +5,7 @@ -entt: Class Index +EnTT: Class Index @@ -21,8 +21,8 @@ @@ -63,41 +63,43 @@ $(function() {
Class Index
-
a | b | c | d | e | f | h | i | m | p | r | s | t | v
+
a | b | c | d | e | f | h | i | m | o | p | r | s | t | v

diff --git a/classentt_1_1Sink.html b/classentt_1_1Sink.html index 19a546db3..d95cb426e 100644 --- a/classentt_1_1Sink.html +++ b/classentt_1_1Sink.html @@ -5,7 +5,7 @@ -entt: entt::Sink< Function > Class Template Reference +EnTT: entt::Sink< Function > Class Template Reference @@ -21,8 +21,8 @@

-
entt -  2.7.1 +
EnTT +  2.7.2
-
entt -  2.7.1 +
EnTT +  2.7.2
-
entt -  2.7.1 +
EnTT +  2.7.2
-
entt -  2.7.1 +
EnTT +  2.7.2
-
entt -  2.7.1 +
EnTT +  2.7.2
-
entt -  2.7.1 +
EnTT +  2.7.2
-
entt -  2.7.1 +
EnTT +  2.7.2
-
entt -  2.7.1 +
EnTT +  2.7.2
-
entt -  2.7.1 +
EnTT +  2.7.2
-
entt -  2.7.1 +
EnTT +  2.7.2
-
entt -  2.7.1 +
EnTT +  2.7.2
-
entt -  2.7.1 +
EnTT +  2.7.2
-
entt -  2.7.1 +
EnTT +  2.7.2
-
entt -  2.7.1 +
EnTT +  2.7.2
-
entt -  2.7.1 +
EnTT +  2.7.2
-
entt -  2.7.1 +
EnTT +  2.7.2
-
entt -  2.7.1 +
EnTT +  2.7.2
+ - + + - - + + - - - + + + - - + + + - - + + + +
  a  
  e  
-		InsertionSort (entt)   Registry (entt)   SparseSet (entt)   
InsertionSort (entt)   RawView (entt)   SnapshotLoader (entt)   
  m  
-		ResourceCache (entt)   SparseSet< Entity > (entt)   
Actor (entt)   Emitter (entt)   ResourceHandle (entt)   SparseSet< Entity, Type > (entt)   
Registry (entt)   SparseSet (entt)   
Actor (entt)   Emitter (entt)   ResourceCache (entt)   SparseSet< Entity > (entt)   
  b  
-		entt_traits (entt)   Monostate (entt)   ResourceLoader (entt)   StdSort (entt)   
entt_traits< std::uint16_t > (entt)   
  p  
-		RuntimeView (entt)   
  t  
-
break_t (entt)   entt_traits< std::uint32_t > (entt)   
  s  
+		entt_traits (entt)   Monostate (entt)   ResourceHandle (entt)   SparseSet< Entity, Type > (entt)   
entt_traits< std::uint16_t > (entt)   
  o  
+		ResourceLoader (entt)   StdSort (entt)   
break_t (entt)   entt_traits< std::uint32_t > (entt)   RuntimeView (entt)   
  t  
  c  
-		entt_traits< std::uint64_t > (entt)   persistent_t (entt)   tag_t (entt)   
  f  
-		PersistentView (entt)   Scheduler (entt)   
  v  
+		entt_traits< std::uint64_t > (entt)   OneShotBubbleSort (entt)   
  s  
Emitter::Connection (entt)   Process (entt)   ServiceLocator (entt)   
ContinuousLoader (entt)   Family (entt)   ProcessAdaptor (entt)   SigH (entt)   View (entt)   
  f  
+
  p  
+		tag_t (entt)   
Emitter::Connection (entt)   Scheduler (entt)   
  v  
+
ContinuousLoader (entt)   Family (entt)   persistent_t (entt)   ServiceLocator (entt)   
  d  
  h  
-		Prototype (entt)   SigH< Ret(Args...), Collector > (entt)   View< Entity, Component > (entt)   
  r  
-		Sink (entt)   
Delegate (entt)   HashedString (entt)   Sink< Ret(Args...)> (entt)   
PersistentView (entt)   SigH (entt)   View (entt)   
Process (entt)   SigH< Ret(Args...), Collector > (entt)   View< Entity, Component > (entt)   
Delegate (entt)   HashedString (entt)   ProcessAdaptor (entt)   Sink (entt)   
Delegate< Ret(Args...)> (entt)   
  i  
-		raw_t (entt)   Snapshot (entt)   
Dispatcher (entt)   RawView (entt)   SnapshotLoader (entt)   
Identifier (entt)   
Prototype (entt)   Sink< Ret(Args...)> (entt)   
Dispatcher (entt)   
  r  
+		Snapshot (entt)   
Identifier (entt)   
raw_t (entt)   
-
a | b | c | d | e | f | h | i | m | p | r | s | t | v
+
a | b | c | d | e | f | h | i | m | o | p | r | s | t | v
diff --git a/config_8h_source.html b/config_8h_source.html index a03aa083d..0dc3705d9 100644 --- a/config_8h_source.html +++ b/config_8h_source.html @@ -5,7 +5,7 @@ -entt: src/entt/config/config.h Source File +EnTT: src/entt/config/config.h Source File @@ -21,8 +21,8 @@ -
entt -  2.7.1 +
EnTT +  2.7.2
diff --git a/delegate_8hpp_source.html b/delegate_8hpp_source.html index 294659d7f..b318a50e0 100644 --- a/delegate_8hpp_source.html +++ b/delegate_8hpp_source.html @@ -5,7 +5,7 @@ -entt: src/entt/signal/delegate.hpp Source File +EnTT: src/entt/signal/delegate.hpp Source File @@ -21,8 +21,8 @@ -
entt -  2.7.1 +
EnTT +  2.7.2
diff --git a/dir_66e9674e8206a335795995fa32a03c91.html b/dir_66e9674e8206a335795995fa32a03c91.html index 4dfa8ac20..5149c4bc7 100644 --- a/dir_66e9674e8206a335795995fa32a03c91.html +++ b/dir_66e9674e8206a335795995fa32a03c91.html @@ -5,7 +5,7 @@ -entt: src/entt Directory Reference +EnTT: src/entt Directory Reference @@ -21,8 +21,8 @@ -
entt -  2.7.1 +
EnTT +  2.7.2
diff --git a/dir_68267d1309a1af8e8297ef4c3efbcdba.html b/dir_68267d1309a1af8e8297ef4c3efbcdba.html index 095f6e853..b37549885 100644 --- a/dir_68267d1309a1af8e8297ef4c3efbcdba.html +++ b/dir_68267d1309a1af8e8297ef4c3efbcdba.html @@ -5,7 +5,7 @@ -entt: src Directory Reference +EnTT: src Directory Reference @@ -21,8 +21,8 @@ -
entt -  2.7.1 +
EnTT +  2.7.2
diff --git a/dir_721f6154dba3c88bcdead5f446bce319.html b/dir_721f6154dba3c88bcdead5f446bce319.html index 5f1910702..47e5be0d4 100644 --- a/dir_721f6154dba3c88bcdead5f446bce319.html +++ b/dir_721f6154dba3c88bcdead5f446bce319.html @@ -5,7 +5,7 @@ -entt: src/entt/process Directory Reference +EnTT: src/entt/process Directory Reference @@ -21,8 +21,8 @@ -
entt -  2.7.1 +
EnTT +  2.7.2
diff --git a/dir_7929ab29d3f740cf727ccbd263321562.html b/dir_7929ab29d3f740cf727ccbd263321562.html index 609bed10a..54a1d5f2b 100644 --- a/dir_7929ab29d3f740cf727ccbd263321562.html +++ b/dir_7929ab29d3f740cf727ccbd263321562.html @@ -5,7 +5,7 @@ -entt: src/entt/config Directory Reference +EnTT: src/entt/config Directory Reference @@ -21,8 +21,8 @@ -
entt -  2.7.1 +
EnTT +  2.7.2
diff --git a/dir_85dbee8884f1b3a817fa7eff8dff73ec.html b/dir_85dbee8884f1b3a817fa7eff8dff73ec.html index 4b2aa84b7..103c296cc 100644 --- a/dir_85dbee8884f1b3a817fa7eff8dff73ec.html +++ b/dir_85dbee8884f1b3a817fa7eff8dff73ec.html @@ -5,7 +5,7 @@ -entt: src/entt/resource Directory Reference +EnTT: src/entt/resource Directory Reference @@ -21,8 +21,8 @@ -
entt -  2.7.1 +
EnTT +  2.7.2
diff --git a/dir_a53318306f6ac0f7fe657839abd543ab.html b/dir_a53318306f6ac0f7fe657839abd543ab.html index 0fae6017f..31f61cc6f 100644 --- a/dir_a53318306f6ac0f7fe657839abd543ab.html +++ b/dir_a53318306f6ac0f7fe657839abd543ab.html @@ -5,7 +5,7 @@ -entt: src/entt/signal Directory Reference +EnTT: src/entt/signal Directory Reference @@ -21,8 +21,8 @@ -
entt -  2.7.1 +
EnTT +  2.7.2
diff --git a/dir_b64489a1e8130d5ebf6d86d282f500f0.html b/dir_b64489a1e8130d5ebf6d86d282f500f0.html index 18255661a..063a9b628 100644 --- a/dir_b64489a1e8130d5ebf6d86d282f500f0.html +++ b/dir_b64489a1e8130d5ebf6d86d282f500f0.html @@ -5,7 +5,7 @@ -entt: src/entt/locator Directory Reference +EnTT: src/entt/locator Directory Reference @@ -21,8 +21,8 @@ -
entt -  2.7.1 +
EnTT +  2.7.2
diff --git a/dir_de8f4e6ba3f54a2a21309f742e93a373.html b/dir_de8f4e6ba3f54a2a21309f742e93a373.html index 9d5de3645..2d5eac20a 100644 --- a/dir_de8f4e6ba3f54a2a21309f742e93a373.html +++ b/dir_de8f4e6ba3f54a2a21309f742e93a373.html @@ -5,7 +5,7 @@ -entt: src/entt/core Directory Reference +EnTT: src/entt/core Directory Reference @@ -21,8 +21,8 @@ -
entt -  2.7.1 +
EnTT +  2.7.2
diff --git a/dir_e3a7bb56c55e5c2286e2fe96e197d4f5.html b/dir_e3a7bb56c55e5c2286e2fe96e197d4f5.html index 85f309eaf..414855302 100644 --- a/dir_e3a7bb56c55e5c2286e2fe96e197d4f5.html +++ b/dir_e3a7bb56c55e5c2286e2fe96e197d4f5.html @@ -5,7 +5,7 @@ -entt: src/entt/entity Directory Reference +EnTT: src/entt/entity Directory Reference @@ -21,8 +21,8 @@ -
entt -  2.7.1 +
EnTT +  2.7.2
diff --git a/dispatcher_8hpp_source.html b/dispatcher_8hpp_source.html index fd9902c34..7992a04d3 100644 --- a/dispatcher_8hpp_source.html +++ b/dispatcher_8hpp_source.html @@ -5,7 +5,7 @@ -entt: src/entt/signal/dispatcher.hpp Source File +EnTT: src/entt/signal/dispatcher.hpp Source File @@ -21,8 +21,8 @@ -
entt -  2.7.1 +
EnTT +  2.7.2
diff --git a/emitter_8hpp_source.html b/emitter_8hpp_source.html index 7916f82fe..96106a58e 100644 --- a/emitter_8hpp_source.html +++ b/emitter_8hpp_source.html @@ -5,7 +5,7 @@ -entt: src/entt/signal/emitter.hpp Source File +EnTT: src/entt/signal/emitter.hpp Source File @@ -21,8 +21,8 @@ -
entt -  2.7.1 +
EnTT +  2.7.2
diff --git a/entity_8hpp_source.html b/entity_8hpp_source.html index 78c27ae7e..160e27518 100644 --- a/entity_8hpp_source.html +++ b/entity_8hpp_source.html @@ -5,7 +5,7 @@ -entt: src/entt/entity/entity.hpp Source File +EnTT: src/entt/entity/entity.hpp Source File @@ -21,8 +21,8 @@ -
entt -  2.7.1 +
EnTT +  2.7.2
diff --git a/entt_8hpp_source.html b/entt_8hpp_source.html index 52b9c0f20..ae75251fb 100644 --- a/entt_8hpp_source.html +++ b/entt_8hpp_source.html @@ -5,7 +5,7 @@ -entt: src/entt/entt.hpp Source File +EnTT: src/entt/entt.hpp Source File @@ -21,8 +21,8 @@ -
entt -  2.7.1 +
EnTT +  2.7.2
diff --git a/entt__traits_8hpp_source.html b/entt__traits_8hpp_source.html index 41738c1c8..2368b9db1 100644 --- a/entt__traits_8hpp_source.html +++ b/entt__traits_8hpp_source.html @@ -5,7 +5,7 @@ -entt: src/entt/entity/entt_traits.hpp Source File +EnTT: src/entt/entity/entt_traits.hpp Source File @@ -21,8 +21,8 @@ -
entt -  2.7.1 +
EnTT +  2.7.2
diff --git a/family_8hpp_source.html b/family_8hpp_source.html index a3a254bc6..41befce38 100644 --- a/family_8hpp_source.html +++ b/family_8hpp_source.html @@ -5,7 +5,7 @@ -entt: src/entt/core/family.hpp Source File +EnTT: src/entt/core/family.hpp Source File @@ -21,8 +21,8 @@ -
entt -  2.7.1 +
EnTT +  2.7.2
diff --git a/files.html b/files.html index b27770e14..c47f3a91a 100644 --- a/files.html +++ b/files.html @@ -5,7 +5,7 @@ -entt: File List +EnTT: File List @@ -21,8 +21,8 @@ -
entt -  2.7.1 +
EnTT +  2.7.2
diff --git a/functions.html b/functions.html index 9c8d202d9..d95e9d205 100644 --- a/functions.html +++ b/functions.html @@ -5,7 +5,7 @@ -entt: Class Members +EnTT: Class Members @@ -21,8 +21,8 @@ -
entt -  2.7.1 +
EnTT +  2.7.2
@@ -75,9 +75,10 @@ $(function() {
  • alive() : entt::Process< Derived, Delta > +, entt::Registry< Entity >
  • assign() -: entt::Actor< Entity > +: entt::Actor< Entity > , entt::Prototype< Entity > , entt::Registry< Entity >
    • diff --git a/functions_0x7e.html b/functions_0x7e.html index 4719f12ac..c2e51b85e 100644 --- a/functions_0x7e.html +++ b/functions_0x7e.html @@ -5,7 +5,7 @@ -entt: Class Members +EnTT: Class Members @@ -21,8 +21,8 @@ -
    entt -  2.7.1 +
    EnTT +  2.7.2
    diff --git a/functions_b.html b/functions_b.html index abbfe49ac..02b4456a1 100644 --- a/functions_b.html +++ b/functions_b.html @@ -5,7 +5,7 @@ -entt: Class Members +EnTT: Class Members @@ -21,8 +21,8 @@ -
    entt -  2.7.1 +
    EnTT +  2.7.2
    diff --git a/functions_c.html b/functions_c.html index 1e545d0b7..81b575a62 100644 --- a/functions_c.html +++ b/functions_c.html @@ -5,7 +5,7 @@ -entt: Class Members +EnTT: Class Members @@ -21,8 +21,8 @@ -
    entt -  2.7.1 +
    EnTT +  2.7.2
    diff --git a/functions_d.html b/functions_d.html index 90a3b10b1..a345ba7bc 100644 --- a/functions_d.html +++ b/functions_d.html @@ -5,7 +5,7 @@ -entt: Class Members +EnTT: Class Members @@ -21,8 +21,8 @@ -
    entt -  2.7.1 +
    EnTT +  2.7.2
    diff --git a/functions_e.html b/functions_e.html index c2628390f..28de690af 100644 --- a/functions_e.html +++ b/functions_e.html @@ -5,7 +5,7 @@ -entt: Class Members +EnTT: Class Members @@ -21,8 +21,8 @@ -
    entt -  2.7.1 +
    EnTT +  2.7.2
    @@ -105,6 +105,7 @@ $(function() {
  • entity() : entt::Actor< Entity > +, entt::Registry< Entity >
  • entity_mask : entt::entt_traits< std::uint16_t > diff --git a/functions_f.html b/functions_f.html index 8b70410de..c1ba99d44 100644 --- a/functions_f.html +++ b/functions_f.html @@ -5,7 +5,7 @@ -entt: Class Members +EnTT: Class Members @@ -21,8 +21,8 @@ -
    entt -  2.7.1 +
    EnTT +  2.7.2
    diff --git a/functions_func.html b/functions_func.html index 89e2e7b2e..f6c079373 100644 --- a/functions_func.html +++ b/functions_func.html @@ -5,7 +5,7 @@ -entt: Class Members - Functions +EnTT: Class Members - Functions @@ -21,8 +21,8 @@ -
    entt -  2.7.1 +
    EnTT +  2.7.2
    @@ -75,9 +75,10 @@ $(function() {
  • alive() : entt::Process< Derived, Delta > +, entt::Registry< Entity >
  • assign() -: entt::Actor< Entity > +: entt::Actor< Entity > , entt::Prototype< Entity > , entt::Registry< Entity >
    • diff --git a/functions_func_0x7e.html b/functions_func_0x7e.html index 7e86f9771..d47b84fe2 100644 --- a/functions_func_0x7e.html +++ b/functions_func_0x7e.html @@ -5,7 +5,7 @@ -entt: Class Members - Functions +EnTT: Class Members - Functions @@ -21,8 +21,8 @@ -
    entt -  2.7.1 +
    EnTT +  2.7.2
    diff --git a/functions_func_b.html b/functions_func_b.html index 506035fdc..3d0cb0e0f 100644 --- a/functions_func_b.html +++ b/functions_func_b.html @@ -5,7 +5,7 @@ -entt: Class Members - Functions +EnTT: Class Members - Functions @@ -21,8 +21,8 @@ -
    entt -  2.7.1 +
    EnTT +  2.7.2
    diff --git a/functions_func_c.html b/functions_func_c.html index abaf9b4f3..eaf7c88cc 100644 --- a/functions_func_c.html +++ b/functions_func_c.html @@ -5,7 +5,7 @@ -entt: Class Members - Functions +EnTT: Class Members - Functions @@ -21,8 +21,8 @@ -
    entt -  2.7.1 +
    EnTT +  2.7.2
    diff --git a/functions_func_d.html b/functions_func_d.html index 068ebfed9..6ad836799 100644 --- a/functions_func_d.html +++ b/functions_func_d.html @@ -5,7 +5,7 @@ -entt: Class Members - Functions +EnTT: Class Members - Functions @@ -21,8 +21,8 @@ -
    entt -  2.7.1 +
    EnTT +  2.7.2
    diff --git a/functions_func_e.html b/functions_func_e.html index 812fe894e..98f83b777 100644 --- a/functions_func_e.html +++ b/functions_func_e.html @@ -5,7 +5,7 @@ -entt: Class Members - Functions +EnTT: Class Members - Functions @@ -21,8 +21,8 @@ -
    entt -  2.7.1 +
    EnTT +  2.7.2
    @@ -89,7 +89,7 @@ $(function() {
  • end() : entt::PersistentView< Entity, Component > , entt::RawView< Entity, Component > -, entt::RuntimeView< Entity > +, entt::RuntimeView< Entity > , entt::SparseSet< Entity > , entt::SparseSet< Entity, Type > , entt::View< Entity, Component > @@ -104,6 +104,7 @@ $(function() {
  • entity() : entt::Actor< Entity > +, entt::Registry< Entity >
  • erase() : entt::Emitter< Derived > diff --git a/functions_func_f.html b/functions_func_f.html index 7f253701b..0ecfea209 100644 --- a/functions_func_f.html +++ b/functions_func_f.html @@ -5,7 +5,7 @@ -entt: Class Members - Functions +EnTT: Class Members - Functions @@ -21,8 +21,8 @@ -
    entt -  2.7.1 +
    EnTT +  2.7.2
    diff --git a/functions_func_g.html b/functions_func_g.html index 74392ac11..8400e4910 100644 --- a/functions_func_g.html +++ b/functions_func_g.html @@ -5,7 +5,7 @@ -entt: Class Members - Functions +EnTT: Class Members - Functions @@ -21,8 +21,8 @@ -
    entt -  2.7.1 +
    EnTT +  2.7.2
    diff --git a/functions_func_h.html b/functions_func_h.html index 93c9a9617..bdc6a202d 100644 --- a/functions_func_h.html +++ b/functions_func_h.html @@ -5,7 +5,7 @@ -entt: Class Members - Functions +EnTT: Class Members - Functions @@ -21,8 +21,8 @@ -
    entt -  2.7.1 +
    EnTT +  2.7.2
    diff --git a/functions_func_l.html b/functions_func_l.html index 966825c2f..c7fb14c6f 100644 --- a/functions_func_l.html +++ b/functions_func_l.html @@ -5,7 +5,7 @@ -entt: Class Members - Functions +EnTT: Class Members - Functions @@ -21,8 +21,8 @@ -
    entt -  2.7.1 +
    EnTT +  2.7.2
    diff --git a/functions_func_m.html b/functions_func_m.html index f71bd60f0..6b20d3d22 100644 --- a/functions_func_m.html +++ b/functions_func_m.html @@ -5,7 +5,7 @@ -entt: Class Members - Functions +EnTT: Class Members - Functions @@ -21,8 +21,8 @@ -
    entt -  2.7.1 +
    EnTT +  2.7.2
    diff --git a/functions_func_o.html b/functions_func_o.html index 4dbd28b60..d1bbdd275 100644 --- a/functions_func_o.html +++ b/functions_func_o.html @@ -5,7 +5,7 @@ -entt: Class Members - Functions +EnTT: Class Members - Functions @@ -21,8 +21,8 @@ -
    entt -  2.7.1 +
    EnTT +  2.7.2
    @@ -86,6 +86,7 @@ $(function() {
  • operator()() : entt::Delegate< Ret(Args...)> , entt::InsertionSort +, entt::OneShotBubbleSort , entt::Prototype< Entity > , entt::StdSort
    • @@ -99,17 +100,17 @@ $(function() { : entt::Actor< Entity > , entt::ContinuousLoader< Entity > , entt::Emitter< Derived >::Connection< Event > -, entt::Emitter< Derived > +, entt::Emitter< Derived > , entt::Monostate< hash_type > -, entt::Prototype< Entity > +, entt::Prototype< Entity > , entt::Registry< Entity > -, entt::ResourceCache< Resource > -, entt::ResourceHandle< Resource > +, entt::ResourceCache< Resource > +, entt::ResourceHandle< Resource > , entt::Scheduler< Delta > , entt::Snapshot< Entity > -, entt::SnapshotLoader< Entity > -, entt::SparseSet< Entity > -, entt::SparseSet< Entity, Type > +, entt::SnapshotLoader< Entity > +, entt::SparseSet< Entity > +, entt::SparseSet< Entity, Type >
  • operator==() : entt::Delegate< Ret(Args...)> @@ -118,7 +119,7 @@ $(function() {
  • operator[]() : entt::PersistentView< Entity, Component > -, entt::RawView< Entity, Component > +, entt::RawView< Entity, Component > , entt::SparseSet< Entity > , entt::SparseSet< Entity, Type > , entt::View< Entity, Component > diff --git a/functions_func_p.html b/functions_func_p.html index 12bc091f2..71b72cea1 100644 --- a/functions_func_p.html +++ b/functions_func_p.html @@ -5,7 +5,7 @@ -entt: Class Members - Functions +EnTT: Class Members - Functions @@ -21,8 +21,8 @@ -
    entt -  2.7.1 +
    EnTT +  2.7.2
    diff --git a/functions_func_r.html b/functions_func_r.html index 05f1cb606..f73c7e39e 100644 --- a/functions_func_r.html +++ b/functions_func_r.html @@ -5,7 +5,7 @@ -entt: Class Members - Functions +EnTT: Class Members - Functions @@ -21,8 +21,8 @@ -
    entt -  2.7.1 +
    EnTT +  2.7.2
    diff --git a/functions_func_s.html b/functions_func_s.html index 3b41d1fd1..c077f683f 100644 --- a/functions_func_s.html +++ b/functions_func_s.html @@ -5,7 +5,7 @@ -entt: Class Members - Functions +EnTT: Class Members - Functions @@ -21,8 +21,8 @@ -
    entt -  2.7.1 +
    EnTT +  2.7.2
    @@ -94,7 +94,7 @@ $(function() { : entt::Registry< Entity >
  • Snapshot() -: entt::Snapshot< Entity > +: entt::Snapshot< Entity >
  • SnapshotLoader() : entt::SnapshotLoader< Entity > @@ -106,7 +106,7 @@ $(function() {
  • SparseSet() : entt::SparseSet< Entity > -, entt::SparseSet< Entity, Type > +, entt::SparseSet< Entity, Type >
  • succeed() : entt::Process< Derived, Delta > diff --git a/functions_func_t.html b/functions_func_t.html index 5d8f834e1..3d69fe72f 100644 --- a/functions_func_t.html +++ b/functions_func_t.html @@ -5,7 +5,7 @@ -entt: Class Members - Functions +EnTT: Class Members - Functions @@ -21,8 +21,8 @@ -
    entt -  2.7.1 +
    EnTT +  2.7.2
    diff --git a/functions_func_u.html b/functions_func_u.html index edafdecd0..ec079962c 100644 --- a/functions_func_u.html +++ b/functions_func_u.html @@ -5,7 +5,7 @@ -entt: Class Members - Functions +EnTT: Class Members - Functions @@ -21,8 +21,8 @@ -
    entt -  2.7.1 +
    EnTT +  2.7.2
    diff --git a/functions_func_v.html b/functions_func_v.html index fc3817188..db7cac2a8 100644 --- a/functions_func_v.html +++ b/functions_func_v.html @@ -5,7 +5,7 @@ -entt: Class Members - Functions +EnTT: Class Members - Functions @@ -21,8 +21,8 @@ -
    entt -  2.7.1 +
    EnTT +  2.7.2
    diff --git a/functions_g.html b/functions_g.html index c1739f5f1..a8113d9dc 100644 --- a/functions_g.html +++ b/functions_g.html @@ -5,7 +5,7 @@ -entt: Class Members +EnTT: Class Members @@ -21,8 +21,8 @@ -
    entt -  2.7.1 +
    EnTT +  2.7.2
    diff --git a/functions_h.html b/functions_h.html index e13326ea1..5bc7ba89e 100644 --- a/functions_h.html +++ b/functions_h.html @@ -5,7 +5,7 @@ -entt: Class Members +EnTT: Class Members @@ -21,8 +21,8 @@ -
    entt -  2.7.1 +
    EnTT +  2.7.2
    diff --git a/functions_i.html b/functions_i.html index 3b251c8aa..0e023ce48 100644 --- a/functions_i.html +++ b/functions_i.html @@ -5,7 +5,7 @@ -entt: Class Members +EnTT: Class Members @@ -21,8 +21,8 @@ -
    entt -  2.7.1 +
    EnTT +  2.7.2
    diff --git a/functions_l.html b/functions_l.html index f7a9e11fa..26be31801 100644 --- a/functions_l.html +++ b/functions_l.html @@ -5,7 +5,7 @@ -entt: Class Members +EnTT: Class Members @@ -21,8 +21,8 @@ -
    entt -  2.7.1 +
    EnTT +  2.7.2
    diff --git a/functions_m.html b/functions_m.html index adb453d16..1587045c1 100644 --- a/functions_m.html +++ b/functions_m.html @@ -5,7 +5,7 @@ -entt: Class Members +EnTT: Class Members @@ -21,8 +21,8 @@ -
    entt -  2.7.1 +
    EnTT +  2.7.2
    diff --git a/functions_o.html b/functions_o.html index f18ba6ec5..33fdc78f8 100644 --- a/functions_o.html +++ b/functions_o.html @@ -5,7 +5,7 @@ -entt: Class Members +EnTT: Class Members @@ -21,8 +21,8 @@ -
    entt -  2.7.1 +
    EnTT +  2.7.2
    @@ -89,6 +89,7 @@ $(function() {
  • operator()() : entt::Delegate< Ret(Args...)> , entt::InsertionSort +, entt::OneShotBubbleSort , entt::Prototype< Entity > , entt::StdSort
    • @@ -101,7 +102,7 @@ $(function() {
  • operator=() : entt::Actor< Entity > , entt::ContinuousLoader< Entity > -, entt::Emitter< Derived >::Connection< Event > +, entt::Emitter< Derived >::Connection< Event > , entt::Emitter< Derived > , entt::Monostate< hash_type > , entt::Prototype< Entity > @@ -111,8 +112,8 @@ $(function() { , entt::Scheduler< Delta > , entt::Snapshot< Entity > , entt::SnapshotLoader< Entity > -, entt::SparseSet< Entity > -, entt::SparseSet< Entity, Type > +, entt::SparseSet< Entity > +, entt::SparseSet< Entity, Type >
  • operator==() : entt::Delegate< Ret(Args...)> @@ -121,7 +122,7 @@ $(function() {
  • operator[]() : entt::PersistentView< Entity, Component > -, entt::RawView< Entity, Component > +, entt::RawView< Entity, Component > , entt::SparseSet< Entity > , entt::SparseSet< Entity, Type > , entt::View< Entity, Component > diff --git a/functions_p.html b/functions_p.html index 48a17b1da..0b75ff189 100644 --- a/functions_p.html +++ b/functions_p.html @@ -5,7 +5,7 @@ -entt: Class Members +EnTT: Class Members @@ -21,8 +21,8 @@ -
    entt -  2.7.1 +
    EnTT +  2.7.2
    diff --git a/functions_r.html b/functions_r.html index 99bd7a4ce..457bb51d9 100644 --- a/functions_r.html +++ b/functions_r.html @@ -5,7 +5,7 @@ -entt: Class Members +EnTT: Class Members @@ -21,8 +21,8 @@ -
    entt -  2.7.1 +
    EnTT +  2.7.2
    diff --git a/functions_rela.html b/functions_rela.html index 7dd4c54fd..4f5aa6b2a 100644 --- a/functions_rela.html +++ b/functions_rela.html @@ -5,7 +5,7 @@ -entt: Class Members - Related Functions +EnTT: Class Members - Related Functions @@ -21,8 +21,8 @@ -
    entt -  2.7.1 +
    EnTT +  2.7.2
    diff --git a/functions_s.html b/functions_s.html index 720cf2d29..3522a5fc2 100644 --- a/functions_s.html +++ b/functions_s.html @@ -5,7 +5,7 @@ -entt: Class Members +EnTT: Class Members @@ -21,8 +21,8 @@ -
    entt -  2.7.1 +
    EnTT +  2.7.2
    @@ -118,14 +118,14 @@ $(function() { : entt::Registry< Entity >
  • Snapshot() -: entt::Snapshot< Entity > +: entt::Snapshot< Entity >
  • SnapshotLoader() : entt::SnapshotLoader< Entity >
  • sort() : entt::PersistentView< Entity, Component > -, entt::Registry< Entity > +, entt::Registry< Entity > , entt::SparseSet< Entity, Type >
  • SparseSet() diff --git a/functions_t.html b/functions_t.html index 74e5b505f..73f3a635a 100644 --- a/functions_t.html +++ b/functions_t.html @@ -5,7 +5,7 @@ -entt: Class Members +EnTT: Class Members @@ -21,8 +21,8 @@ -
    entt -  2.7.1 +
    EnTT +  2.7.2
    diff --git a/functions_type.html b/functions_type.html index c5395c619..c8c82a33e 100644 --- a/functions_type.html +++ b/functions_type.html @@ -5,7 +5,7 @@ -entt: Class Members - Typedefs +EnTT: Class Members - Typedefs @@ -21,8 +21,8 @@ -
    entt -  2.7.1 +
    EnTT +  2.7.2
    diff --git a/functions_u.html b/functions_u.html index c3cd71517..1deb21f14 100644 --- a/functions_u.html +++ b/functions_u.html @@ -5,7 +5,7 @@ -entt: Class Members +EnTT: Class Members @@ -21,8 +21,8 @@ -
    entt -  2.7.1 +
    EnTT +  2.7.2
    diff --git a/functions_v.html b/functions_v.html index 773a0baee..fad9840ed 100644 --- a/functions_v.html +++ b/functions_v.html @@ -5,7 +5,7 @@ -entt: Class Members +EnTT: Class Members @@ -21,8 +21,8 @@ -
    entt -  2.7.1 +
    EnTT +  2.7.2
    diff --git a/functions_vars.html b/functions_vars.html index a663ab891..da404c89e 100644 --- a/functions_vars.html +++ b/functions_vars.html @@ -5,7 +5,7 @@ -entt: Class Members - Variables +EnTT: Class Members - Variables @@ -21,8 +21,8 @@ -
    entt -  2.7.1 +
    EnTT +  2.7.2
    diff --git a/graph_legend.html b/graph_legend.html index d3fc417e2..9668f9894 100644 --- a/graph_legend.html +++ b/graph_legend.html @@ -5,7 +5,7 @@ -entt: Graph Legend +EnTT: Graph Legend @@ -21,8 +21,8 @@ -
    entt -  2.7.1 +
    EnTT +  2.7.2
    diff --git a/handle_8hpp_source.html b/handle_8hpp_source.html index bd2c25eb1..dada4a358 100644 --- a/handle_8hpp_source.html +++ b/handle_8hpp_source.html @@ -5,7 +5,7 @@ -entt: src/entt/resource/handle.hpp Source File +EnTT: src/entt/resource/handle.hpp Source File @@ -21,8 +21,8 @@ -
    entt -  2.7.1 +
    EnTT +  2.7.2
    diff --git a/hashed__string_8hpp_source.html b/hashed__string_8hpp_source.html index 403964056..32a440094 100644 --- a/hashed__string_8hpp_source.html +++ b/hashed__string_8hpp_source.html @@ -5,7 +5,7 @@ -entt: src/entt/core/hashed_string.hpp Source File +EnTT: src/entt/core/hashed_string.hpp Source File @@ -21,8 +21,8 @@ -
    entt -  2.7.1 +
    EnTT +  2.7.2
    @@ -67,7 +67,7 @@ $(function() {
    hashed_string.hpp
    -
    1 #ifndef ENTT_CORE_HASHED_STRING_HPP
    2 #define ENTT_CORE_HASHED_STRING_HPP
    3 
    4 
    5 #include <cstddef>
    6 #include <cstdint>
    7 #include "../config/config.h"
    8 
    9 
    10 namespace entt {
    11 
    12 
    22 class HashedString final {
    23  struct ConstCharWrapper final {
    24  // non-explicit constructor on purpose
    25  constexpr ConstCharWrapper(const char *str) ENTT_NOEXCEPT: str{str} {}
    26  const char *str;
    27  };
    28 
    29  static constexpr std::uint64_t offset = 14695981039346656037ull;
    30  static constexpr std::uint64_t prime = 1099511628211ull;
    31 
    32  // Fowler–Noll–Vo hash function v. 1a - the good
    33  static constexpr std::uint64_t helper(std::uint64_t partial, const char *str) ENTT_NOEXCEPT {
    34  return str[0] == 0 ? partial : helper((partial^str[0])*prime, str+1);
    35  }
    36 
    37 public:
    39  using hash_type = std::uint64_t;
    40 
    55  template <std::size_t N>
    56  constexpr HashedString(const char (&str)[N]) ENTT_NOEXCEPT
    57  : hash{helper(offset, str)}, str{str}
    58  {}
    59 
    66  explicit constexpr HashedString(ConstCharWrapper wrapper) ENTT_NOEXCEPT
    67  : hash{helper(offset, wrapper.str)}, str{wrapper.str}
    68  {}
    69 
    74  constexpr operator const char *() const ENTT_NOEXCEPT { return str; }
    75 
    80  constexpr operator hash_type() const ENTT_NOEXCEPT { return hash; }
    81 
    87  constexpr bool operator==(const HashedString &other) const ENTT_NOEXCEPT {
    88  return hash == other.hash;
    89  }
    90 
    91 private:
    92  const hash_type hash;
    93  const char *str;
    94 };
    95 
    96 
    103 constexpr bool operator!=(const HashedString &lhs, const HashedString &rhs) ENTT_NOEXCEPT {
    104  return !(lhs == rhs);
    105 }
    106 
    107 
    108 }
    109 
    110 
    111 constexpr entt::HashedString operator"" ENTT_HS_SUFFIX(const char *str, std::size_t) ENTT_NOEXCEPT {
    112  return entt::HashedString{str};
    113 }
    114 
    115 
    116 #endif // ENTT_CORE_HASHED_STRING_HPP
    entt::operator!=
    constexpr bool operator!=(const HashedString &lhs, const HashedString &rhs) ENTT_NOEXCEPT
    Compares two hashed strings.
    Definition: hashed_string.hpp:103
    +
    1 #ifndef ENTT_CORE_HASHED_STRING_HPP
    2 #define ENTT_CORE_HASHED_STRING_HPP
    3 
    4 
    5 #include <cstddef>
    6 #include <cstdint>
    7 #include "../config/config.h"
    8 
    9 
    10 namespace entt {
    11 
    12 
    22 class HashedString final {
    23  struct ConstCharWrapper final {
    24  // non-explicit constructor on purpose
    25  constexpr ConstCharWrapper(const char *str) ENTT_NOEXCEPT: str{str} {}
    26  const char *str;
    27  };
    28 
    29  static constexpr std::uint64_t offset = 14695981039346656037ull;
    30  static constexpr std::uint64_t prime = 1099511628211ull;
    31 
    32  // Fowler–Noll–Vo hash function v. 1a - the good
    33  static constexpr std::uint64_t helper(std::uint64_t partial, const char *str) ENTT_NOEXCEPT {
    34  return str[0] == 0 ? partial : helper((partial^str[0])*prime, str+1);
    35  }
    36 
    37 public:
    39  using hash_type = std::uint64_t;
    40 
    55  template <std::size_t N>
    56  constexpr HashedString(const char (&str)[N]) ENTT_NOEXCEPT
    57  : hash{helper(offset, str)}, str{str}
    58  {}
    59 
    66  explicit constexpr HashedString(ConstCharWrapper wrapper) ENTT_NOEXCEPT
    67  : hash{helper(offset, wrapper.str)}, str{wrapper.str}
    68  {}
    69 
    74  constexpr operator const char *() const ENTT_NOEXCEPT { return str; }
    75 
    80  constexpr operator hash_type() const ENTT_NOEXCEPT { return hash; }
    81 
    87  constexpr bool operator==(const HashedString &other) const ENTT_NOEXCEPT {
    88  return hash == other.hash;
    89  }
    90 
    91 private:
    92  const hash_type hash;
    93  const char *str;
    94 };
    95 
    96 
    103 constexpr bool operator!=(const HashedString &lhs, const HashedString &rhs) ENTT_NOEXCEPT {
    104  return !(lhs == rhs);
    105 }
    106 
    107 
    108 }
    109 
    110 
    116 constexpr entt::HashedString operator"" ENTT_HS_SUFFIX(const char *str, std::size_t) ENTT_NOEXCEPT {
    117  return entt::HashedString{str};
    118 }
    119 
    120 
    121 #endif // ENTT_CORE_HASHED_STRING_HPP
    entt::operator!=
    constexpr bool operator!=(const HashedString &lhs, const HashedString &rhs) ENTT_NOEXCEPT
    Compares two hashed strings.
    Definition: hashed_string.hpp:103
    entt
    EnTT default namespace.
    Definition: algorithm.hpp:10
    entt::HashedString::HashedString
    constexpr HashedString(ConstCharWrapper wrapper) ENTT_NOEXCEPT
    Explicit constructor on purpose to avoid constructing a hashed string directly from a const char *...
    Definition: hashed_string.hpp:66
    entt::HashedString::operator==
    constexpr bool operator==(const HashedString &other) const ENTT_NOEXCEPT
    Compares two hashed strings.
    Definition: hashed_string.hpp:87
    diff --git a/helper_8hpp_source.html b/helper_8hpp_source.html index 9eaf1b200..59a3670a3 100644 --- a/helper_8hpp_source.html +++ b/helper_8hpp_source.html @@ -5,7 +5,7 @@ -entt: src/entt/entity/helper.hpp Source File +EnTT: src/entt/entity/helper.hpp Source File @@ -21,8 +21,8 @@ -
    entt -  2.7.1 +
    EnTT +  2.7.2
    @@ -67,11 +67,12 @@ $(function() {
    helper.hpp
    -
    1 #ifndef ENTT_ENTITY_HELPER_HPP
    2 #define ENTT_ENTITY_HELPER_HPP
    3 
    4 
    5 #include "../signal/sigh.hpp"
    6 #include "registry.hpp"
    7 #include "utility.hpp"
    8 
    9 
    10 namespace entt {
    11 
    12 
    27 template<typename Entity, typename... Component>
    28 void dependency(Registry<Entity> &registry, const Entity entity) {
    29  using accumulator_type = int[];
    30  accumulator_type accumulator = { ((registry.template has<Component>(entity) ? void() : (registry.template assign<Component>(entity), void())), 0)... };
    31  (void)accumulator;
    32 }
    33 
    34 
    52 template<typename... Dependency, typename Entity>
    53 void dependency(Sink<void(Registry<Entity> &, const Entity)> sink) {
    54  sink.template connect<dependency<Entity, Dependency...>>();
    55 }
    56 
    57 
    75 template<typename... Dependency, typename Entity>
    76 void dependency(break_t, Sink<void(Registry<Entity> &, const Entity)> sink) {
    77  sink.template disconnect<dependency<Entity, Dependency...>>();
    78 }
    79 
    80 
    81 }
    82 
    83 
    84 #endif // ENTT_ENTITY_HELPER_HPP
    entt::Registry
    Fast and reliable entity-component system.
    Definition: registry.hpp:40
    +
    1 #ifndef ENTT_ENTITY_HELPER_HPP
    2 #define ENTT_ENTITY_HELPER_HPP
    3 
    4 
    5 #include <type_traits>
    6 #include "../core/hashed_string.hpp"
    7 #include "../signal/sigh.hpp"
    8 #include "registry.hpp"
    9 #include "utility.hpp"
    10 
    11 
    12 namespace entt {
    13 
    14 
    29 template<typename Entity, typename... Component>
    30 void dependency(Registry<Entity> &registry, const Entity entity) {
    31  using accumulator_type = int[];
    32  accumulator_type accumulator = { ((registry.template has<Component>(entity) ? void() : (registry.template assign<Component>(entity), void())), 0)... };
    33  (void)accumulator;
    34 }
    35 
    36 
    54 template<typename... Dependency, typename Entity>
    55 void dependency(Sink<void(Registry<Entity> &, const Entity)> sink) {
    56  sink.template connect<dependency<Entity, Dependency...>>();
    57 }
    58 
    59 
    77 template<typename... Dependency, typename Entity>
    78 void dependency(break_t, Sink<void(Registry<Entity> &, const Entity)> sink) {
    79  sink.template disconnect<dependency<Entity, Dependency...>>();
    80 }
    81 
    82 
    98 template<typename HashedString::hash_type Value>
    99 using label = std::integral_constant<typename HashedString::hash_type, Value>;
    100 
    101 
    102 }
    103 
    104 
    105 #endif // ENTT_ENTITY_HELPER_HPP
    entt::Registry
    Fast and reliable entity-component system.
    Definition: registry.hpp:40
    entt::Sink
    Sink implementation.
    Definition: sigh.hpp:99
    entt
    EnTT default namespace.
    Definition: algorithm.hpp:10
    entt::break_t
    Break type used to disambiguate overloads.
    Definition: utility.hpp:21
    -
    entt::dependency
    void dependency(Registry< Entity > &registry, const Entity entity)
    Dependency function prototype.
    Definition: helper.hpp:28
    +
    entt::dependency
    void dependency(Registry< Entity > &registry, const Entity entity)
    Dependency function prototype.
    Definition: helper.hpp:30
    +
    entt::label
    std::integral_constant< typename HashedString::hash_type, Value > label
    Alias template to ease the assignment of labels to entities.
    Definition: helper.hpp:99
    diff --git a/hierarchy.html b/hierarchy.html index b554a1728..4247bfb3d 100644 --- a/hierarchy.html +++ b/hierarchy.html @@ -5,7 +5,7 @@ -entt: Class Hierarchy +EnTT: Class Hierarchy @@ -21,8 +21,8 @@ -
    entt -  2.7.1 +
    EnTT +  2.7.2
    @@ -89,34 +89,35 @@ This inheritance list is sorted roughly, but not completely, alphabetically: ▼CInvoker  Centt::SigH< Ret(Args...), Collector >Unmanaged signal handler definition  Centt::Monostate< hash_type >Minimal implementation of the monostate pattern - Centt::persistent_tPersistent view type used to disambiguate overloads - Centt::PersistentView< Entity, Component >Persistent view - Centt::Process< Derived, Delta >Base class for processes - ▼Centt::Process< ProcessAdaptor< Func, Delta >, Delta > - Centt::ProcessAdaptor< Func, Delta >Adaptor for lambdas and functors to turn them into processes - Centt::Prototype< Entity >Prototype container for concepts - Centt::raw_tRaw view type used to disambiguate overloads - Centt::RawView< Entity, Component >Raw view - Centt::Registry< Entity >Fast and reliable entity-component system - Centt::ResourceCache< Resource >Simple cache for resources of a given type - Centt::ResourceHandle< Resource >Shared resource handle - Centt::ResourceLoader< Loader, Resource >Base class for resource loaders - Centt::RuntimeView< Entity >Runtime view - Centt::Scheduler< Delta >Cooperative scheduler for processes - Centt::ServiceLocator< Service >Service locator, nothing more - Centt::SigH< Function, Collector >Unmanaged signal handler declaration - Centt::SigH< void(const Event &)> - Centt::Sink< Function >Sink implementation - Centt::Sink< Ret(Args...)>Sink implementation - Centt::Snapshot< Entity >Utility class to create snapshots from a registry - Centt::SnapshotLoader< Entity >Utility class to restore a snapshot as a whole - Centt::SparseSet<... >Sparse set - ▼Centt::SparseSet< Entity >Basic sparse set implementation - Centt::SparseSet< Entity, Type >Extended sparse set implementation - Centt::StdSortFunction object to wrap std::sort in a class type - Centt::tag_tTag class type used to disambiguate overloads - Centt::View< Entity, Component >Multi component view - Centt::View< Entity, Component >Single component view specialization + Centt::OneShotBubbleSortFunction object for performing bubble sort (single iteration) + Centt::persistent_tPersistent view type used to disambiguate overloads + Centt::PersistentView< Entity, Component >Persistent view + Centt::Process< Derived, Delta >Base class for processes + ▼Centt::Process< ProcessAdaptor< Func, Delta >, Delta > + Centt::ProcessAdaptor< Func, Delta >Adaptor for lambdas and functors to turn them into processes + Centt::Prototype< Entity >Prototype container for concepts + Centt::raw_tRaw view type used to disambiguate overloads + Centt::RawView< Entity, Component >Raw view + Centt::Registry< Entity >Fast and reliable entity-component system + Centt::ResourceCache< Resource >Simple cache for resources of a given type + Centt::ResourceHandle< Resource >Shared resource handle + Centt::ResourceLoader< Loader, Resource >Base class for resource loaders + Centt::RuntimeView< Entity >Runtime view + Centt::Scheduler< Delta >Cooperative scheduler for processes + Centt::ServiceLocator< Service >Service locator, nothing more + Centt::SigH< Function, Collector >Unmanaged signal handler declaration + Centt::SigH< void(const Event &)> + Centt::Sink< Function >Sink implementation + Centt::Sink< Ret(Args...)>Sink implementation + Centt::Snapshot< Entity >Utility class to create snapshots from a registry + Centt::SnapshotLoader< Entity >Utility class to restore a snapshot as a whole + Centt::SparseSet<... >Sparse set + ▼Centt::SparseSet< Entity >Basic sparse set implementation + Centt::SparseSet< Entity, Type >Extended sparse set implementation + Centt::StdSortFunction object to wrap std::sort in a class type + Centt::tag_tTag class type used to disambiguate overloads + Centt::View< Entity, Component >Multi component view + Centt::View< Entity, Component >Single component view specialization
    diff --git a/ident_8hpp_source.html b/ident_8hpp_source.html index 4537dcdbe..6d8022ece 100644 --- a/ident_8hpp_source.html +++ b/ident_8hpp_source.html @@ -5,7 +5,7 @@ -entt: src/entt/core/ident.hpp Source File +EnTT: src/entt/core/ident.hpp Source File @@ -21,8 +21,8 @@ -
    entt -  2.7.1 +
    EnTT +  2.7.2
    diff --git a/index.html b/index.html index e9d00447d..4bab8f18e 100644 --- a/index.html +++ b/index.html @@ -5,7 +5,7 @@ -entt: EnTT Framework +EnTT: Main Page @@ -21,8 +21,8 @@ -
    entt -  2.7.1 +
    EnTT +  2.7.2
    @@ -60,122 +60,27 @@ $(function() {
    -
    EnTT Framework
    +
    EnTT Documentation
    -

    +
    +EnTT: Gaming meets modern C++ +

    -Table of Contents

    - -

    Introduction

    -

    EnTT is a header-only, tiny and easy to use framework written in modern C++.
    - It was originally designed entirely around an architectural pattern called ECS that is used mostly in game development. For further details:

    +

    EnTT is a header-only, tiny and easy to use entity-component system (and much more) written in modern C++.
    + The entity-component-system (also known as ECS) is an architectural pattern used mostly in game development. For further details:

    A long time ago, the sole entity-component system was part of the project. After a while the codebase has grown and more and more classes have become part of the repository.
    - That's why today it's called the EnTT Framework.

    -

    Currently, EnTT is tested on Linux, Microsoft Windows and OS X. It has proven to work also on both Android and iOS.
    - Most likely it will not be problematic on other systems as well, but has not been sufficiently tested so far.

    -

    -The framework

    -

    EnTT was written initially as a faster alternative to other well known and open source entity-component systems. Nowadays the EnTT framework is moving its first steps. Much more will come in the future and hopefully I'm going to work on it for a long time.
    - Requests for feature, PR, suggestions ad feedback are highly appreciated.

    -

    If you find you can help me and want to contribute to the EnTT framework with your experience or you do want to get part of the project for some other reasons, feel free to contact me directly (you can find the mail in the profile).
    - I can't promise that each and every contribution will be accepted, but I can assure that I'll do my best to take them all seriously.

    -

    -State of the art

    -

    Here is a brief list of what it offers today:

    + Here is a brief, yet incomplete list of what it offers today:

    • Statically generated integer identifiers for types (assigned either at compile-time or at runtime).
    • A constexpr utility for human readable resource identifiers.
      • +
    • A minimal configuration system built on top of the monostate pattern.
    • An incredibly fast entity-component system based on sparse sets, with its own views and a pay for what you use policy to adjust performance and memory usage according to users' requirements.
    • Actor class for those who aren't confident with entity-component systems.
    • The smallest and most basic implementation of a service locator ever seen.
      • @@ -187,16 +92,17 @@ State of the art
    • ...
    • Any other business.
    -

    Consider it a work in progress. For more details and an updated list, please refer to the online documentation. It probably contains much more. Moreover, the whole API is fully documented in-code for those who are brave enough to read it.
    - Continue reading to know how the different parts of the project work or follow the link above to take a look at the API reference.

    -

    +

    Consider it a work in progress. The whole API is also fully documented in-code for those who are brave enough to read it.

    +

    Currently, EnTT is tested on Linux, Microsoft Windows and OS X. It has proven to work also on both Android and iOS.
    + Most likely it will not be problematic on other systems as well, but has not been sufficiently tested so far.

    +

    Code Example

    -
    #include <entt/entt.hpp>
    #include <cstdint>
    struct Position {
    float x;
    float y;
    };
    struct Velocity {
    float dx;
    float dy;
    };
    void update(entt::DefaultRegistry &registry) {
    auto view = registry.view<Position, Velocity>();
    for(auto entity: view) {
    // gets only the components that are going to be used ...
    auto &velocity = view.get<Velocity>(entity);
    velocity.dx = 0.;
    velocity.dy = 0.;
    // ...
    }
    }
    void update(std::uint64_t dt, entt::DefaultRegistry &registry) {
    registry.view<Position, Velocity>().each([dt](auto entity, auto &position, auto &velocity) {
    // gets all the components of the view at once ...
    position.x += velocity.dx * dt;
    position.y += velocity.dy * dt;
    // ...
    });
    }
    int main() {
    entt::DefaultRegistry registry;
    std::uint64_t dt = 16;
    for(auto i = 0; i < 10; ++i) {
    auto entity = registry.create();
    registry.assign<Position>(entity, i * 1.f, i * 1.f);
    if(i % 2 == 0) { registry.assign<Velocity>(entity, i * .1f, i * .1f); }
    }
    update(dt, registry);
    update(registry);
    // ...
    }

    +
    #include <entt/entt.hpp>
    #include <cstdint>
    struct Position {
    float x;
    float y;
    };
    struct Velocity {
    float dx;
    float dy;
    };
    void update(entt::DefaultRegistry &registry) {
    auto view = registry.view<Position, Velocity>();
    for(auto entity: view) {
    // gets only the components that are going to be used ...
    auto &velocity = view.get<Velocity>(entity);
    velocity.dx = 0.;
    velocity.dy = 0.;
    // ...
    }
    }
    void update(std::uint64_t dt, entt::DefaultRegistry &registry) {
    registry.view<Position, Velocity>().each([dt](auto entity, auto &position, auto &velocity) {
    // gets all the components of the view at once ...
    position.x += velocity.dx * dt;
    position.y += velocity.dy * dt;
    // ...
    });
    }
    int main() {
    entt::DefaultRegistry registry;
    std::uint64_t dt = 16;
    for(auto i = 0; i < 10; ++i) {
    auto entity = registry.create();
    registry.assign<Position>(entity, i * 1.f, i * 1.f);
    if(i % 2 == 0) { registry.assign<Velocity>(entity, i * .1f, i * .1f); }
    }
    update(dt, registry);
    update(registry);
    // ...
    }

    Motivation

    I started working on EnTT because of the wrong reason: my goal was to design an entity-component system that beated another well known open source solution in terms of performance and used (possibly) less memory in the average case.
    In the end, I did it, but it wasn't much satisfying. Actually it wasn't satisfying at all. The fastest and nothing more, fairly little indeed. When I realized it, I tried hard to keep intact the great performance of EnTT and to add all the features I wanted to see in my own library at the same time.

    -

    Today EnTT is finally what I was looking for: still faster than its competitors, lower memory usage in the average case, a really good API and an amazing set of features. And even more, of course.

    -

    +

    Nowadays, EnTT is finally what I was looking for: still faster than its competitors, lower memory usage in the average case, a really good API and an amazing set of features. And even more, of course.

    +

    Performance

    As it stands right now, EnTT is just fast enough for my requirements if compared to my first choice (it was already amazingly fast actually).
    Below is a comparison between the two (both of them compiled with GCC 7.3.0 on a Dell XPS 13 out of the mid 2014):

    @@ -247,9 +153,9 @@ Arrays are almost sorted, insertion sort - 0.0007s If you decide to use EnTT, choose it because of its API, features and performance, not because there is a benchmark somewhere that makes it seem the fastest.

    Probably I'll try to get out of EnTT more features and even better performance in the future, mainly for fun.
    If you want to contribute and/or have any suggestion, feel free to make a PR or open an issue to discuss your idea.

    -

    +

    Build Instructions

    -

    +

    Requirements

    To be able to use EnTT, users must provide a full-featured compiler that supports at least C++14.
    The requirements below are mandatory to compile the tests and to extract the documentation:

    @@ -257,21 +163,32 @@ Requirements
  • CMake version 3.2 or later.
  • Doxygen version 1.8 or later.
    • -

    +

    Library

    -

    EnTT is a header-only library. This means that including the entt.hpp header is enough to include the whole framework and use it. For those who are interested only in the entity-component system, consider to include the sole entity/registry.hpp header instead.
    +

    EnTT is a header-only library. This means that including the entt.hpp header is enough to include the library as a whole and use it. For those who are interested only in the entity-component system, consider to include the sole entity/registry.hpp header instead.
    It's a matter of adding the following line to the top of a file:

    #include <entt/entt.hpp>

    Use the line below to include only the entity-component system instead:

    #include <entt/entity/registry.hpp>

    Then pass the proper -I argument to the compiler to add the src directory to the include paths.

    -

    +

    +Side note: shared libraries

    +

    To make sure that an application and a shared library that use both EnTT can interact correctly when symbols are hidden by default, there are some tricks to follow.
    + In particular and in order to avoid undefined behaviors, all the instantiation of the Family class template shall be made explicit along with the system-wide specifier to use to export them.

    +

    At the time I'm writing this document, the classes that use internally the above mentioned class template are Dispatcher, Emitter and Registry. Therefore and as an example, if you use the Registry class template in your shared library and want to set symbols visibility to hidden by default, the following lines are required to allow it to function properly with a client that also uses the Registry somehow:

    +
      +
    • On GNU/Linux:
      • +
    +
    namespace entt {
    template class __attribute__((visibility("default"))) Family<struct InternalRegistryTagFamily>;
    template class __attribute__((visibility("default"))) Family<struct InternalRegistryComponentFamily>;
    template class __attribute__((visibility("default"))) Family<struct InternalRegistryHandlerFamily>;
    }
      +
    • On Windows:
      • +
    +
    namespace entt {
    template class __declspec(dllexport) Family<struct InternalRegistryTagFamily>;
    template class __declspec(dllexport) Family<struct InternalRegistryComponentFamily>;
    template class __declspec(dllexport) Family<struct InternalRegistryHandlerFamily>;
    }

    Otherwise, the risk is that type identifiers are different between the shared library and the application and this will prevent the whole thing from functioning correctly for obvious reasons.

    +

    Documentation

    The documentation is based on doxygen. To build it: 

    $ cd build
 $ cmake .. -DBUILD_DOCS=ON
 $ make

    The API reference will be created in HTML format within the directory build/docs/html. To navigate it with your favorite browser: 

    $ cd build
 $ your_favorite_browser docs/html/index.html
-

    The API reference is also available online for the latest version.

    -

    +

    Tests

    To compile and run the tests, EnTT requires googletest.
    cmake will download and compile the library before compiling anything else. In order to build without tests set CMake option BUILD_TESTING=OFF.

    @@ -283,31 +200,31 @@ Tests
  • $ make test

    • Note that benchmarks are not part of this set.

    -

    +

    Crash Course: entity-component system

    -

    +

    Design choices

    -

    +

    A bitset-free entity-component system

    EnTT is a bitset-free entity-component system that doesn't require users to specify the component set at compile-time.
    This is why users can instantiate the core class simply like:

    entt::DefaultRegistry registry;

    In place of its more annoying and error-prone counterpart:

    -
    entt::DefaultRegistry<Comp0, Comp1, ..., CompN> registry;

    +
    entt::DefaultRegistry<Comp0, Comp1, ..., CompN> registry;

    Pay per use

    EnTT is entirely designed around the principle that users have to pay only for what they want.

    When it comes to using an entity-component system, the tradeoff is usually between performance and memory usage. The faster it is, the more memory it uses. However, slightly worse performance along non-critical paths are the right price to pay to reduce memory usage and I've always wondered why this kind of tools do not leave me the choice.
    EnTT follows a completely different approach. It squeezes the best from the basic data structures and gives users the possibility to pay more for higher performance where needed.
    The disadvantage of this approach is that users need to know the systems they are working on and the tools they are using. Otherwise, the risk to ruin the performance along critical paths is high.

    So far, this choice has proven to be a good one and I really hope it can be for many others besides me.

    -

    +

    Vademecum

    The Registry to store, the views to iterate. That's all.

    An entity (the E of an ECS) is an opaque identifier that users should just use as-is and store around if needed. Do not try to inspect an entity identifier, its format can change in future and a registry offers all the functionalities to query them out-of-the-box. The underlying type of an entity (either std::uint16_t, std::uint32_t or std::uint64_t) can be specified when defining a registry (actually the DefaultRegistry is nothing more than a Registry where the type of the entities is std::uint32_t).
    Components (the C of an ECS) should be plain old data structures or more complex and movable data structures with a proper constructor. Actually, the sole requirement of a component type is that it must be both move constructible and move assignable. They are list initialized by using the parameters provided to construct the component itself. No need to register components or their types neither with the registry nor with the entity-component system at all.
    Systems (the S of an ECS) are just plain functions, functors, lambdas or whatever users want. They can accept a Registry or a view of any type and use them the way they prefer. No need to register systems or their types neither with the registry nor with the entity-component system at all.

    -

    The following sections will explain in short how to use the entity-component system, the core part of the whole framework.
    - In fact, the framework is composed of many other classes in addition to those describe below. For more details, please refer to the inline documentation.

    -

    +

    The following sections will explain in short how to use the entity-component system, the core part of the whole library.
    + In fact, the project is composed of many other classes in addition to those describe below. For more details, please refer to the inline documentation.

    +

    The Registry, the Entity and the Component

    A registry can store and manage entities, as well as create views to iterate the underlying data structures.
    Registry is a class template that lets users decide what's the preferred type to represent an entity. Because std::uint32_t is large enough for almost all the cases, there exists also an alias named DefaultRegistry for Registry<std::uint32_t>.

    @@ -333,7 +250,7 @@ The Registry, the Entity and the Component
    registry.reset();

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

    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.
    Tags undergo the same requirements of components. They can be either plain old data structures or more complex and movable data structures with a proper constructor.
    @@ -346,7 +263,7 @@ Single instance components

    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, 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.

    -

    +

    Observe changes

    Because of how the registry works internally, it stores a couple of signal handlers for each pool in order to notify some of its data structures on the construction and destruction of components.
    These signal handlers are also exposed and made available to users. This is the basic brick to build fancy things like dependencies and reactive systems.

    @@ -366,20 +283,20 @@ Observe changes

    To a certain extent, these limitations do not apply. However, it is risky to try to force them and users should respect the limitations unless they know exactly what they are doing. Subtle bugs are the price to pay in case of errors otherwise.

    In general, events and therefore listeners must not be used as replacements for systems. They should not contain much logic and interactions with a registry should be kept to a minimum, if possible. Note also that the greater the number of listeners, the greater the performance hit when components are created or destroyed.

    -

    +

    Who let the tags out?

    As an extension, signals are also provided with tags. Although they are not strictly required internally, it makes sense that a user expects signal support even when it comes to tags actually.
    Signals for tags undergo exactly the same requirements of those introduced for components. Also the function type for a listener is the same and it's invoked with the same guarantees discussed above.

    To get the sinks for a tag just use tag tag_t to disambiguate overloads of member functions as in the following example:

    registry.construction<MyTag>(entt::tag_t{}).connect<&MyFreeFunction>();
    registry.destruction<MyTag>(entt::tag_t{}).connect<MyClass, &MyClass::member>(&instance);

    Listeners for tags and components are managed separately and do not influence each other in any case. Therefore, note that the greater the number of listeners for a type, the greater the performance hit when a tag of the given type is created or destroyed.

    -

    +

    Runtime components

    Defining components at runtime is useful to support plugin systems and mods in general. However, it seems impossible with a tool designed around a bunch of templates. Indeed it's not that difficult.
    Of course, some features cannot be easily exported into a runtime environment. As an example, sorting a group of components defined at runtime isn't for free if compared to most of the other operations. However, the basic functionalities of an entity-component system such as EnTT fit the problem perfectly and can also be used to manage runtime components if required.
    All that is necessary to do it is to know the identifiers of the components. An identifier is nothing more than a number or similar that can be used at runtime to work with the type system.

    In EnTT, identifiers are easily accessible:

    -
    entt::DefaultRegistry registry;
    // standard component identifier
    auto ctype = registry.component<Position>();
    // single instance component identifier
    auto ttype = registry.tag<PlayingCharacter>();

    Once the identifiers are made available, almost everything becomes pretty simple.

    -

    +
    entt::DefaultRegistry registry;
    // standard component identifier
    auto ctype = registry.type<Position>();
    // single instance component identifier
    auto ttype = registry.type<PlayingCharacter>(entt::tag_t{});

    Once the identifiers are made available, almost everything becomes pretty simple.

    +

    A journey through a plugin

    EnTT comes with an example (actually a test) that shows how to integrate compile-time and runtime components in a stack based JavaScript environment. It uses Duktape under the hood, mainly because I wanted to learn how it works at the time I was writing the code.

    The code is not production-ready and overall performance can be highly improved. However, I sacrificed optimizations in favor of a more readable piece of code. I hope I succeeded.
    @@ -388,7 +305,7 @@ A journey through a plugin

    The basic idea is that of creating a compile-time component aimed to map all the runtime components assigned to an entity.
    Identifiers come in use to address the right function from a map when invoked from the runtime environment and to filter entities when iterating.
    With a bit of gymnastic, one can narrow views and improve the performance to some extent but it was not the goal of the example.

    -

    +

    Sorting: is it possible?

    It goes without saying that sorting entities and components is possible with EnTT.
    In fact, there are two functions that respond to slightly different needs:

    @@ -401,7 +318,7 @@ Sorting: is it possible?
  • Components can be sorted according to the order imposed by another component:
    • registry.sort<Movement, Physics>();

    In this case, instances of Movement are arranged in memory so that cache misses are minimized when the two components are iterated together.

    -

    +

    Snapshot: complete vs continuous

    The Registry class offers basic support to serialization.
    It doesn't convert components and tags to bytes directly, there wasn't the need of another tool for serialization out there. Instead, it accepts an opaque object with a suitable interface (namely an archive) to serialize its internal data structures and restore them later. The way types and instances are converted to a bunch of bytes is completely in charge to the archive and thus to final users.

    @@ -423,7 +340,7 @@ Snapshot: complete vs continuous Note also that both component and tag store items along with entities. It means that they work properly without a call to the entities member function.

    Once a snapshot is created, there exist mainly two ways to load it: as a whole and in a kind of continuous mode.
    The following sections describe both loaders and archives in details.

    -

    +

    Snapshot loader

    A snapshot loader requires that the destination registry be empty and loads all the data at once while keeping intact the identifiers that the entities originally had.
    To do that, the registry offers a member function named restore that returns a temporary object properly initialized to restore a snapshot.

    @@ -432,7 +349,7 @@ Snapshot loader

    The entities and destroyed member functions restore the sets of entities and the versions that the entities originally had at the source.

    The component member function restores all and only the components specified and assigns them to the right entities. Note that the template parameter list must be exactly the same used during the serialization. The same applies to the tag member function.

    The orphans member function literally destroys those entities that have neither components nor tags. It's usually useless if the snapshot is a full dump of the source. However, in case all the entities are serialized but only few components and tags are saved, it could happen that some of the entities have neither components nor tags once restored. The best users can do to deal with them is to destroy those entities and thus update their versions.

    -

    +

    Continuous loader

    A continuous loader is designed to load data from a source registry to a (possibly) non-empty destination. The loader can accommodate in a registry more than one snapshot in a sort of continuous loading that updates the destination one step at a time.
    Identifiers that entities originally had are not transferred to the target. Instead, the loader maps remote identifiers to local ones while restoring a snapshot. Because of that, this kind of loader offers a way to update automatically identifiers that are part of components or tags (as an example, as data members or gathered in a container).
    @@ -444,7 +361,7 @@ Continuous loader In case the component or the tag contains entities itself (either as data members of type entity_type or as containers of entities), the loader can update them automatically. To do that, it's enough to specify the data members to update as shown in the example.

    The orphans member function literally destroys those entities that have neither components nor tags after a restore. It has exactly the same purpose described in the previous section and works the same way.

    Finally, shrink helps to purge local entities that no longer have a remote conterpart. Users should invoke this member function after restoring each snapshot, unless they know exactly what they are doing.

    -

    +

    Archives

    Archives must publicly expose a predefined set of member functions. The API is straightforward and consists only of a group of function call operators that are invoked by the snapshot class and the loaders.

    In particular:

    @@ -460,12 +377,12 @@ Archives
    void operator()(Entity &);

    Where Entity is the type of the entities used by the registry. Each time the function is invoked, the archive must read the next element from the underlying storage and copy it in the given variable. Note that all the member functions of a loader class make also an initial call to this endpoint to read the size of the set they are going to load.
    In addition, the archive must accept a pair of entity and either component or tag for each type to be restored. Therefore, given a type T, the archive must contain a function call operator with the following signature:

    void operator()(Entity &, T &);

    Every time such an operator is invoked, the archive must read the next elements from the underlying storage and copy them in the given variables.

    -

    +

    One example to rule them all

    EnTT comes with some examples (actually some tests) that show how to integrate a well known library for serialization as an archive. It uses Cereal C++ under the hood, mainly because I wanted to learn how it works at the time I was writing the code.

    The code is not production-ready and it isn't neither the only nor (probably) the best way to do it. However, feel free to use it at your own risk.

    The basic idea is to store everything in a group of queues in memory, then bring everything back to the registry with different loaders.

    -

    +

    Prototype

    A prototype defines a type of an application in terms of its parts. They can be used to assign components to entities of a registry at once.
    Roughly speaking, in most cases prototypes can be considered just as templates to use to initialize entities according to concepts. In fact, users can create how many prototypes they want, each one initialized differently from the others.

    @@ -479,24 +396,29 @@ Prototype

    In the examples above, the prototype uses its underlying registry to create entities and components both for its purposes and when it's cloned. To use a different repository to clone a prototype, all the member functions accept also a reference to a valid registry as a first argument.

    Prototypes are a very useful tool that can save a lot of typing sometimes. Furthermore, the codebase may be easier to maintain, since updating a prototype is much less error prone than jumping around in the codebase to update all the snippets copied and pasted around to initialize entities and components.

    -

    +

    Helpers

    The so called helpers are small classes and functions mainly designed to offer built-in support for the most basic functionalities.
    The list of helpers will grow longer as time passes and new ideas come out.

    -

    +

    Dependency function

    A dependency function is a predefined listener, actually a function template to use to automatically assign components to an entity when a type has a dependency on some other types.
    The following adds components AType and AnotherType whenever MyType is assigned to an entity:

    entt::dependency<AType, AnotherType>(registry.construction<MyType>());

    A component is assigned to an entity and thus default initialized only in case the entity itself hasn't it yet. It means that already existent components won't be overriden.
    A dependency can easily be broken by means of the same function template:

    -
    entt::dependency<AType, AnotherType>(entt::break_t{}, registry.construction<MyType>());

    +
    entt::dependency<AType, AnotherType>(entt::break_t{}, registry.construction<MyType>());

    +Labels

    +

    There's nothing magical about the way labels can be assigned to entities while avoiding a performance hit at runtime. Nonetheless, the syntax can be annoying and that's why a more user-friendly shortcut is provided to do it.
    + This shortcut is the alias template entt::label.

    +

    If used in combination with hashed strings, it helps to use labels where types would be required otherwise. As an example:

    +
    registry.assign<entt::label<"enemy"_hs>>(entity);

    Null entity

    In EnTT, there exists a sort of null entity made available to users that is accessible via the entt::null variable.
    - The framework guarantees that the following expression always returns false:

    + The library guarantees that the following expression always returns false:

    registry.valid(entt::null);

    In other terms, a registry will reject the null entity in all cases because it isn't considered valid. It means that the null entity cannot own components or tags for obvious reasons.
    The type of the null entity is internal and should not be used for any purpose other than defining the null entity itself. However, there exist implicit conversions from the null entity to identifiers of any allowed type:

    typename entt::DefaultRegistry::entity_type null = entt::null;

    Similarly, the null entity can be compared to any other identifier:

    -
    const auto entity = registry.create();
    const bool null = (entity == entt::null);

    +
    const auto entity = registry.create();
    const bool null = (entity == entt::null);

    View: to persist or not to persist?

    First of all, it is worth answering an obvious question: why views?
    Roughly speaking, they are a good tool to enforce single responsibility. A system that has access to a registry can create and destroy entities, as well as assign and remove components. On the other side, a system that has access to a view can only iterate entities and their components, then read or update the data members of the latter.
    @@ -565,13 +487,13 @@ View: to persist or not to persist?

    To easily iterate entities and components, all the views offer the common begin and end member functions that allow users to use a view in a typical range-for loop. Almost all the views offer also a more functional each member function that accepts a callback for convenience.
    Continue reading for more details or refer to the inline documentation.

    -

    +

    Standard View

    A standard view behaves differently if it's constructed for a single component or if it has been requested to iterate multiple components. Even the API is different in the two cases.
    All that they share is the way they are created by means of a registry:

    // single component standard view
    auto single = registry.view<Position>();
    // multi component standard view
    auto multi = registry.view<Position, Velocity>();

    For all that remains, it's worth discussing them separately.

    -

    +

    Single component standard view

    Single component standard views are specialized in order to give a boost in terms of performance in all the situation. This kind of views can access the underlying data structures directly and avoid superfluous checks.
    They offer a bunch of functionalities to get the number of entities they are going to return and a raw access to the entity list as well as to the component list. It's also possible to ask a view if it contains a given entity.
    @@ -581,7 +503,7 @@ Single component standard view

    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) {
    // ...
    });

    The each member function is highly optimized. Unless users want to iterate only entities, using each should be the preferred approach.

    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.

    -

    +

    Multi component standard view

    Multi component standard views iterate entities that have at least all the given components in their bags. During construction, these views look at the number of entities available for each component and pick up a reference to the smallest set of candidates in order to speed up iterations.
    They offer fewer functionalities than their companion views for single component. In particular, a multi component standard view exposes utility functions to get the estimated number of entities it is going to return and to know whether it's empty or not. It's also possible to ask a view if it contains a given entity.
    @@ -591,7 +513,7 @@ Multi component standard view

    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) {
    // ...
    });

    The each member function is highly optimized. Unless users want to iterate only entities or get only some of the components, using each should be the preferred approach.

    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.

    -

    +

    Persistent View

    A persistent view returns all the entities and only the entities that have at least the given components. Moreover, it's guaranteed that the entity list is tightly packed in memory for fast iterations.
    In general, persistent views don't stay true to the order of any set of components unless users explicitly sort them.

    @@ -605,7 +527,7 @@ Persistent View
    auto view = registry.view<Position, Velocity>(entt::persistent_t{});
    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>(entt::persistent_t{}).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.

    -

    +

    Raw View

    Raw views return all the components of a given type. This kind of views can access components directly and avoid extra indirections like when components are accessed via an entity identifier.
    They offer a bunch of functionalities to get the number of instances they are going to return and a raw access to the entity list as well as to the component list.
    @@ -616,7 +538,7 @@ Raw View

    auto view = registry.view<Renderable>(entt::raw_t{});
    for(auto &&component: raw) {
    // ...
    }

    Or rely on the each member function:

    registry.view<Renderable>(entt::raw_t{}).each([](auto &renderable) {
    // ...
    });

    Performance are exactly the same in both cases.

    Note: raw views don't have a get member function for obvious reasons.

    -

    +

    Runtime View

    Runtime views iterate entities that have at least all the given components in their bags. During construction, these views look at the number of entities available for each component and pick up a reference to the smallest set of candidates in order to speed up iterations.
    They offer more or less the same functionalities of a multi component standard view. However, they don't expose a get member function and users should refer to the registry that generated the view to access components. In particular, a runtime view exposes utility functions to get the estimated number of entities it is going to return and to know whether it's empty or not. It's also possible to ask a view if it contains a given entity.
    @@ -626,7 +548,7 @@ Runtime View

    using component_type = typename decltype(registry)::component_type;
    component_type types[] = { registry.type<Position>(), registry.type<Velocity>() };
    auto view = registry.view(std::cbegin(types), std::cend(types));
    for(auto entity: view) {
    // a component at a time ...
    Position &position = registry.get<Position>(entity);
    Velocity &velocity = registry.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:

    using component_type = typename decltype(registry)::component_type;
    component_type types[] = { registry.type<Position>(), registry.type<Velocity>() };
    auto view = registry.view(std::cbegin(types), std::cend(types)).each([](auto entity) {
    // ...
    });

    Performance are exactly the same in both cases.

    Note: runtime views are meant for all those cases where users don't know at compile-time what components to use to iterate entities. This is particularly well suited to plugin systems and mods in general. Where possible, don't use runtime views, as their performance are slightly inferior to those of the other views.

    -

    +

    Give me everything

    Views are narrow windows on the entire list of entities. They work by filtering entities according to their components.
    In some cases there may be the need to iterate all the entities still in use regardless of their components. The registry offers a specific member function to do that:

    @@ -638,7 +560,7 @@ Give me everything
    registry.orphans([](auto entity) {
    // ...
    });

    To test the orphanity of a single entity, use the member function orphan instead. It accepts a valid entity identifer as an argument and returns true in case the entity is an orphan, false otherwise.

    In general, all these functions can result in poor performance.
    each is fairly slow because of some checks it performs on each and every entity. For similar reasons, orphans can be even slower. Both functions should not be used frequently to avoid the risk of a performance hit.

    -

    +

    Iterations: what is allowed and what is not

    Most of the ECS available out there have some annoying limitations (at least from my point of view): entities and components cannot be created nor destroyed during iterations.
    EnTT partially solves the problem with a few limitations:

    @@ -653,7 +575,7 @@ Iterations: what is allowed and what is not
  • Mark entities and components with a proper tag component that indicates they must be purged, then perform a second iteration to clean them up one by one.

    • A notable side effect of this feature is that the number of required allocations is further reduced in most of the cases.

    -

    +

    Multithreading

    In general, the entire registry isn't thread safe as it is. Thread safety isn't something that users should want out of the box for several reasons. Just to mention one of them: performance.
    Views and consequently the approach adopted by EnTT are the great exception to the rule. It's true that views and thus their iterators aren't thread safe by themselves. Because of this users shouldn't try to iterate a set of components and modify the same set concurrently. However:

    @@ -663,11 +585,11 @@ Multithreading

    This kind of entity-component systems can be used in single threaded applications as well as along with async stuff or multiple threads. Moreover, typical thread based models for ECS don't require a fully thread safe registry to work. Actually, users can reach the goal with the registry as it is while working with most of the common models.

    Because of the few reasons mentioned above and many others not mentioned, users are completely responsible for synchronization whether required. On the other hand, they could get away with it without having to resort to particular expedients.

    -

    +

    Crash Course: core functionalities

    -

    The EnTT framework comes with a bunch of core functionalities mostly used by the other parts of the library itself.
    - Hardly users of the framework will include these features in their code, but it's worth describing what EnTT offers so as not to reinvent the wheel in case of need.

    -

    +

    EnTT comes with a bunch of core functionalities mostly used by the other parts of the library itself.
    + Hardly users will include these features in their code, but it's worth describing what EnTT offers so as not to reinvent the wheel in case of need.

    +

    Compile-time identifiers

    Sometimes it's useful to be able to give unique identifiers to types at compile-time.
    There are plenty of different solutions out there and I could have used one of them. However, I decided to spend my time to define a compact and versatile tool that fully embraces what the modern C++ has to offer.

    @@ -675,30 +597,31 @@ Compile-time identifiers
    #include <ident.hpp>
    // defines the identifiers for the given types
    using ID = entt::Identifier<AType, AnotherType>;
    // ...
    switch(aTypeIdentifier) {
    case ID::get<AType>():
    // ...
    break;
    case ID::get<AnotherType>():
    // ...
    break;
    default:
    // ...
    }

    This is all what the class template has to offer: a static get member function that returns a numerical identifier for the given type. It can be used in any context where constant expressions are required.

    As long as the list remains unchanged, identifiers are also guaranteed to be the same for every run. In case they have been used in a production environment and a type has to be removed, one can just use a placeholder to left the other identifiers unchanged:

    template<typename> struct IgnoreType {};
    using ID = entt::Identifier<
    ATypeStillValid,
    IgnoreType<ATypeNoLongerValid>,
    AnotherTypeStillValid
    >;

    A bit ugly to see, but it works at least.

    -

    +

    Runtime identifiers

    Sometimes it's useful to be able to give unique identifiers to types at runtime.
    - There are plenty of different solutions out there and I could have used one of them. In fact, I adapted the most common one to my requirements and used it extensively within the entire framework.

    + There are plenty of different solutions out there and I could have used one of them. In fact, I adapted the most common one to my requirements and used it extensively within the entire library.

    It's the Family class. Here is an example of use directly from the entity-component system:

    using component_family = entt::Family<struct InternalRegistryComponentFamily>;
    // ...
    template<typename Component>
    component_type component() const noexcept {
    return component_family::type<Component>();
    }

    This is all what a family has to offer: a type member function that returns a numerical identifier for the given type.

    Please, note that identifiers aren't guaranteed to be the same for every run. Indeed it mostly depends on the flow of execution.

    -

    +

    Hashed strings

    A hashed string is a zero overhead resource identifier. Users can use human-readable identifiers in the codebase while using their numeric counterparts at runtime, thus without affecting performance.
    The class has an implicit constexpr constructor that chews a bunch of characters. Once created, all what one can do with it is getting back the original string or converting it into a number.
    The good part is that a hashed string can be used wherever a constant expression is required and no string-to-number conversion will take place at runtime if used carefully.

    Example of use:

    -
    auto load(entt::HashedString::hash_type resource) {
    // uses the numeric representation of the resource to load and return it
    }
    auto resource = load(entt::HashedString{"gui/background"});

    +
    auto load(entt::HashedString::hash_type resource) {
    // uses the numeric representation of the resource to load and return it
    }
    auto resource = load(entt::HashedString{"gui/background"});

    There is also a user defined literal dedicated to hashed strings to make them more user-friendly:

    +
    constexpr auto str = "text"_hs;

    Conflicts

    The hashed string class uses internally FNV-1a to compute the numeric counterpart of a string. Because of the pigeonhole principle, conflicts are possible. This is a fact.
    There is no silver bullet to solve the problem of conflicts when dealing with hashing functions. In this case, the best solution seemed to be to give up. That's all.
    After all, human-readable resource identifiers aren't something strictly defined and over which users have not the control. Choosing a slightly different identifier is probably the best solution to make the conflict disappear in this case.

    -

    +

    Monostate

    The monostate pattern is often presented as an alternative to a singleton based configuration system. This is exactly its purpose in EnTT. Moreover, this implementation is thread safe by design (hopefully).
    Keys are represented by hashed strings, values are basic types like ints or bools. Values of different types can be associated to each key, even more than one at a time. Because of this, users must pay attention to use the same type both during an assignment and when they try to read back their data. Otherwise, they will probably incur in unexpected results.

    Example of use:

    -
    entt::Monostate<entt::HashedString{"mykey"}>{} = true;
    entt::Monostate<"mykey"_hs>{} = 42;
    // ...
    const bool b = entt::Monostate<"mykey"_hs>{};
    const int i = entt::Monostate<entt::HashedString{"mykey"}>{};

    +
    entt::Monostate<entt::HashedString{"mykey"}>{} = true;
    entt::Monostate<"mykey"_hs>{} = 42;
    // ...
    const bool b = entt::Monostate<"mykey"_hs>{};
    const int i = entt::Monostate<entt::HashedString{"mykey"}>{};

    Crash Course: service locator

    Usually service locators are tightly bound to the services they expose and it's hard to define a general purpose solution. This template based implementation tries to fill the gap and to get rid of the burden of defining a different specific locator for each application.
    This class is tiny, partially unsafe and thus risky to use. Moreover it doesn't fit probably most of the scenarios in which a service locator is required. Look at it as a small tool that can sometimes be useful if the user knows how to handle it.

    @@ -706,11 +629,11 @@ Crash Course: service locator The locator is instantiated with the base type of the service if any and a concrete implementation is provided along with all the parameters required to initialize it. As an example:

    // the service has no base type, a locator is used to treat it as a kind of singleton
    entt::ServiceLocator<MyService>::set(params...);
    // sets up an opaque service
    entt::ServiceLocator<AudioInterface>::set<AudioImplementation>(params...);
    // resets (destroys) the service
    entt::ServiceLocator<AudioInterface>::reset();

    The locator can also be queried to know if an active service is currently set and to retrieve it if necessary (either as a pointer or as a reference):

    // no service currently set
    auto empty = entt::ServiceLocator<AudioInterface>::empty();
    // gets a (possibly empty) shared pointer to the service ...
    std::shared_ptr<AudioInterface> ptr = entt::ServiceLocator<AudioInterface>::get();
    // ... or a reference, but it's undefined behaviour if the service isn't set yet
    AudioInterface &ref = entt::ServiceLocator<AudioInterface>::ref();

    A common use is to wrap the different locators in a container class, creating aliases for the various services:

    -
    struct Locator {
    using Camera = entt::ServiceLocator<CameraInterface>;
    using Audio = entt::ServiceLocator<AudioInterface>;
    // ...
    };
    // ...
    void init() {
    Locator::Camera::set<CameraNull>();
    Locator::Audio::set<AudioImplementation>(params...);
    // ...
    }

    +
    struct Locator {
    using Camera = entt::ServiceLocator<CameraInterface>;
    using Audio = entt::ServiceLocator<AudioInterface>;
    // ...
    };
    // ...
    void init() {
    Locator::Camera::set<CameraNull>();
    Locator::Audio::set<AudioImplementation>(params...);
    // ...
    }

    Crash Course: cooperative scheduler

    Sometimes processes are a useful tool to work around the strict definition of a system and introduce logic in a different way, usually without resorting to the introduction of other components.

    -

    The EnTT framework offers a minimal support to this paradigm by introducing a few classes that users can use to define and execute cooperative processes.

    -

    +

    EnTT offers a minimal support to this paradigm by introducing a few classes that users can use to define and execute cooperative processes.

    +

    The process

    A typical process must inherit from the Process class template that stays true to the CRTP idiom. Moreover, derived classes must specify what's the intended type for elapsed times.

    A process should expose publicly the following member functions whether required (note that it isn't required to define a function unless the derived class wants to override the default behavior):

    @@ -733,7 +656,7 @@ The process

    Derived classes can also change the internal state of a process by invoking succeed and fail, as well as pause and unpause the process itself. All these are protected member functions made available to be able to manage the life cycle of a process from a derived class.

    Here is a minimal example for the sake of curiosity:

    -
    struct MyProcess: entt::Process<MyProcess, std::uint32_t> {
    using delta_type = std::uint32_t;
    void update(delta_type delta, void *) {
    remaining = delta > remaining ? delta_type{] : (remaining - delta);
    // ...
    if(!remaining) {
    succeed();
    }
    }
    void init(void *data) {
    remaining = *static_cast<delta_type *>(data);
    }
    private:
    delta_type remaining;
    };

    +
    struct MyProcess: entt::Process<MyProcess, std::uint32_t> {
    using delta_type = std::uint32_t;
    void update(delta_type delta, void *) {
    remaining = delta > remaining ? delta_type{] : (remaining - delta);
    // ...
    if(!remaining) {
    succeed();
    }
    }
    void init(void *data) {
    remaining = *static_cast<delta_type *>(data);
    }
    private:
    delta_type remaining;
    };

    Adaptor

    Lambdas and functors can't be used directly with a scheduler for they are not properly defined processes with managed life cycles.
    This class helps in filling the gap and turning lambdas and functors into full featured processes usable by a scheduler.

    @@ -747,7 +670,7 @@ Adaptor

    Both succeed and fail accept no parameters at all.

    Note that usually users shouldn't worry about creating adaptors at all. A scheduler creates them internally each and every time a lambda or a functor is used as a process.

    -

    +

    The scheduler

    A cooperative scheduler runs different processes and helps managing their life cycles.

    Each process is invoked once per tick. If it terminates, it's removed automatically from the scheduler and it's never invoked again. Otherwise it's a good candidate to run once more the next tick.
    @@ -765,13 +688,13 @@ The scheduler As a minimal example of use:

    // schedules a task in the form of a lambda function
    scheduler.attach([](auto delta, void *, auto succeed, auto fail) {
    // ...
    })
    // appends a child in the form of another lambda function
    .then([](auto delta, void *, auto succeed, auto fail) {
    // ...
    })
    // appends a child in the form of a process class
    .then<MyProcess>();

    To update a scheduler and thus all its processes, the update member function is the way to go:

    // updates all the processes, no user data are provided
    scheduler.update(delta);
    // updates all the processes and provides them with custom data
    scheduler.update(delta, &data);

    In addition to these functions, the scheduler offers an abort member function that can be used to discard all the running processes at once:

    -
    // aborts all the processes abruptly ...
    scheduler.abort(true);
    // ... or gracefully during the next tick
    scheduler.abort();

    +
    // aborts all the processes abruptly ...
    scheduler.abort(true);
    // ... or gracefully during the next tick
    scheduler.abort();

    Crash Course: resource management

    Resource management is usually one of the most critical part of a software like a game. Solutions are often tuned to the particular application. There exist several approaches and all of them are perfectly fine as long as they fit the requirements of the piece of software in which they are used.
    Examples are loading everything on start, loading on request, predictive loading, and so on.

    -

    The EnTT framework doesn't pretend to offer a one-fits-all solution for the different cases. Instead, it offers a minimal and perhaps trivial cache that can be useful most of the time during prototyping and sometimes even in a production environment.
    +

    EnTT doesn't pretend to offer a one-fits-all solution for the different cases. Instead, it offers a minimal and perhaps trivial cache that can be useful most of the time during prototyping and sometimes even in a production environment.
    For those interested in the subject, the plan is to improve it considerably over time in terms of performance, memory usage and functionalities. Hoping to make it, of course, one step at a time.

    -

    +

    The resource, the loader and the cache

    There are three main actors in the model: the resource, the loader and the cache.

    The resource is whatever the user wants it to be. An image, a video, an audio, whatever. There are no limits.
    @@ -815,14 +738,14 @@ The resource, the loader and the cache

    if(handle) {
    // ...
    }

    Finally, in case there is the need to load a resource and thus to get a handle without storing the resource itself in the cache, users can rely on the temp member function template.
    The declaration is similar to the one of load but for the fact that it doesn't return a boolean value. Instead, it returns a (possibly invalid) handle for the resource:

    auto handle = cache.temp<MyLoader>("another/identifier", 42);

    Do not forget to test the handle for validity. Otherwise, getting the reference to the resource it points may result in undefined behavior.

    -

    +

    Crash Course: events, signals and everything in between

    Signals are usually a core part of games and software architectures in general.
    Roughly speaking, they help to decouple the various parts of a system while allowing them to communicate with each other somehow.

    The so called _modern C++_ comes with a tool that can be useful in these terms, the std::function. As an example, it can be used to create delegates.
    However, there is no guarantee that an std::function does not perform allocations under the hood and this could be problematic sometimes. Furthermore, it solves a problem but may not adapt well to other requirements that may arise from time to time.

    -

    In case that the flexibility and potential of an std::function are not required or where you are looking for something different, the EnTT framework offers a full set of classes to solve completely different problems.

    -

    +

    In case that the flexibility and potential of an std::function are not required or where you are looking for something different, EnTT offers a full set of classes to solve completely different problems.

    +

    Signals

    Signal handlers work with naked pointers, function pointers and pointers to member functions. Listeners can be any kind of objects and the user is in charge of connecting and disconnecting them from a signal to avoid crashes due to different lifetimes. On the other side, performance shouldn't be affected that much by the presence of such a signal handler.
    A signal handler can be used as a private data member without exposing any publish functionality to the clients of a class. The basic idea is to impose a clear separation between the signal itself and its sink class, that is a tool to be used to connect and disconnect listeners on the fly.

    @@ -835,7 +758,7 @@ Signals
    void foo(int, char) { /* ... */ }
    struct S {
    void bar(int, char) { /* ... */ }
    };
    // ...
    S instance;
    signal.sink().connect<&foo>();
    signal.sink().connect<S, &S::bar>(&instance);
    // ...
    // disconnects a free function
    signal.sink().disconnect<&foo>();
    // disconnect a specific member function of an instance ...
    signal.sink().disconnect<S, &S::bar>(&instance);
    // ... or an instance as a whole
    signal.sink().disconnect(&instance);
    // discards all the listeners at once
    signal.sink().disconnect();

    Once listeners are attached (or even if there are no listeners at all), events and data in general can be published through a signal by means of the publish member function:

    signal.publish(42, 'c');

    To collect data, the collect member function should be used instead. Below is a minimal example to show how to use it:

    struct MyCollector {
    std::vector<int> vec{};
    bool operator()(int v) noexcept {
    vec.push_back(v);
    return true;
    }
    };
    int f() { return 0; }
    int g() { return 1; }
    // ...
    entt::SigH<int(), MyCollector<int>> signal;
    signal.sink().connect<&f>();
    signal.sink().connect<&g>();
    MyCollector collector = signal.collect();
    assert(collector.vec[0] == 0);
    assert(collector.vec[1] == 1);

    As shown above, a collector must expose a function operator that accepts as an argument a type to which the return type of the listeners can be converted. Moreover, it has to return a boolean value that is false to stop collecting data, true otherwise. This way one can avoid calling all the listeners in case it isn't necessary.

    -

    +

    Delegate

    A delegate can be used as general purpose invoker with no memory overhead for free functions and member functions provided along with an instance on which to invoke them.
    It does not claim to be a drop-in replacement for an std::function, so do not expect to use it whenever an std::function fits well. However, it can be used to send opaque delegates around to be used to invoke functions as needed.

    @@ -846,8 +769,8 @@ Delegate
    int f(int i) { return i; }
    struct MyStruct {
    int f(int i) { return i }
    };
    // bind a free function to the delegate
    delegate.connect<&f>();
    // bind a member function to the delegate
    MyStruct instance;
    delegate.connect<MyStruct, &MyStruct::f>(&instance);

    It hasn't a disconnect counterpart. Instead, there exists a reset member function to clear it.
    The empty member function can be used to know if a delegate is empty:

    const auto empty = delegate.empty();

    Finally, to invoke a delegate, the function call operator is the way to go as usual:

    -
    auto ret = delegate(42);

    Probably too much small and pretty poor of functionalities, but the delegate class can help in a lot of cases and it has shown that it is worth keeping it within the framework.

    -

    +
    auto ret = delegate(42);

    Probably too much small and pretty poor of functionalities, but the delegate class can help in a lot of cases and it has shown that it is worth keeping it within the library.

    +

    Event dispatcher

    The event dispatcher class is designed so as to be used in a loop. It allows users both to trigger immediate events or to queue events to be published all together once per tick.
    This class shares part of its API with the one of the signal handler, but it doesn't require that all the types of events are specified when declared:

    @@ -860,7 +783,7 @@ Event dispatcher

    On the other hand, the enqueue member function queues messages together and allows to maintain control over the moment they are sent to listeners. The signature of this method is more or less the same of trigger:

    dispatcher.enqueue<AnEvent>(42);
    dispatcher.enqueue<AnotherEvent>();

    Events are stored aside until the update member function is invoked, then all the messages that are still pending are sent to the listeners at once:

    // emits all the events of the given type at once
    dispatcher.update<MyEvent>();
    // emits all the events queued so far at once
    dispatcher.update();

    This way users can embed the dispatcher in a loop and literally dispatch events once per tick to their systems.

    -

    +

    Event emitter

    A general purpose event emitter thought mainly for those cases where it comes to working with asynchronous stuff.
    Originally designed to fit the requirements of uvw (a wrapper for libuv written in modern C++), it was adapted later to be included in this library.

    @@ -888,7 +811,7 @@ Event emitter
    // removes all the listener for the specific event
    emitter.clear<MyEvent>();
    // removes all the listeners registered so far
    emitter.clear();

    To send an event to all the listeners that are interested in it, the publish member function offers a convenient approach that relieves the user from having to create the event:

    struct MyEvent { int i; };
    // ...
    emitter.publish<MyEvent>(42);

    Finally, the empty member function tests if there exists at least either a listener registered with the event emitter or to a given type of event:

    bool empty;
    // checks if there is any listener registered for the specific event
    empty = emitter.empty<MyEvent>();
    // checks it there are listeners registered with the event emitter
    empty = emitter.empty();

    In general, the event emitter is a handy tool when the derived classes wrap asynchronous operations, because it introduces a nice-to-have model based on events and listeners that kindly hides the complexity behind the scenes. However it is not limited to such uses.

    -

    +

    Packaging Tools

    EnTT is available for some of the most known packaging tools. In particular:

      @@ -897,13 +820,15 @@ Packaging Tools Available as a homebrew formula. Just type the following to install it:
      brew install skypjack/entt/entt

    Consider this list a work in progress and help me to make it longer.

    -

    +

    EnTT in Action

    EnTT is widely used in private and commercial applications. I cannot even mention most of them because of some signatures I put on some documents time ago.
    Fortunately, there are also people who took the time to implement open source projects based on EnTT and did not hold back when it came to documenting them.

    Below an incomplete list of projects and articles:

    If you know of other resources out there that are about EnTT, feel free to open an issue or a PR and I'll be glad to add them to the list.

    -

    -Contributors

    -

    If you want to participate, please see the guidelines for contributing before to create issues or pull requests.
    - Take also a look at the contributors list to know who has participated so far.

    -

    +

    License

    -

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

    -

    -Support

    -

    -Donation

    -

    Developing and maintaining EnTT takes some time and lots of coffee. I'd like to add more and more functionalities in future and turn it in a full-featured framework.
    - If you want to support this project, you can offer me an espresso. I'm from Italy, we're used to turning the best coffee ever in code. If you find that it's not enough, feel free to support me the way you prefer.
    - Take a look at the donation button at the top of the page for more details or just click here.

    -

    -Hire me

    -

    If you start using EnTT and need help, if you want a new feature and want me to give it the highest priority, if you have any other reason to contact me: do not hesitate. I'm available for hiring.
    - Feel free to take a look at my profile and contact me by mail.

    +

    Code and documentation Copyright (c) 2017-2018 Michele Caini.
    + Logo Copyright (c) 2018 Richard Caseres.

    +

    Code released under the MIT license. Documentation released under CC BY 4.0.
    + Logo released under CC BY-SA 4.0.

    diff --git a/inherit_graph_17.map b/inherit_graph_17.map index 68b105f9f..7aef5d7c1 100644 --- a/inherit_graph_17.map +++ b/inherit_graph_17.map @@ -1,3 +1,3 @@ - + diff --git a/inherit_graph_17.md5 b/inherit_graph_17.md5 index b4cc67996..432af4f8d 100644 --- a/inherit_graph_17.md5 +++ b/inherit_graph_17.md5 @@ -1 +1 @@ -20c874a300d88122441dac8e77bf11e8 \ No newline at end of file +4f41409bd2b6db723b3ecd9e2b752c70 \ No newline at end of file diff --git a/inherit_graph_17.png b/inherit_graph_17.png index 6ce02376d..c2668d595 100644 Binary files a/inherit_graph_17.png and b/inherit_graph_17.png differ diff --git a/inherit_graph_18.map b/inherit_graph_18.map index f59ca3c15..68b105f9f 100644 --- a/inherit_graph_18.map +++ b/inherit_graph_18.map @@ -1,3 +1,3 @@ - + diff --git a/inherit_graph_18.md5 b/inherit_graph_18.md5 index 9e985e6b1..b4cc67996 100644 --- a/inherit_graph_18.md5 +++ b/inherit_graph_18.md5 @@ -1 +1 @@ -68c3f1d2aaee71c81615b1ee951d2af7 \ No newline at end of file +20c874a300d88122441dac8e77bf11e8 \ No newline at end of file diff --git a/inherit_graph_18.png b/inherit_graph_18.png index 924d0c1dc..6ce02376d 100644 Binary files a/inherit_graph_18.png and b/inherit_graph_18.png differ diff --git a/inherit_graph_19.map b/inherit_graph_19.map index 65672c65c..f59ca3c15 100644 --- a/inherit_graph_19.map +++ b/inherit_graph_19.map @@ -1,3 +1,3 @@ - + diff --git a/inherit_graph_19.md5 b/inherit_graph_19.md5 index 95847419f..9e985e6b1 100644 --- a/inherit_graph_19.md5 +++ b/inherit_graph_19.md5 @@ -1 +1 @@ -c978a805ca3e2559509fb10fb22ba569 \ No newline at end of file +68c3f1d2aaee71c81615b1ee951d2af7 \ No newline at end of file diff --git a/inherit_graph_19.png b/inherit_graph_19.png index bfd542e06..924d0c1dc 100644 Binary files a/inherit_graph_19.png and b/inherit_graph_19.png differ diff --git a/inherit_graph_20.map b/inherit_graph_20.map index 406d96210..65672c65c 100644 --- a/inherit_graph_20.map +++ b/inherit_graph_20.map @@ -1,4 +1,3 @@ - - + diff --git a/inherit_graph_20.md5 b/inherit_graph_20.md5 index 79029b2fd..95847419f 100644 --- a/inherit_graph_20.md5 +++ b/inherit_graph_20.md5 @@ -1 +1 @@ -4d9979ed2fcc17345a05e91549c6f353 \ No newline at end of file +c978a805ca3e2559509fb10fb22ba569 \ No newline at end of file diff --git a/inherit_graph_20.png b/inherit_graph_20.png index 7d998f344..bfd542e06 100644 Binary files a/inherit_graph_20.png and b/inherit_graph_20.png differ diff --git a/inherit_graph_21.map b/inherit_graph_21.map index 0ec2cbabf..406d96210 100644 --- a/inherit_graph_21.map +++ b/inherit_graph_21.map @@ -1,3 +1,4 @@ - + + diff --git a/inherit_graph_21.md5 b/inherit_graph_21.md5 index 96a74eaf2..3314079fc 100644 --- a/inherit_graph_21.md5 +++ b/inherit_graph_21.md5 @@ -1 +1 @@ -8717e582ab01906c25cce74e94efc8ba \ No newline at end of file +1457846e47d2afc06e84994cd00835ca \ No newline at end of file diff --git a/inherit_graph_21.png b/inherit_graph_21.png index 8001af7f7..7d998f344 100644 Binary files a/inherit_graph_21.png and b/inherit_graph_21.png differ diff --git a/inherit_graph_22.map b/inherit_graph_22.map index 4a54762fb..0ec2cbabf 100644 --- a/inherit_graph_22.map +++ b/inherit_graph_22.map @@ -1,3 +1,3 @@ - + diff --git a/inherit_graph_22.md5 b/inherit_graph_22.md5 index cee282778..96a74eaf2 100644 --- a/inherit_graph_22.md5 +++ b/inherit_graph_22.md5 @@ -1 +1 @@ -290a5b9298ed0c6980ce61d3800f8661 \ No newline at end of file +8717e582ab01906c25cce74e94efc8ba \ No newline at end of file diff --git a/inherit_graph_22.png b/inherit_graph_22.png index d4e6d5031..8001af7f7 100644 Binary files a/inherit_graph_22.png and b/inherit_graph_22.png differ diff --git a/inherit_graph_23.map b/inherit_graph_23.map index 6aba09019..4a54762fb 100644 --- a/inherit_graph_23.map +++ b/inherit_graph_23.map @@ -1,3 +1,3 @@ - + diff --git a/inherit_graph_23.md5 b/inherit_graph_23.md5 index e148f959b..cee282778 100644 --- a/inherit_graph_23.md5 +++ b/inherit_graph_23.md5 @@ -1 +1 @@ -9a33b8231c878d5e6ebdbdd360973b53 \ No newline at end of file +290a5b9298ed0c6980ce61d3800f8661 \ No newline at end of file diff --git a/inherit_graph_23.png b/inherit_graph_23.png index 5250f1daa..d4e6d5031 100644 Binary files a/inherit_graph_23.png and b/inherit_graph_23.png differ diff --git a/inherit_graph_24.map b/inherit_graph_24.map index 9f5c41240..6aba09019 100644 --- a/inherit_graph_24.map +++ b/inherit_graph_24.map @@ -1,3 +1,3 @@ - + diff --git a/inherit_graph_24.md5 b/inherit_graph_24.md5 index 75b65452a..e148f959b 100644 --- a/inherit_graph_24.md5 +++ b/inherit_graph_24.md5 @@ -1 +1 @@ -4e394cd62968962a42441b4a70fd88e4 \ No newline at end of file +9a33b8231c878d5e6ebdbdd360973b53 \ No newline at end of file diff --git a/inherit_graph_24.png b/inherit_graph_24.png index d34389072..5250f1daa 100644 Binary files a/inherit_graph_24.png and b/inherit_graph_24.png differ diff --git a/inherit_graph_25.map b/inherit_graph_25.map index 35299d892..9f5c41240 100644 --- a/inherit_graph_25.map +++ b/inherit_graph_25.map @@ -1,3 +1,3 @@ - + diff --git a/inherit_graph_25.md5 b/inherit_graph_25.md5 index da199b4a4..75b65452a 100644 --- a/inherit_graph_25.md5 +++ b/inherit_graph_25.md5 @@ -1 +1 @@ -51bd2d62cec2bcbbf0df1dd79babf051 \ No newline at end of file +4e394cd62968962a42441b4a70fd88e4 \ No newline at end of file diff --git a/inherit_graph_25.png b/inherit_graph_25.png index c96052a26..d34389072 100644 Binary files a/inherit_graph_25.png and b/inherit_graph_25.png differ diff --git a/inherit_graph_26.map b/inherit_graph_26.map index 62d3a9d46..35299d892 100644 --- a/inherit_graph_26.map +++ b/inherit_graph_26.map @@ -1,3 +1,3 @@ - + diff --git a/inherit_graph_26.md5 b/inherit_graph_26.md5 index 6fed19d4c..da199b4a4 100644 --- a/inherit_graph_26.md5 +++ b/inherit_graph_26.md5 @@ -1 +1 @@ -79f5be431b4e27136879c42af4894284 \ No newline at end of file +51bd2d62cec2bcbbf0df1dd79babf051 \ No newline at end of file diff --git a/inherit_graph_26.png b/inherit_graph_26.png index bbb8862d7..c96052a26 100644 Binary files a/inherit_graph_26.png and b/inherit_graph_26.png differ diff --git a/inherit_graph_27.map b/inherit_graph_27.map index ee7694b54..62d3a9d46 100644 --- a/inherit_graph_27.map +++ b/inherit_graph_27.map @@ -1,3 +1,3 @@ - + diff --git a/inherit_graph_27.md5 b/inherit_graph_27.md5 index e363686c9..6fed19d4c 100644 --- a/inherit_graph_27.md5 +++ b/inherit_graph_27.md5 @@ -1 +1 @@ -b13e94c37667394c061cef177073e658 \ No newline at end of file +79f5be431b4e27136879c42af4894284 \ No newline at end of file diff --git a/inherit_graph_27.png b/inherit_graph_27.png index 37a607526..bbb8862d7 100644 Binary files a/inherit_graph_27.png and b/inherit_graph_27.png differ diff --git a/inherit_graph_28.map b/inherit_graph_28.map index 80abd0278..ee7694b54 100644 --- a/inherit_graph_28.map +++ b/inherit_graph_28.map @@ -1,3 +1,3 @@ - + diff --git a/inherit_graph_28.md5 b/inherit_graph_28.md5 index dbd2320db..e363686c9 100644 --- a/inherit_graph_28.md5 +++ b/inherit_graph_28.md5 @@ -1 +1 @@ -27181bb2a8663aecc220cf73a1a33ee4 \ No newline at end of file +b13e94c37667394c061cef177073e658 \ No newline at end of file diff --git a/inherit_graph_28.png b/inherit_graph_28.png index 616d06561..37a607526 100644 Binary files a/inherit_graph_28.png and b/inherit_graph_28.png differ diff --git a/inherit_graph_29.map b/inherit_graph_29.map index a8b498de3..80abd0278 100644 --- a/inherit_graph_29.map +++ b/inherit_graph_29.map @@ -1,3 +1,3 @@ - + diff --git a/inherit_graph_29.md5 b/inherit_graph_29.md5 index d815e7823..dbd2320db 100644 --- a/inherit_graph_29.md5 +++ b/inherit_graph_29.md5 @@ -1 +1 @@ -fcd13fd54c20a3b15b68df42f79e8750 \ No newline at end of file +27181bb2a8663aecc220cf73a1a33ee4 \ No newline at end of file diff --git a/inherit_graph_29.png b/inherit_graph_29.png index d5e41b427..616d06561 100644 Binary files a/inherit_graph_29.png and b/inherit_graph_29.png differ diff --git a/inherit_graph_30.map b/inherit_graph_30.map index f63e56225..a8b498de3 100644 --- a/inherit_graph_30.map +++ b/inherit_graph_30.map @@ -1,3 +1,3 @@ - + diff --git a/inherit_graph_30.md5 b/inherit_graph_30.md5 index 8f03789a1..d815e7823 100644 --- a/inherit_graph_30.md5 +++ b/inherit_graph_30.md5 @@ -1 +1 @@ -041e5c12848cb9cfed45decbf29ab84a \ No newline at end of file +fcd13fd54c20a3b15b68df42f79e8750 \ No newline at end of file diff --git a/inherit_graph_30.png b/inherit_graph_30.png index 3b0848620..d5e41b427 100644 Binary files a/inherit_graph_30.png and b/inherit_graph_30.png differ diff --git a/inherit_graph_31.map b/inherit_graph_31.map index 286c35707..f63e56225 100644 --- a/inherit_graph_31.map +++ b/inherit_graph_31.map @@ -1,3 +1,3 @@ - + diff --git a/inherit_graph_31.md5 b/inherit_graph_31.md5 index a6cb78e10..8f03789a1 100644 --- a/inherit_graph_31.md5 +++ b/inherit_graph_31.md5 @@ -1 +1 @@ -e0f7a1b094358c98dff7a3cba8246d13 \ No newline at end of file +041e5c12848cb9cfed45decbf29ab84a \ No newline at end of file diff --git a/inherit_graph_31.png b/inherit_graph_31.png index c561eac44..3b0848620 100644 Binary files a/inherit_graph_31.png and b/inherit_graph_31.png differ diff --git a/inherit_graph_32.map b/inherit_graph_32.map index 41d8fb1ad..286c35707 100644 --- a/inherit_graph_32.map +++ b/inherit_graph_32.map @@ -1,3 +1,3 @@ - + diff --git a/inherit_graph_32.md5 b/inherit_graph_32.md5 index 9bb2e0c64..a6cb78e10 100644 --- a/inherit_graph_32.md5 +++ b/inherit_graph_32.md5 @@ -1 +1 @@ -e261121843365a6714cf47f6436ea958 \ No newline at end of file +e0f7a1b094358c98dff7a3cba8246d13 \ No newline at end of file diff --git a/inherit_graph_32.png b/inherit_graph_32.png index c476458de..c561eac44 100644 Binary files a/inherit_graph_32.png and b/inherit_graph_32.png differ diff --git a/inherit_graph_33.map b/inherit_graph_33.map index 2c9d579f9..41d8fb1ad 100644 --- a/inherit_graph_33.map +++ b/inherit_graph_33.map @@ -1,3 +1,3 @@ - + diff --git a/inherit_graph_33.md5 b/inherit_graph_33.md5 index 7567b4969..dd247523d 100644 --- a/inherit_graph_33.md5 +++ b/inherit_graph_33.md5 @@ -1 +1 @@ -32f62226ed08bbc862cab90e19b0b664 \ No newline at end of file +5633fcb4ebba61ee9bcd12f9f1d7ccdc \ No newline at end of file diff --git a/inherit_graph_33.png b/inherit_graph_33.png index 6dc9a20bb..c476458de 100644 Binary files a/inherit_graph_33.png and b/inherit_graph_33.png differ diff --git a/inherit_graph_34.map b/inherit_graph_34.map index b0c28a377..2c9d579f9 100644 --- a/inherit_graph_34.map +++ b/inherit_graph_34.map @@ -1,3 +1,3 @@ - + diff --git a/inherit_graph_34.md5 b/inherit_graph_34.md5 index 9c537fb89..7567b4969 100644 --- a/inherit_graph_34.md5 +++ b/inherit_graph_34.md5 @@ -1 +1 @@ -38369dcd720ab0039d7bc3ae6bd935b7 \ No newline at end of file +32f62226ed08bbc862cab90e19b0b664 \ No newline at end of file diff --git a/inherit_graph_34.png b/inherit_graph_34.png index d7273b5ec..6dc9a20bb 100644 Binary files a/inherit_graph_34.png and b/inherit_graph_34.png differ diff --git a/inherit_graph_35.map b/inherit_graph_35.map index 7902bf72e..b0c28a377 100644 --- a/inherit_graph_35.map +++ b/inherit_graph_35.map @@ -1,3 +1,3 @@ - + diff --git a/inherit_graph_35.md5 b/inherit_graph_35.md5 index c66e60a30..9c537fb89 100644 --- a/inherit_graph_35.md5 +++ b/inherit_graph_35.md5 @@ -1 +1 @@ -452c0cc41e45b4a0855838fb8e7a10ff \ No newline at end of file +38369dcd720ab0039d7bc3ae6bd935b7 \ No newline at end of file diff --git a/inherit_graph_35.png b/inherit_graph_35.png index abac03b9a..d7273b5ec 100644 Binary files a/inherit_graph_35.png and b/inherit_graph_35.png differ diff --git a/inherit_graph_36.map b/inherit_graph_36.map index 85ec12751..7902bf72e 100644 --- a/inherit_graph_36.map +++ b/inherit_graph_36.map @@ -1,3 +1,3 @@ - + diff --git a/inherit_graph_36.md5 b/inherit_graph_36.md5 index affeb35a9..c66e60a30 100644 --- a/inherit_graph_36.md5 +++ b/inherit_graph_36.md5 @@ -1 +1 @@ -8abb22caca0c349e0d2a583fd575dc99 \ No newline at end of file +452c0cc41e45b4a0855838fb8e7a10ff \ No newline at end of file diff --git a/inherit_graph_36.png b/inherit_graph_36.png index f5b0eb482..abac03b9a 100644 Binary files a/inherit_graph_36.png and b/inherit_graph_36.png differ diff --git a/inherit_graph_37.map b/inherit_graph_37.map index c511abbe7..85ec12751 100644 --- a/inherit_graph_37.map +++ b/inherit_graph_37.map @@ -1,3 +1,3 @@ - + diff --git a/inherit_graph_37.md5 b/inherit_graph_37.md5 index da5341960..affeb35a9 100644 --- a/inherit_graph_37.md5 +++ b/inherit_graph_37.md5 @@ -1 +1 @@ -1fadc2ef69a803635ec75ea2c3f6a5f2 \ No newline at end of file +8abb22caca0c349e0d2a583fd575dc99 \ No newline at end of file diff --git a/inherit_graph_37.png b/inherit_graph_37.png index 270cb90fe..f5b0eb482 100644 Binary files a/inherit_graph_37.png and b/inherit_graph_37.png differ diff --git a/inherit_graph_38.map b/inherit_graph_38.map index b11003411..c511abbe7 100644 --- a/inherit_graph_38.map +++ b/inherit_graph_38.map @@ -1,4 +1,3 @@ - - + diff --git a/inherit_graph_38.md5 b/inherit_graph_38.md5 index c522d3c5e..da5341960 100644 --- a/inherit_graph_38.md5 +++ b/inherit_graph_38.md5 @@ -1 +1 @@ -8b49e5d4ab6821a094273ac533350361 \ No newline at end of file +1fadc2ef69a803635ec75ea2c3f6a5f2 \ No newline at end of file diff --git a/inherit_graph_38.png b/inherit_graph_38.png index 9c3ded490..270cb90fe 100644 Binary files a/inherit_graph_38.png and b/inherit_graph_38.png differ diff --git a/inherit_graph_39.map b/inherit_graph_39.map index 8b565bf7e..b11003411 100644 --- a/inherit_graph_39.map +++ b/inherit_graph_39.map @@ -1,3 +1,4 @@ - + + diff --git a/inherit_graph_39.md5 b/inherit_graph_39.md5 index b79b6846b..c522d3c5e 100644 --- a/inherit_graph_39.md5 +++ b/inherit_graph_39.md5 @@ -1 +1 @@ -621c711cd444e7dcd7b795f1703c5cd0 \ No newline at end of file +8b49e5d4ab6821a094273ac533350361 \ No newline at end of file diff --git a/inherit_graph_39.png b/inherit_graph_39.png index 3b9f3f3b9..9c3ded490 100644 Binary files a/inherit_graph_39.png and b/inherit_graph_39.png differ diff --git a/inherit_graph_40.map b/inherit_graph_40.map index f3f0e77bd..8b565bf7e 100644 --- a/inherit_graph_40.map +++ b/inherit_graph_40.map @@ -1,3 +1,3 @@ - + diff --git a/inherit_graph_40.md5 b/inherit_graph_40.md5 index 177fc5aa0..b79b6846b 100644 --- a/inherit_graph_40.md5 +++ b/inherit_graph_40.md5 @@ -1 +1 @@ -ed043cf7fc8e24545bbc5bcb24759660 \ No newline at end of file +621c711cd444e7dcd7b795f1703c5cd0 \ No newline at end of file diff --git a/inherit_graph_40.png b/inherit_graph_40.png index 5697d7f2a..3b9f3f3b9 100644 Binary files a/inherit_graph_40.png and b/inherit_graph_40.png differ diff --git a/inherit_graph_41.map b/inherit_graph_41.map index 8c48d78eb..f3f0e77bd 100644 --- a/inherit_graph_41.map +++ b/inherit_graph_41.map @@ -1,3 +1,3 @@ - + diff --git a/inherit_graph_41.md5 b/inherit_graph_41.md5 index cc16fa558..177fc5aa0 100644 --- a/inherit_graph_41.md5 +++ b/inherit_graph_41.md5 @@ -1 +1 @@ -38a5043984aa729fe65aca223c7ae6b5 \ No newline at end of file +ed043cf7fc8e24545bbc5bcb24759660 \ No newline at end of file diff --git a/inherit_graph_41.png b/inherit_graph_41.png index 1859301ff..5697d7f2a 100644 Binary files a/inherit_graph_41.png and b/inherit_graph_41.png differ diff --git a/inherit_graph_42.map b/inherit_graph_42.map index cd9cba107..8c48d78eb 100644 --- a/inherit_graph_42.map +++ b/inherit_graph_42.map @@ -1,3 +1,3 @@ - + diff --git a/inherit_graph_42.md5 b/inherit_graph_42.md5 index dcda05878..cc16fa558 100644 --- a/inherit_graph_42.md5 +++ b/inherit_graph_42.md5 @@ -1 +1 @@ -4dcecc0d02b196a20c46b12b739ad30e \ No newline at end of file +38a5043984aa729fe65aca223c7ae6b5 \ No newline at end of file diff --git a/inherit_graph_42.png b/inherit_graph_42.png index 0c5a70d46..1859301ff 100644 Binary files a/inherit_graph_42.png and b/inherit_graph_42.png differ diff --git a/inherit_graph_43.map b/inherit_graph_43.map index d4b0989d5..cd9cba107 100644 --- a/inherit_graph_43.map +++ b/inherit_graph_43.map @@ -1,3 +1,3 @@ - + diff --git a/inherit_graph_43.md5 b/inherit_graph_43.md5 index 054df0392..dcda05878 100644 --- a/inherit_graph_43.md5 +++ b/inherit_graph_43.md5 @@ -1 +1 @@ -e858ed2f3c399ac5179f89b14a40a3d7 \ No newline at end of file +4dcecc0d02b196a20c46b12b739ad30e \ No newline at end of file diff --git a/inherit_graph_44.map b/inherit_graph_44.map new file mode 100644 index 000000000..d4b0989d5 --- /dev/null +++ b/inherit_graph_44.map @@ -0,0 +1,3 @@ + + + diff --git a/inherit_graph_44.md5 b/inherit_graph_44.md5 new file mode 100644 index 000000000..054df0392 --- /dev/null +++ b/inherit_graph_44.md5 @@ -0,0 +1 @@ +e858ed2f3c399ac5179f89b14a40a3d7 \ No newline at end of file diff --git a/inherit_graph_44.png b/inherit_graph_44.png new file mode 100644 index 000000000..0c5a70d46 Binary files /dev/null and b/inherit_graph_44.png differ diff --git a/inherit_graph_7.md5 b/inherit_graph_7.md5 index 65a0cb47d..5d9098707 100644 --- a/inherit_graph_7.md5 +++ b/inherit_graph_7.md5 @@ -1 +1 @@ -40f4469fb7f11fef360e323dce4d8001 \ No newline at end of file +63a3599f7631c7b9ecde8ef690c60920 \ No newline at end of file diff --git a/inherits.html b/inherits.html index e375f5961..d5376ef40 100644 --- a/inherits.html +++ b/inherits.html @@ -5,7 +5,7 @@ -entt: Class Hierarchy +EnTT: Class Hierarchy @@ -21,8 +21,8 @@ -
    entt -  2.7.1 +
    EnTT +  2.7.2
    @@ -151,139 +151,144 @@ $(function() { - + + + + + + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + diff --git a/loader_8hpp_source.html b/loader_8hpp_source.html index 58f27ec6a..840907e84 100644 --- a/loader_8hpp_source.html +++ b/loader_8hpp_source.html @@ -5,7 +5,7 @@ -entt: src/entt/resource/loader.hpp Source File +EnTT: src/entt/resource/loader.hpp Source File @@ -21,8 +21,8 @@ -
    entt -  2.7.1 +
    EnTT +  2.7.2
    diff --git a/locator_8hpp_source.html b/locator_8hpp_source.html index a7d6ee2c9..924e8fdfa 100644 --- a/locator_8hpp_source.html +++ b/locator_8hpp_source.html @@ -5,7 +5,7 @@ -entt: src/entt/locator/locator.hpp Source File +EnTT: src/entt/locator/locator.hpp Source File @@ -21,8 +21,8 @@ -
    entt -  2.7.1 +
    EnTT +  2.7.2
    diff --git a/menudata.js b/menudata.js index eb678ef42..f1bfe6713 100644 --- a/menudata.js +++ b/menudata.js @@ -1,5 +1,6 @@ var menudata={children:[ {text:"Main Page",url:"index.html"}, +{text:"Related Pages",url:"pages.html"}, {text:"Namespaces",url:"namespaces.html",children:[ {text:"Namespace List",url:"namespaces.html"}, {text:"Namespace Members",url:"namespacemembers.html",children:[ diff --git a/monostate_8hpp_source.html b/monostate_8hpp_source.html index 48c4005f8..7da55103a 100644 --- a/monostate_8hpp_source.html +++ b/monostate_8hpp_source.html @@ -5,7 +5,7 @@ -entt: src/entt/core/monostate.hpp Source File +EnTT: src/entt/core/monostate.hpp Source File @@ -21,8 +21,8 @@ -
    entt -  2.7.1 +
    EnTT +  2.7.2
    diff --git a/namespaceentt.html b/namespaceentt.html index bb59b2108..255126c2d 100644 --- a/namespaceentt.html +++ b/namespaceentt.html @@ -5,7 +5,7 @@ -entt: entt Namespace Reference +EnTT: entt Namespace Reference @@ -21,8 +21,8 @@ -
    entt -  2.7.1 +
    EnTT +  2.7.2
    @@ -122,6 +122,9 @@ Classes struct  Monostate  Minimal implementation of the monostate pattern. More...
      +struct  OneShotBubbleSort + Function object for performing bubble sort (single iteration). More...
    +  struct  persistent_t  Persistent view type used to disambiguate overloads. More...
      @@ -209,6 +212,10 @@ Typedefs using DefaultActor = Actor< DefaultRegistry::entity_type >  Default actor class. More...
      +template<typename HashedString::hash_type Value> +using label = std::integral_constant< typename HashedString::hash_type, Value > + Alias template to ease the assignment of labels to entities. More...
    +  using DefaultPrototype = Prototype< DefaultRegistry::entity_type >  Default prototype. More...
      @@ -307,7 +314,34 @@ Variables

    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 1598 of file registry.hpp.

    +

    Definition at line 1623 of file registry.hpp.

    + +
    +
    + +

    ◆ label

    + +
    +
    +
    +template<typename HashedString::hash_type Value>
    + + + + +
    using entt::label = typedef std::integral_constant<typename HashedString::hash_type, Value>
    +
    + +

    Alias template to ease the assignment of labels to entities.

    +

    If used in combination with hashed strings, it simplifies the assignment of labels to entities and the use of labels in general where a type would be required otherwise.
    + As an example and where the user defined literal for hashed strings hasn't been changed:

    entt::DefaultRegistry registry;
    registry.assign<entt::label<"enemy"_hs>>(entity);
    Template Parameters
    + + +
    ValueThe numeric representation of an instance of hashed string.
    +
    +
    + +

    Definition at line 99 of file helper.hpp.

    @@ -359,7 +393,7 @@ template<typename Entity , typename... Component>
    -

    Definition at line 28 of file helper.hpp.

    +

    Definition at line 30 of file helper.hpp.

    @@ -397,7 +431,7 @@ template<typename... Dependency, typename Entity >
    -

    Definition at line 53 of file helper.hpp.

    +

    Definition at line 55 of file helper.hpp.

    @@ -445,7 +479,7 @@ template<typename... Dependency, typename Entity >
    -

    Definition at line 76 of file helper.hpp.

    +

    Definition at line 78 of file helper.hpp.

    diff --git a/namespacemembers.html b/namespacemembers.html index a60fd2667..daf84fec4 100644 --- a/namespacemembers.html +++ b/namespacemembers.html @@ -5,7 +5,7 @@ -entt: Namespace Members +EnTT: Namespace Members @@ -21,8 +21,8 @@ -
    entt -  2.7.1 +
    EnTT +  2.7.2
    @@ -72,6 +72,9 @@ $(function() {
  • dependency() : entt
    • +
  • label +: entt +
  • null : entt
    • diff --git a/namespacemembers_func.html b/namespacemembers_func.html index 270423e1d..15e2fc347 100644 --- a/namespacemembers_func.html +++ b/namespacemembers_func.html @@ -5,7 +5,7 @@ -entt: Namespace Members +EnTT: Namespace Members @@ -21,8 +21,8 @@ -
    entt -  2.7.1 +
    EnTT +  2.7.2
    diff --git a/namespacemembers_type.html b/namespacemembers_type.html index 75d0e51eb..7df67a5d3 100644 --- a/namespacemembers_type.html +++ b/namespacemembers_type.html @@ -5,7 +5,7 @@ -entt: Namespace Members +EnTT: Namespace Members @@ -21,8 +21,8 @@ -
    entt -  2.7.1 +
    EnTT +  2.7.2
    @@ -69,6 +69,9 @@ $(function() {
  • DefaultRegistry : entt
    • +
  • label +: entt +
    • diff --git a/namespacemembers_vars.html b/namespacemembers_vars.html index 5c0e3d8af..6b9ad81f2 100644 --- a/namespacemembers_vars.html +++ b/namespacemembers_vars.html @@ -5,7 +5,7 @@ -entt: Namespace Members +EnTT: Namespace Members @@ -21,8 +21,8 @@ -
    entt -  2.7.1 +
    EnTT +  2.7.2
    diff --git a/namespaces.html b/namespaces.html index 8f91d2b68..f4ffa563b 100644 --- a/namespaces.html +++ b/namespaces.html @@ -5,7 +5,7 @@ -entt: Namespace List +EnTT: Namespace List @@ -21,8 +21,8 @@ -
    entt -  2.7.1 +
    EnTT +  2.7.2
    diff --git a/pages.html b/pages.html new file mode 100644 index 000000000..07bce2ade --- /dev/null +++ b/pages.html @@ -0,0 +1,79 @@ + + + + + + + +EnTT: Related Pages + + + + + + + + + +
    +
    + + + + + + +
    +
    EnTT +  2.7.2 +
    +
    +
    + + + + + + + +
    + +
    +
    + + +
    + +
    + +
    +
    +
    Related Pages
    +
    +
    +
    Here is a list of all related documentation pages:
    + + +
     Contributing
    +
    +
    + +
    +Generated by   +doxygen + 1.8.13 +
    + + diff --git a/process_8hpp_source.html b/process_8hpp_source.html index cf6e634ce..1df9bc497 100644 --- a/process_8hpp_source.html +++ b/process_8hpp_source.html @@ -5,7 +5,7 @@ -entt: src/entt/process/process.hpp Source File +EnTT: src/entt/process/process.hpp Source File @@ -21,8 +21,8 @@ -
    entt -  2.7.1 +
    EnTT +  2.7.2
    diff --git a/prototype_8hpp_source.html b/prototype_8hpp_source.html index bf050de0b..0b3ec0657 100644 --- a/prototype_8hpp_source.html +++ b/prototype_8hpp_source.html @@ -5,7 +5,7 @@ -entt: src/entt/entity/prototype.hpp Source File +EnTT: src/entt/entity/prototype.hpp Source File @@ -21,8 +21,8 @@ -
    entt -  2.7.1 +
    EnTT +  2.7.2
    @@ -80,11 +80,11 @@ $(function() {
    entt::Prototype::operator()
    void operator()(registry_type &other, const entity_type dst) const ENTT_NOEXCEPT
    Assigns the components of a prototype to an entity.
    Definition: prototype.hpp:405
    entt::Prototype::~Prototype
    ~Prototype()
    Releases all its resources.
    Definition: prototype.hpp:77
    entt::Prototype::unset
    void unset() ENTT_NOEXCEPT
    Removes the given component from a prototype.
    Definition: prototype.hpp:156
    -
    entt::Registry::create
    entity_type create()
    Creates a new entity and returns it.
    Definition: registry.hpp:402
    +
    entt::Registry::create
    entity_type create()
    Creates a new entity and returns it.
    Definition: registry.hpp:448
    entt::Prototype::operator()
    entity_type operator()(registry_type &other) const ENTT_NOEXCEPT
    Creates a new entity using a given prototype.
    Definition: prototype.hpp:451
    entt::Prototype::operator=
    Prototype & operator=(const Prototype &)=delete
    Copying a prototype isn&#39;t allowed.
    entt::Prototype::has
    bool has() const ENTT_NOEXCEPT
    Checks if a prototype owns all the given components.
    Definition: prototype.hpp:167
    -
    entt::Registry::component_type
    typename component_family::family_type component_type
    Unsigned integer type.
    Definition: registry.hpp:129
    +
    entt::Registry::component_type
    typename component_family::family_type component_type
    Unsigned integer type.
    Definition: registry.hpp:158
    entt::Prototype::operator()
    entity_type operator()() const ENTT_NOEXCEPT
    Creates a new entity using a given prototype.
    Definition: prototype.hpp:472
    entt::Prototype
    Prototype container for concepts.
    Definition: prototype.hpp:39
    entt::Prototype::assign
    void assign(registry_type &other, const entity_type dst) const
    Assigns the components of a prototype to a given entity.
    Definition: prototype.hpp:307
    diff --git a/registry_8hpp_source.html b/registry_8hpp_source.html index e9af3b910..4077b7195 100644 --- a/registry_8hpp_source.html +++ b/registry_8hpp_source.html @@ -5,7 +5,7 @@ -entt: src/entt/entity/registry.hpp Source File +EnTT: src/entt/entity/registry.hpp Source File @@ -21,8 +21,8 @@ -
    entt -  2.7.1 +
    EnTT +  2.7.2
    @@ -67,84 +67,86 @@ $(function() {
    registry.hpp
    -
    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 <iterator>
    13 #include <algorithm>
    14 #include <type_traits>
    15 #include "../config/config.h"
    16 #include "../core/algorithm.hpp"
    17 #include "../core/family.hpp"
    18 #include "../signal/sigh.hpp"
    19 #include "entt_traits.hpp"
    20 #include "snapshot.hpp"
    21 #include "sparse_set.hpp"
    22 #include "utility.hpp"
    23 #include "view.hpp"
    24 
    25 
    26 namespace entt {
    27 
    28 
    39 template<typename Entity>
    40 class Registry {
    41  using tag_family = Family<struct InternalRegistryTagFamily>;
    42  using component_family = Family<struct InternalRegistryComponentFamily>;
    43  using handler_family = Family<struct InternalRegistryHandlerFamily>;
    44  using signal_type = SigH<void(Registry &, const Entity)>;
    45  using traits_type = entt_traits<Entity>;
    46 
    47  template<typename... Component>
    48  static void creating(Registry &registry, const Entity entity) {
    49  if(registry.has<Component...>(entity)) {
    50  registry.handlers[handler_family::type<Component...>()]->construct(entity);
    51  }
    52  }
    53 
    54  template<typename... Component>
    55  static void destroying(Registry &registry, const Entity entity) {
    56  auto &handler = *registry.handlers[handler_family::type<Component...>()];
    57  return handler.has(entity) ? handler.destroy(entity) : void();
    58  }
    59 
    60  struct Attachee {
    61  Attachee(const Entity entity) ENTT_NOEXCEPT: entity{entity} {}
    62  virtual ~Attachee() = default;
    63  Entity entity;
    64  };
    65 
    66  template<typename Tag>
    67  struct Attaching: Attachee {
    68  // requirements for aggregates are relaxed only since C++17
    69  template<typename... Args>
    70  Attaching(const Entity entity, Args &&... args)
    71  : Attachee{entity}, tag{std::forward<Args>(args)...}
    72  {}
    73 
    74  Tag tag;
    75  };
    76 
    77  template<typename Component>
    78  inline bool managed() const ENTT_NOEXCEPT {
    79  const auto ctype = component_family::type<Component>();
    80  return ctype < pools.size() && std::get<0>(pools[ctype]);
    81  }
    82 
    83  template<typename Component>
    84  inline const SparseSet<Entity, Component> & pool() const ENTT_NOEXCEPT {
    85  assert(managed<Component>());
    86  const auto ctype = component_family::type<Component>();
    87  return static_cast<SparseSet<Entity, Component> &>(*std::get<0>(pools[ctype]));
    88  }
    89 
    90  template<typename Component>
    91  inline SparseSet<Entity, Component> & pool() ENTT_NOEXCEPT {
    92  return const_cast<SparseSet<Entity, Component> &>(const_cast<const Registry *>(this)->pool<Component>());
    93  }
    94 
    95  template<typename Component>
    96  void assure() {
    97  const auto ctype = component_family::type<Component>();
    98 
    99  if(!(ctype < pools.size())) {
    100  pools.resize(ctype + 1);
    101  }
    102 
    103  auto &cpool = std::get<0>(pools[ctype]);
    104 
    105  if(!cpool) {
    106  cpool = std::make_unique<SparseSet<Entity, Component>>();
    107  }
    108  }
    109 
    110  template<typename Tag>
    111  void assure(tag_t) {
    112  const auto ttype = tag_family::type<Tag>();
    113 
    114  if(!(ttype < tags.size())) {
    115  tags.resize(ttype + 1);
    116  }
    117  }
    118 
    119 public:
    121  using entity_type = typename traits_type::entity_type;
    123  using version_type = typename traits_type::version_type;
    125  using size_type = std::size_t;
    127  using tag_type = typename tag_family::family_type;
    129  using component_type = typename component_family::family_type;
    131  using sink_type = typename signal_type::sink_type;
    132 
    134  Registry() = default;
    135 
    137  Registry(const Registry &) = delete;
    139  Registry(Registry &&) = default;
    140 
    142  Registry & operator=(const Registry &) = delete;
    144  Registry & operator=(Registry &&) = default;
    145 
    158  template<typename Tag>
    159  static tag_type type(tag_t) ENTT_NOEXCEPT {
    160  return tag_family::type<Tag>();
    161  }
    162 
    175  template<typename Component>
    176  static component_type type() ENTT_NOEXCEPT {
    177  return component_family::type<Component>();
    178  }
    179 
    185  template<typename Component>
    186  size_type size() const ENTT_NOEXCEPT {
    187  return managed<Component>() ? pool<Component>().size() : size_type{};
    188  }
    189 
    194  size_type size() const ENTT_NOEXCEPT {
    195  return entities.size() - available;
    196  }
    197 
    207  template<typename Component>
    208  void reserve(const size_type cap) {
    209  assure<Component>();
    210  pool<Component>().reserve(cap);
    211  }
    212 
    221  void reserve(const size_type cap) {
    222  entities.reserve(cap);
    223  }
    224 
    230  template<typename Component>
    231  size_type capacity() const ENTT_NOEXCEPT {
    232  return managed<Component>() ? pool<Component>().capacity() : size_type{};
    233  }
    234 
    240  size_type capacity() const ENTT_NOEXCEPT {
    241  return entities.capacity();
    242  }
    243 
    250  template<typename Component>
    251  bool empty() const ENTT_NOEXCEPT {
    252  return !managed<Component>() || pool<Component>().empty();
    253  }
    254 
    259  bool empty() const ENTT_NOEXCEPT {
    260  return entities.size() == available;
    261  }
    262 
    277  template<typename Component>
    278  const Component * raw() const ENTT_NOEXCEPT {
    279  return managed<Component>() ? pool<Component>().raw() : nullptr;
    280  }
    281 
    296  template<typename Component>
    297  inline Component * raw() ENTT_NOEXCEPT {
    298  return const_cast<Component *>(const_cast<const Registry *>(this)->raw<Component>());
    299  }
    300 
    315  template<typename Component>
    316  const entity_type * data() const ENTT_NOEXCEPT {
    317  return managed<Component>() ? pool<Component>().data() : nullptr;
    318  }
    319 
    325  bool valid(const entity_type entity) const ENTT_NOEXCEPT {
    326  const auto pos = size_type(entity & traits_type::entity_mask);
    327  return (pos < entities.size() && entities[pos] == entity);
    328  }
    329 
    347  bool fast(const entity_type entity) const ENTT_NOEXCEPT {
    348  const auto pos = size_type(entity & traits_type::entity_mask);
    349  assert(pos < entities.size());
    350  return (entities[pos] == entity);
    351  }
    352 
    358  version_type version(const entity_type entity) const ENTT_NOEXCEPT {
    359  return version_type((entity >> traits_type::entity_shift) & traits_type::version_mask);
    360  }
    361 
    379  version_type current(const entity_type entity) const ENTT_NOEXCEPT {
    380  const auto pos = size_type(entity & traits_type::entity_mask);
    381  assert(pos < entities.size());
    382  return version_type((entities[pos] >> traits_type::entity_shift) & traits_type::version_mask);
    383  }
    384 
    402  entity_type create() {
    403  entity_type entity;
    404 
    405  if(available) {
    406  const auto entt = next;
    407  const auto version = entities[entt] & (~traits_type::entity_mask);
    408 
    409  entity = entt | version;
    410  next = entities[entt] & traits_type::entity_mask;
    411  entities[entt] = entity;
    412  --available;
    413  } else {
    414  entity = entity_type(entities.size());
    415  entities.push_back(entity);
    416  // traits_type::entity_mask is reserved to allow for null identifiers
    417  assert(entity < traits_type::entity_mask);
    418  }
    419 
    420  return entity;
    421  }
    422 
    437  template<typename Tag>
    438  void destroy(tag_t) {
    439  return has<Tag>() ? destroy(attachee<Tag>()) : void();
    440  }
    441 
    464  void destroy(const entity_type entity) {
    465  assert(valid(entity));
    466 
    467  for(auto pos = pools.size(); pos; --pos) {
    468  auto &tup = pools[pos-1];
    469  auto &cpool = std::get<0>(tup);
    470 
    471  if(cpool && cpool->has(entity)) {
    472  std::get<2>(tup).publish(*this, entity);
    473  cpool->destroy(entity);
    474  }
    475  };
    476 
    477  for(auto pos = tags.size(); pos; --pos) {
    478  auto &tup = tags[pos-1];
    479  auto &tag = std::get<0>(tup);
    480 
    481  if(tag && tag->entity == entity) {
    482  std::get<2>(tup).publish(*this, entity);
    483  tag.reset();
    484  }
    485  };
    486 
    487  // just a way to protect users from listeners that attach components
    488  assert(orphan(entity));
    489 
    490  const auto entt = entity & traits_type::entity_mask;
    491  const auto version = (((entity >> traits_type::entity_shift) + 1) & traits_type::version_mask) << traits_type::entity_shift;
    492  const auto node = (available ? next : ((entt + 1) & traits_type::entity_mask)) | version;
    493 
    494  entities[entt] = node;
    495  next = entt;
    496  ++available;
    497  }
    498 
    514  template<typename... Component, typename... Type>
    515  void destroy(Type...) {
    516  for(const auto entity: view<Component...>(Type{}...)) {
    517  destroy(entity);
    518  }
    519  }
    520 
    542  template<typename Tag, typename... Args>
    543  Tag & assign(tag_t, const entity_type entity, Args &&... args) {
    544  assert(valid(entity));
    545  assert(!has<Tag>());
    546  assure<Tag>(tag_t{});
    547  auto &tup = tags[tag_family::type<Tag>()];
    548  std::get<0>(tup).reset(new Attaching<Tag>{entity, std::forward<Args>(args)...});
    549  std::get<1>(tup).publish(*this, entity);
    550  return get<Tag>();
    551  }
    552 
    573  template<typename Component, typename... Args>
    574  Component & assign(const entity_type entity, Args &&... args) {
    575  assert(valid(entity));
    576  assure<Component>();
    577  pool<Component>().construct(entity, std::forward<Args>(args)...);
    578  std::get<1>(pools[component_family::type<Component>()]).publish(*this, entity);
    579  return pool<Component>().get(entity);
    580  }
    581 
    586  template<typename Tag>
    587  void remove() {
    588  if(has<Tag>()) {
    589  auto &tup = tags[tag_family::type<Tag>()];
    590  auto &tag = std::get<0>(tup);
    591  std::get<2>(tup).publish(*this, tag->entity);
    592  tag.reset();
    593  }
    594  }
    595 
    609  template<typename Component>
    610  void remove(const entity_type entity) {
    611  assert(valid(entity));
    612  assert(managed<Component>());
    613  const auto ctype = component_family::type<Component>();
    614  std::get<2>(pools[ctype]).publish(*this, entity);
    615  pool<Component>().destroy(entity);
    616  }
    617 
    623  template<typename Tag>
    624  bool has() const ENTT_NOEXCEPT {
    625  const auto ttype = tag_family::type<Tag>();
    626  bool found = false;
    627 
    628  if(ttype < tags.size()) {
    629  auto &tag = std::get<0>(tags[ttype]);
    630  // it's a valid tag and the associated entity hasn't been destroyed in the meantime
    631  found = tag && (tag->entity == (entities[tag->entity & traits_type::entity_mask]));
    632  }
    633 
    634  return found;
    635  }
    636 
    650  template<typename Tag>
    651  bool has(tag_t, const entity_type entity) const ENTT_NOEXCEPT {
    652  return has<Tag>() && attachee<Tag>() == entity;
    653  }
    654 
    667  template<typename... Component>
    668  bool has(const entity_type entity) const ENTT_NOEXCEPT {
    669  assert(valid(entity));
    670  bool all = true;
    671  using accumulator_type = bool[];
    672  accumulator_type accumulator = { all, (all = all && managed<Component>() && pool<Component>().has(entity))... };
    673  (void)accumulator;
    674  return all;
    675  }
    676 
    689  template<typename Tag>
    690  const Tag & get() const ENTT_NOEXCEPT {
    691  assert(has<Tag>());
    692  return static_cast<Attaching<Tag> *>(std::get<0>(tags[tag_family::type<Tag>()]).get())->tag;
    693  }
    694 
    707  template<typename Tag>
    708  inline Tag & get() ENTT_NOEXCEPT {
    709  return const_cast<Tag &>(const_cast<const Registry *>(this)->get<Tag>());
    710  }
    711 
    726  template<typename Component>
    727  const Component & get(const entity_type entity) const ENTT_NOEXCEPT {
    728  assert(valid(entity));
    729  assert(managed<Component>());
    730  return pool<Component>().get(entity);
    731  }
    732 
    747  template<typename Component>
    748  inline Component & get(const entity_type entity) ENTT_NOEXCEPT {
    749  return const_cast<Component &>(const_cast<const Registry *>(this)->get<Component>(entity));
    750  }
    751 
    766  template<typename... Component>
    767  inline std::enable_if_t<(sizeof...(Component) > 1), std::tuple<const Component &...>>
    768  get(const entity_type entity) const ENTT_NOEXCEPT {
    769  return std::tuple<const Component &...>{get<Component>(entity)...};
    770  }
    771 
    786  template<typename... Component>
    787  inline std::enable_if_t<(sizeof...(Component) > 1), std::tuple<Component &...>>
    788  get(const entity_type entity) ENTT_NOEXCEPT {
    789  return std::tuple<Component &...>{get<Component>(entity)...};
    790  }
    791 
    810  template<typename Tag, typename... Args>
    811  Tag & replace(tag_t, Args &&... args) {
    812  return (get<Tag>() = Tag{std::forward<Args>(args)...});
    813  }
    814 
    835  template<typename Component, typename... Args>
    836  Component & replace(const entity_type entity, Args &&... args) {
    837  return (get<Component>(entity) = Component{std::forward<Args>(args)...});
    838  }
    839 
    856  template<typename Tag>
    857  entity_type move(const entity_type entity) ENTT_NOEXCEPT {
    858  assert(valid(entity));
    859  assert(has<Tag>());
    860  auto &tag = std::get<0>(tags[tag_family::type<Tag>()]);
    861  const auto owner = tag->entity;
    862  tag->entity = entity;
    863  return owner;
    864  }
    865 
    878  template<typename Tag>
    879  entity_type attachee() const ENTT_NOEXCEPT {
    880  assert(has<Tag>());
    881  return std::get<0>(tags[tag_family::type<Tag>()])->entity;
    882  }
    883 
    910  template<typename Component, typename... Args>
    911  Component & accommodate(const entity_type entity, Args &&... args) {
    912  assure<Component>();
    913  auto &cpool = pool<Component>();
    914 
    915  return (cpool.has(entity)
    916  ? cpool.get(entity) = Component{std::forward<Args>(args)...}
    917  : cpool.construct(entity, std::forward<Args>(args)...));
    918  }
    919 
    943  template<typename Tag>
    944  sink_type construction(tag_t) ENTT_NOEXCEPT {
    945  assure<Tag>(tag_t{});
    946  return std::get<1>(tags[tag_family::type<Tag>()]).sink();
    947  }
    948 
    972  template<typename Component>
    973  sink_type construction() ENTT_NOEXCEPT {
    974  assure<Component>();
    975  return std::get<1>(pools[component_family::type<Component>()]).sink();
    976  }
    977 
    1001  template<typename Tag>
    1002  sink_type destruction(tag_t) ENTT_NOEXCEPT {
    1003  assure<Tag>(tag_t{});
    1004  return std::get<2>(tags[tag_family::type<Tag>()]).sink();
    1005  }
    1006 
    1030  template<typename Component>
    1031  sink_type destruction() ENTT_NOEXCEPT {
    1032  assure<Component>();
    1033  return std::get<2>(pools[component_family::type<Component>()]).sink();
    1034  }
    1035 
    1077  template<typename Component, typename Compare, typename Sort = StdSort, typename... Args>
    1078  void sort(Compare compare, Sort sort = Sort{}, Args &&... args) {
    1079  assure<Component>();
    1080  pool<Component>().sort(std::move(compare), std::move(sort), std::forward<Args>(args)...);
    1081  }
    1082 
    1113  template<typename To, typename From>
    1114  void sort() {
    1115  assure<To>();
    1116  assure<From>();
    1117  pool<To>().respect(pool<From>());
    1118  }
    1119 
    1134  template<typename Component>
    1135  void reset(const entity_type entity) {
    1136  assert(valid(entity));
    1137  assure<Component>();
    1138  const auto ctype = component_family::type<Component>();
    1139  auto &cpool = *std::get<0>(pools[ctype]);
    1140 
    1141  if(cpool.has(entity)) {
    1142  std::get<2>(pools[ctype]).publish(*this, entity);
    1143  cpool.destroy(entity);
    1144  }
    1145  }
    1146 
    1155  template<typename Component>
    1156  void reset() {
    1157  assure<Component>();
    1158  const auto ctype = component_family::type<Component>();
    1159  auto &cpool = *std::get<0>(pools[ctype]);
    1160  auto &sig = std::get<2>(pools[ctype]);
    1161 
    1162  for(const auto entity: cpool) {
    1163  sig.publish(*this, entity);
    1164  cpool.destroy(entity);
    1165  }
    1166  }
    1167 
    1176  void reset() {
    1177  each([this](const auto entity) {
    1178  // useless this-> used to suppress a warning with clang
    1179  this->destroy(entity);
    1180  });
    1181  }
    1182 
    1203  template<typename Func>
    1204  void each(Func func) const {
    1205  if(available) {
    1206  for(auto pos = entities.size(); pos; --pos) {
    1207  const auto curr = entity_type(pos - 1);
    1208  const auto entity = entities[curr];
    1209  const auto entt = entity & traits_type::entity_mask;
    1210 
    1211  if(curr == entt) {
    1212  func(entity);
    1213  }
    1214  }
    1215  } else {
    1216  for(auto pos = entities.size(); pos; --pos) {
    1217  func(entities[pos-1]);
    1218  }
    1219  }
    1220  }
    1221 
    1231  bool orphan(const entity_type entity) const {
    1232  assert(valid(entity));
    1233  bool orphan = true;
    1234 
    1235  for(std::size_t i = 0; i < pools.size() && orphan; ++i) {
    1236  const auto &pool = std::get<0>(pools[i]);
    1237  orphan = !(pool && pool->has(entity));
    1238  }
    1239 
    1240  for(std::size_t i = 0; i < tags.size() && orphan; ++i) {
    1241  const auto &tag = std::get<0>(tags[i]);
    1242  orphan = !(tag && (tag->entity == entity));
    1243  }
    1244 
    1245  return orphan;
    1246  }
    1247 
    1264  template<typename Func>
    1265  void orphans(Func func) const {
    1266  each([func = std::move(func), this](const auto entity) {
    1267  if(orphan(entity)) {
    1268  func(entity);
    1269  }
    1270  });
    1271  }
    1272 
    1307  template<typename... Component>
    1308  View<Entity, Component...> view() {
    1309  return View<Entity, Component...>{(assure<Component>(), pool<Component>())...};
    1310  }
    1311 
    1328  template<typename... Component>
    1329  void prepare() {
    1330  static_assert(sizeof...(Component) > 1, "!");
    1331  const auto htype = handler_family::type<Component...>();
    1332 
    1333  if(!(htype < handlers.size())) {
    1334  handlers.resize(htype + 1);
    1335  }
    1336 
    1337  if(!handlers[htype]) {
    1338  handlers[htype] = std::make_unique<SparseSet<entity_type>>();
    1339  auto &handler = handlers[htype];
    1340 
    1341  for(auto entity: view<Component...>()) {
    1342  handler->construct(entity);
    1343  }
    1344 
    1345  auto connect = [this](const auto ctype) {
    1346  auto &cpool = pools[ctype];
    1347  std::get<1>(cpool).sink().template connect<&Registry::creating<Component...>>();
    1348  std::get<2>(cpool).sink().template connect<&Registry::destroying<Component...>>();
    1349  };
    1350 
    1351  using accumulator_type = int[];
    1352  accumulator_type accumulator = { (assure<Component>(), connect(component_family::type<Component>()), 0)... };
    1353  (void)accumulator;
    1354  }
    1355  }
    1356 
    1372  template<typename... Component>
    1373  void discard() {
    1374  if(contains<Component...>()) {
    1375  const auto htype = handler_family::type<Component...>();
    1376 
    1377  auto disconnect = [this](const auto ctype) {
    1378  auto &cpool = pools[ctype];
    1379  std::get<1>(cpool).sink().template disconnect<&Registry::creating<Component...>>();
    1380  std::get<2>(cpool).sink().template disconnect<&Registry::destroying<Component...>>();
    1381  };
    1382 
    1383  // if a set exists, pools have already been created for it
    1384  using accumulator_type = int[];
    1385  accumulator_type accumulator = { (disconnect(component_family::type<Component>()), 0)... };
    1386  handlers[htype].reset();
    1387  (void)accumulator;
    1388  }
    1389  }
    1390 
    1396  template<typename... Component>
    1397  bool contains() const ENTT_NOEXCEPT {
    1398  static_assert(sizeof...(Component) > 1, "!");
    1399  const auto htype = handler_family::type<Component...>();
    1400  return (htype < handlers.size() && handlers[htype]);
    1401  }
    1402 
    1442  template<typename... Component>
    1443  PersistentView<Entity, Component...> view(persistent_t) {
    1444  prepare<Component...>();
    1445  const auto htype = handler_family::type<Component...>();
    1446  return PersistentView<Entity, Component...>{*handlers[htype], (assure<Component>(), pool<Component>())...};
    1447  }
    1448 
    1472  template<typename Component>
    1473  RawView<Entity, Component> view(raw_t) {
    1474  assure<Component>();
    1475  return RawView<Entity, Component>{pool<Component>()};
    1476  }
    1477 
    1504  template<typename It>
    1505  RuntimeView<Entity> view(It first, It last) {
    1506  static_assert(std::is_convertible<typename std::iterator_traits<It>::value_type, component_type>::value, "!");
    1507  std::vector<const SparseSet<Entity> *> set(last - first);
    1508 
    1509  std::transform(first, last, set.begin(), [this](const component_type ctype) {
    1510  return ctype < pools.size() ? std::get<0>(pools[ctype]).get() : nullptr;
    1511  });
    1512 
    1513  return RuntimeView<Entity>{std::move(set)};
    1514  }
    1515 
    1526  Snapshot<Entity> snapshot() const ENTT_NOEXCEPT {
    1527  using follow_fn_type = entity_type(const Registry &, const entity_type);
    1528  const entity_type seed = available ? (next | (entities[next] & ~traits_type::entity_mask)) : next;
    1529 
    1530  follow_fn_type *follow = [](const Registry &registry, const entity_type entity) -> entity_type {
    1531  const auto &entities = registry.entities;
    1532  const auto entt = entity & traits_type::entity_mask;
    1533  const auto next = entities[entt] & traits_type::entity_mask;
    1534  return (next | (entities[next] & ~traits_type::entity_mask));
    1535  };
    1536 
    1537  return { *this, seed, follow };
    1538  }
    1539 
    1555  SnapshotLoader<Entity> restore() ENTT_NOEXCEPT {
    1556  using assure_fn_type = void(Registry &, const entity_type, const bool);
    1557 
    1558  assure_fn_type *assure = [](Registry &registry, const entity_type entity, const bool destroyed) {
    1559  using promotion_type = std::conditional_t<sizeof(size_type) >= sizeof(entity_type), size_type, entity_type>;
    1560  // explicit promotion to avoid warnings with std::uint16_t
    1561  const auto entt = promotion_type{entity} & traits_type::entity_mask;
    1562  auto &entities = registry.entities;
    1563 
    1564  if(!(entt < entities.size())) {
    1565  auto curr = entities.size();
    1566  entities.resize(entt + 1);
    1567  std::iota(entities.data() + curr, entities.data() + entt, entity_type(curr));
    1568  }
    1569 
    1570  entities[entt] = entity;
    1571 
    1572  if(destroyed) {
    1573  registry.destroy(entity);
    1574  const auto version = (entity & (~traits_type::entity_mask));
    1575  entities[entt] = ((entities[entt] & traits_type::entity_mask) | version);
    1576  }
    1577  };
    1578 
    1579  return { (*this = {}), assure };
    1580  }
    1581 
    1582 private:
    1583  std::vector<std::unique_ptr<SparseSet<Entity>>> handlers;
    1584  std::vector<std::tuple<std::unique_ptr<SparseSet<Entity>>, signal_type, signal_type>> pools;
    1585  std::vector<std::tuple<std::unique_ptr<Attachee>, signal_type, signal_type>> tags;
    1586  std::vector<entity_type> entities;
    1587  size_type available{};
    1588  entity_type next{};
    1589 };
    1590 
    1591 
    1598 using DefaultRegistry = Registry<std::uint32_t>;
    1599 
    1600 
    1601 }
    1602 
    1603 
    1604 #endif // ENTT_ENTITY_REGISTRY_HPP
    entt::Registry::each
    void each(Func func) const
    Iterates all the entities that are still in use.
    Definition: registry.hpp:1204
    -
    entt::Registry::discard
    void discard()
    Discards all the data structures used for a given persitent view.
    Definition: registry.hpp:1373
    -
    entt::Registry::sink_type
    typename signal_type::sink_type sink_type
    Type of sink for the given component.
    Definition: registry.hpp:131
    -
    entt::Registry::sort
    void sort(Compare compare, Sort sort=Sort{}, Args &&... args)
    Sorts the pool of entities for the given component.
    Definition: registry.hpp:1078
    -
    entt::Registry::orphans
    void orphans(Func func) const
    Iterates orphans and applies them the given function object.
    Definition: registry.hpp:1265
    -
    entt::Registry::size
    size_type size() const ENTT_NOEXCEPT
    Returns the number of entities still in use.
    Definition: registry.hpp:194
    -
    entt::Registry::has
    bool has() const ENTT_NOEXCEPT
    Checks if the given tag has an owner.
    Definition: registry.hpp:624
    -
    entt::Registry::reset
    void reset()
    Resets the pool of the given component.
    Definition: registry.hpp:1156
    -
    entt::Registry::accommodate
    Component & accommodate(const entity_type entity, Args &&... args)
    Assigns or replaces the given component for an entity.
    Definition: registry.hpp:911
    -
    entt::Registry::destroy
    void destroy(const entity_type entity)
    Destroys an entity and lets the registry recycle the identifier.
    Definition: registry.hpp:464
    +
    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 <iterator>
    13 #include <algorithm>
    14 #include <type_traits>
    15 #include "../config/config.h"
    16 #include "../core/algorithm.hpp"
    17 #include "../core/family.hpp"
    18 #include "../signal/sigh.hpp"
    19 #include "entt_traits.hpp"
    20 #include "snapshot.hpp"
    21 #include "sparse_set.hpp"
    22 #include "utility.hpp"
    23 #include "view.hpp"
    24 
    25 
    26 namespace entt {
    27 
    28 
    39 template<typename Entity>
    40 class Registry {
    41  using tag_family = Family<struct InternalRegistryTagFamily>;
    42  using component_family = Family<struct InternalRegistryComponentFamily>;
    43  using handler_family = Family<struct InternalRegistryHandlerFamily>;
    44  using signal_type = SigH<void(Registry &, const Entity)>;
    45  using traits_type = entt_traits<Entity>;
    46 
    47  template<typename handler_family::family_type(*Type)(), typename... Component>
    48  static void creating(Registry &registry, const Entity entity) {
    49  if(registry.has<Component...>(entity)) {
    50  registry.handlers[Type()]->construct(entity);
    51  }
    52  }
    53 
    54  template<typename... Component>
    55  static void destroying(Registry &registry, const Entity entity) {
    56  auto &handler = *registry.handlers[handler_family::type<Component...>()];
    57  return handler.has(entity) ? handler.destroy(entity) : void();
    58  }
    59 
    60  struct Attachee {
    61  Attachee(const Entity entity) ENTT_NOEXCEPT: entity{entity} {}
    62  virtual ~Attachee() = default;
    63  Entity entity;
    64  };
    65 
    66  template<typename Tag>
    67  struct Attaching: Attachee {
    68  // requirements for aggregates are relaxed only since C++17
    69  template<typename... Args>
    70  Attaching(const Entity entity, Args &&... args)
    71  : Attachee{entity}, tag{std::forward<Args>(args)...}
    72  {}
    73 
    74  Tag tag;
    75  };
    76 
    77  template<typename Comp, std::size_t Pivot, typename... Component, std::size_t... Indexes>
    78  void connect(std::index_sequence<Indexes...>) {
    79  auto &cpool = pools[component_family::type<Comp>()];
    80  std::get<1>(cpool).sink().template connect<&Registry::creating<&handler_family::type<Component...>, std::tuple_element_t<(Indexes < Pivot ? Indexes : (Indexes+1)), std::tuple<Component...>>...>>();
    81  std::get<2>(cpool).sink().template connect<&Registry::destroying<Component...>>();
    82  }
    83 
    84  template<typename... Component, std::size_t... Indexes>
    85  void connect(std::index_sequence<Indexes...>) {
    86  using accumulator_type = int[];
    87  accumulator_type accumulator = { (assure<Component>(), connect<Component, Indexes, Component...>(std::make_index_sequence<sizeof...(Component)-1>{}), 0)... };
    88  (void)accumulator;
    89  }
    90 
    91  template<typename Comp, std::size_t Pivot, typename... Component, std::size_t... Indexes>
    92  void disconnect(std::index_sequence<Indexes...>) {
    93  auto &cpool = pools[component_family::type<Comp>()];
    94  std::get<1>(cpool).sink().template disconnect<&Registry::creating<&handler_family::type<Component...>, std::tuple_element_t<(Indexes < Pivot ? Indexes : (Indexes+1)), std::tuple<Component...>>...>>();
    95  std::get<2>(cpool).sink().template disconnect<&Registry::destroying<Component...>>();
    96  }
    97 
    98  template<typename... Component, std::size_t... Indexes>
    99  void disconnect(std::index_sequence<Indexes...>) {
    100  using accumulator_type = int[];
    101  // if a set exists, pools have already been created for it
    102  accumulator_type accumulator = { (disconnect<Component, Indexes, Component...>(std::make_index_sequence<sizeof...(Component)-1>{}), 0)... };
    103  (void)accumulator;
    104  }
    105 
    106  template<typename Component>
    107  inline bool managed() const ENTT_NOEXCEPT {
    108  const auto ctype = component_family::type<Component>();
    109  return ctype < pools.size() && std::get<0>(pools[ctype]);
    110  }
    111 
    112  template<typename Component>
    113  inline const SparseSet<Entity, Component> & pool() const ENTT_NOEXCEPT {
    114  assert(managed<Component>());
    115  const auto ctype = component_family::type<Component>();
    116  return static_cast<SparseSet<Entity, Component> &>(*std::get<0>(pools[ctype]));
    117  }
    118 
    119  template<typename Component>
    120  inline SparseSet<Entity, Component> & pool() ENTT_NOEXCEPT {
    121  return const_cast<SparseSet<Entity, Component> &>(const_cast<const Registry *>(this)->pool<Component>());
    122  }
    123 
    124  template<typename Component>
    125  void assure() {
    126  const auto ctype = component_family::type<Component>();
    127 
    128  if(!(ctype < pools.size())) {
    129  pools.resize(ctype + 1);
    130  }
    131 
    132  auto &cpool = std::get<0>(pools[ctype]);
    133 
    134  if(!cpool) {
    135  cpool = std::make_unique<SparseSet<Entity, Component>>();
    136  }
    137  }
    138 
    139  template<typename Tag>
    140  void assure(tag_t) {
    141  const auto ttype = tag_family::type<Tag>();
    142 
    143  if(!(ttype < tags.size())) {
    144  tags.resize(ttype + 1);
    145  }
    146  }
    147 
    148 public:
    150  using entity_type = typename traits_type::entity_type;
    152  using version_type = typename traits_type::version_type;
    154  using size_type = std::size_t;
    156  using tag_type = typename tag_family::family_type;
    158  using component_type = typename component_family::family_type;
    160  using sink_type = typename signal_type::sink_type;
    161 
    163  Registry() = default;
    164 
    166  Registry(const Registry &) = delete;
    168  Registry(Registry &&) = default;
    169 
    171  Registry & operator=(const Registry &) = delete;
    173  Registry & operator=(Registry &&) = default;
    174 
    187  template<typename Tag>
    188  static tag_type type(tag_t) ENTT_NOEXCEPT {
    189  return tag_family::type<Tag>();
    190  }
    191 
    204  template<typename Component>
    205  static component_type type() ENTT_NOEXCEPT {
    206  return component_family::type<Component>();
    207  }
    208 
    214  template<typename Component>
    215  size_type size() const ENTT_NOEXCEPT {
    216  return managed<Component>() ? pool<Component>().size() : size_type{};
    217  }
    218 
    223  size_type size() const ENTT_NOEXCEPT {
    224  return entities.size();
    225  }
    226 
    231  size_type alive() const ENTT_NOEXCEPT {
    232  return entities.size() - available;
    233  }
    234 
    244  template<typename Component>
    245  void reserve(const size_type cap) {
    246  assure<Component>();
    247  pool<Component>().reserve(cap);
    248  }
    249 
    258  void reserve(const size_type cap) {
    259  entities.reserve(cap);
    260  }
    261 
    267  template<typename Component>
    268  size_type capacity() const ENTT_NOEXCEPT {
    269  return managed<Component>() ? pool<Component>().capacity() : size_type{};
    270  }
    271 
    277  size_type capacity() const ENTT_NOEXCEPT {
    278  return entities.capacity();
    279  }
    280 
    287  template<typename Component>
    288  bool empty() const ENTT_NOEXCEPT {
    289  return !managed<Component>() || pool<Component>().empty();
    290  }
    291 
    296  bool empty() const ENTT_NOEXCEPT {
    297  return entities.size() == available;
    298  }
    299 
    314  template<typename Component>
    315  const Component * raw() const ENTT_NOEXCEPT {
    316  return managed<Component>() ? pool<Component>().raw() : nullptr;
    317  }
    318 
    333  template<typename Component>
    334  inline Component * raw() ENTT_NOEXCEPT {
    335  return const_cast<Component *>(const_cast<const Registry *>(this)->raw<Component>());
    336  }
    337 
    352  template<typename Component>
    353  const entity_type * data() const ENTT_NOEXCEPT {
    354  return managed<Component>() ? pool<Component>().data() : nullptr;
    355  }
    356 
    362  bool valid(const entity_type entity) const ENTT_NOEXCEPT {
    363  const auto pos = size_type(entity & traits_type::entity_mask);
    364  return (pos < entities.size() && entities[pos] == entity);
    365  }
    366 
    384  bool fast(const entity_type entity) const ENTT_NOEXCEPT {
    385  const auto pos = size_type(entity & traits_type::entity_mask);
    386  assert(pos < entities.size());
    387  return (entities[pos] == entity);
    388  }
    389 
    395  entity_type entity(const entity_type entity) const ENTT_NOEXCEPT {
    396  return entity & traits_type::entity_mask;
    397  }
    398 
    404  version_type version(const entity_type entity) const ENTT_NOEXCEPT {
    405  return version_type((entity >> traits_type::entity_shift) & traits_type::version_mask);
    406  }
    407 
    425  version_type current(const entity_type entity) const ENTT_NOEXCEPT {
    426  const auto pos = size_type(entity & traits_type::entity_mask);
    427  assert(pos < entities.size());
    428  return version_type((entities[pos] >> traits_type::entity_shift) & traits_type::version_mask);
    429  }
    430 
    448  entity_type create() {
    449  entity_type entity;
    450 
    451  if(available) {
    452  const auto entt = next;
    453  const auto version = entities[entt] & (~traits_type::entity_mask);
    454  entity = entt | version;
    455  next = entities[entt] & traits_type::entity_mask;
    456  entities[entt] = entity;
    457  --available;
    458  } else {
    459  entity = entity_type(entities.size());
    460  entities.push_back(entity);
    461  // traits_type::entity_mask is reserved to allow for null identifiers
    462  assert(entity < traits_type::entity_mask);
    463  }
    464 
    465  return entity;
    466  }
    467 
    482  template<typename Tag>
    483  void destroy(tag_t) {
    484  return has<Tag>() ? destroy(attachee<Tag>()) : void();
    485  }
    486 
    509  void destroy(const entity_type entity) {
    510  assert(valid(entity));
    511 
    512  for(auto pos = pools.size(); pos; --pos) {
    513  auto &tup = pools[pos-1];
    514  auto &cpool = std::get<0>(tup);
    515 
    516  if(cpool && cpool->has(entity)) {
    517  std::get<2>(tup).publish(*this, entity);
    518  cpool->destroy(entity);
    519  }
    520  };
    521 
    522  for(auto pos = tags.size(); pos; --pos) {
    523  auto &tup = tags[pos-1];
    524  auto &tag = std::get<0>(tup);
    525 
    526  if(tag && tag->entity == entity) {
    527  std::get<2>(tup).publish(*this, entity);
    528  tag.reset();
    529  }
    530  };
    531 
    532  // just a way to protect users from listeners that attach components
    533  assert(orphan(entity));
    534 
    535  // lengthens the implicit list of destroyed entities
    536  const auto entt = entity & traits_type::entity_mask;
    537  const auto version = (((entity >> traits_type::entity_shift) + 1) & traits_type::version_mask) << traits_type::entity_shift;
    538  const auto node = (available ? next : ((entt + 1) & traits_type::entity_mask)) | version;
    539  entities[entt] = node;
    540  next = entt;
    541  ++available;
    542  }
    543 
    559  template<typename... Component, typename... Type>
    560  void destroy(Type...) {
    561  for(const auto entity: view<Component...>(Type{}...)) {
    562  destroy(entity);
    563  }
    564  }
    565 
    587  template<typename Tag, typename... Args>
    588  Tag & assign(tag_t, const entity_type entity, Args &&... args) {
    589  assert(valid(entity));
    590  assert(!has<Tag>());
    591  assure<Tag>(tag_t{});
    592  auto &tup = tags[tag_family::type<Tag>()];
    593  std::get<0>(tup).reset(new Attaching<Tag>{entity, std::forward<Args>(args)...});
    594  std::get<1>(tup).publish(*this, entity);
    595  return get<Tag>();
    596  }
    597 
    618  template<typename Component, typename... Args>
    619  Component & assign(const entity_type entity, Args &&... args) {
    620  assert(valid(entity));
    621  assure<Component>();
    622  pool<Component>().construct(entity, std::forward<Args>(args)...);
    623  std::get<1>(pools[component_family::type<Component>()]).publish(*this, entity);
    624  return pool<Component>().get(entity);
    625  }
    626 
    631  template<typename Tag>
    632  void remove() {
    633  if(has<Tag>()) {
    634  auto &tup = tags[tag_family::type<Tag>()];
    635  auto &tag = std::get<0>(tup);
    636  std::get<2>(tup).publish(*this, tag->entity);
    637  tag.reset();
    638  }
    639  }
    640 
    654  template<typename Component>
    655  void remove(const entity_type entity) {
    656  assert(valid(entity));
    657  assert(managed<Component>());
    658  const auto ctype = component_family::type<Component>();
    659  std::get<2>(pools[ctype]).publish(*this, entity);
    660  pool<Component>().destroy(entity);
    661  }
    662 
    668  template<typename Tag>
    669  bool has() const ENTT_NOEXCEPT {
    670  const auto ttype = tag_family::type<Tag>();
    671  bool found = false;
    672 
    673  if(ttype < tags.size()) {
    674  auto &tag = std::get<0>(tags[ttype]);
    675  // it's a valid tag and the associated entity hasn't been destroyed in the meantime
    676  found = tag && (tag->entity == (entities[tag->entity & traits_type::entity_mask]));
    677  }
    678 
    679  return found;
    680  }
    681 
    695  template<typename Tag>
    696  bool has(tag_t, const entity_type entity) const ENTT_NOEXCEPT {
    697  return has<Tag>() && attachee<Tag>() == entity;
    698  }
    699 
    712  template<typename... Component>
    713  bool has(const entity_type entity) const ENTT_NOEXCEPT {
    714  assert(valid(entity));
    715  bool all = true;
    716  using accumulator_type = bool[];
    717  accumulator_type accumulator = { all, (all = all && managed<Component>() && pool<Component>().has(entity))... };
    718  (void)accumulator;
    719  return all;
    720  }
    721 
    734  template<typename Tag>
    735  const Tag & get() const ENTT_NOEXCEPT {
    736  assert(has<Tag>());
    737  return static_cast<Attaching<Tag> *>(std::get<0>(tags[tag_family::type<Tag>()]).get())->tag;
    738  }
    739 
    752  template<typename Tag>
    753  inline Tag & get() ENTT_NOEXCEPT {
    754  return const_cast<Tag &>(const_cast<const Registry *>(this)->get<Tag>());
    755  }
    756 
    771  template<typename Component>
    772  const Component & get(const entity_type entity) const ENTT_NOEXCEPT {
    773  assert(valid(entity));
    774  assert(managed<Component>());
    775  return pool<Component>().get(entity);
    776  }
    777 
    792  template<typename Component>
    793  inline Component & get(const entity_type entity) ENTT_NOEXCEPT {
    794  return const_cast<Component &>(const_cast<const Registry *>(this)->get<Component>(entity));
    795  }
    796 
    811  template<typename... Component>
    812  inline std::enable_if_t<(sizeof...(Component) > 1), std::tuple<const Component &...>>
    813  get(const entity_type entity) const ENTT_NOEXCEPT {
    814  return std::tuple<const Component &...>{get<Component>(entity)...};
    815  }
    816 
    831  template<typename... Component>
    832  inline std::enable_if_t<(sizeof...(Component) > 1), std::tuple<Component &...>>
    833  get(const entity_type entity) ENTT_NOEXCEPT {
    834  return std::tuple<Component &...>{get<Component>(entity)...};
    835  }
    836 
    855  template<typename Tag, typename... Args>
    856  Tag & replace(tag_t, Args &&... args) {
    857  return (get<Tag>() = Tag{std::forward<Args>(args)...});
    858  }
    859 
    880  template<typename Component, typename... Args>
    881  Component & replace(const entity_type entity, Args &&... args) {
    882  return (get<Component>(entity) = Component{std::forward<Args>(args)...});
    883  }
    884 
    901  template<typename Tag>
    902  entity_type move(const entity_type entity) ENTT_NOEXCEPT {
    903  assert(valid(entity));
    904  assert(has<Tag>());
    905  auto &tag = std::get<0>(tags[tag_family::type<Tag>()]);
    906  const auto owner = tag->entity;
    907  tag->entity = entity;
    908  return owner;
    909  }
    910 
    923  template<typename Tag>
    924  entity_type attachee() const ENTT_NOEXCEPT {
    925  assert(has<Tag>());
    926  return std::get<0>(tags[tag_family::type<Tag>()])->entity;
    927  }
    928 
    955  template<typename Component, typename... Args>
    956  Component & accommodate(const entity_type entity, Args &&... args) {
    957  assure<Component>();
    958  auto &cpool = pool<Component>();
    959 
    960  return (cpool.has(entity)
    961  ? cpool.get(entity) = Component{std::forward<Args>(args)...}
    962  : cpool.construct(entity, std::forward<Args>(args)...));
    963  }
    964 
    988  template<typename Tag>
    989  sink_type construction(tag_t) ENTT_NOEXCEPT {
    990  assure<Tag>(tag_t{});
    991  return std::get<1>(tags[tag_family::type<Tag>()]).sink();
    992  }
    993 
    1017  template<typename Component>
    1018  sink_type construction() ENTT_NOEXCEPT {
    1019  assure<Component>();
    1020  return std::get<1>(pools[component_family::type<Component>()]).sink();
    1021  }
    1022 
    1046  template<typename Tag>
    1047  sink_type destruction(tag_t) ENTT_NOEXCEPT {
    1048  assure<Tag>(tag_t{});
    1049  return std::get<2>(tags[tag_family::type<Tag>()]).sink();
    1050  }
    1051 
    1075  template<typename Component>
    1076  sink_type destruction() ENTT_NOEXCEPT {
    1077  assure<Component>();
    1078  return std::get<2>(pools[component_family::type<Component>()]).sink();
    1079  }
    1080 
    1122  template<typename Component, typename Compare, typename Sort = StdSort, typename... Args>
    1123  void sort(Compare compare, Sort sort = Sort{}, Args &&... args) {
    1124  assure<Component>();
    1125  pool<Component>().sort(std::move(compare), std::move(sort), std::forward<Args>(args)...);
    1126  }
    1127 
    1158  template<typename To, typename From>
    1159  void sort() {
    1160  assure<To>();
    1161  assure<From>();
    1162  pool<To>().respect(pool<From>());
    1163  }
    1164 
    1179  template<typename Component>
    1180  void reset(const entity_type entity) {
    1181  assert(valid(entity));
    1182  assure<Component>();
    1183  const auto ctype = component_family::type<Component>();
    1184  auto &cpool = *std::get<0>(pools[ctype]);
    1185 
    1186  if(cpool.has(entity)) {
    1187  std::get<2>(pools[ctype]).publish(*this, entity);
    1188  cpool.destroy(entity);
    1189  }
    1190  }
    1191 
    1200  template<typename Component>
    1201  void reset() {
    1202  assure<Component>();
    1203  const auto ctype = component_family::type<Component>();
    1204  auto &cpool = *std::get<0>(pools[ctype]);
    1205  auto &sig = std::get<2>(pools[ctype]);
    1206 
    1207  for(const auto entity: cpool) {
    1208  sig.publish(*this, entity);
    1209  cpool.destroy(entity);
    1210  }
    1211  }
    1212 
    1221  void reset() {
    1222  each([this](const auto entity) {
    1223  // useless this-> used to suppress a warning with clang
    1224  this->destroy(entity);
    1225  });
    1226  }
    1227 
    1248  template<typename Func>
    1249  void each(Func func) const {
    1250  if(available) {
    1251  for(auto pos = entities.size(); pos; --pos) {
    1252  const auto curr = entity_type(pos - 1);
    1253  const auto entity = entities[curr];
    1254  const auto entt = entity & traits_type::entity_mask;
    1255 
    1256  if(curr == entt) {
    1257  func(entity);
    1258  }
    1259  }
    1260  } else {
    1261  for(auto pos = entities.size(); pos; --pos) {
    1262  func(entities[pos-1]);
    1263  }
    1264  }
    1265  }
    1266 
    1276  bool orphan(const entity_type entity) const {
    1277  assert(valid(entity));
    1278  bool orphan = true;
    1279 
    1280  for(std::size_t i = 0; i < pools.size() && orphan; ++i) {
    1281  const auto &pool = std::get<0>(pools[i]);
    1282  orphan = !(pool && pool->has(entity));
    1283  }
    1284 
    1285  for(std::size_t i = 0; i < tags.size() && orphan; ++i) {
    1286  const auto &tag = std::get<0>(tags[i]);
    1287  orphan = !(tag && (tag->entity == entity));
    1288  }
    1289 
    1290  return orphan;
    1291  }
    1292 
    1309  template<typename Func>
    1310  void orphans(Func func) const {
    1311  each([func = std::move(func), this](const auto entity) {
    1312  if(orphan(entity)) {
    1313  func(entity);
    1314  }
    1315  });
    1316  }
    1317 
    1352  template<typename... Component>
    1353  View<Entity, Component...> view() {
    1354  return View<Entity, Component...>{(assure<Component>(), pool<Component>())...};
    1355  }
    1356 
    1373  template<typename... Component>
    1374  void prepare() {
    1375  static_assert(sizeof...(Component) > 1, "!");
    1376  const auto htype = handler_family::type<Component...>();
    1377 
    1378  if(!(htype < handlers.size())) {
    1379  handlers.resize(htype + 1);
    1380  }
    1381 
    1382  if(!handlers[htype]) {
    1383  connect<Component...>(std::make_index_sequence<sizeof...(Component)>{});
    1384  handlers[htype] = std::make_unique<SparseSet<entity_type>>();
    1385  auto &handler = *handlers[htype];
    1386 
    1387  for(auto entity: view<Component...>()) {
    1388  handler.construct(entity);
    1389  }
    1390  }
    1391  }
    1392 
    1408  template<typename... Component>
    1409  void discard() {
    1410  if(contains<Component...>()) {
    1411  disconnect<Component...>(std::make_index_sequence<sizeof...(Component)>{});
    1412  handlers[handler_family::type<Component...>()].reset();
    1413  }
    1414  }
    1415 
    1421  template<typename... Component>
    1422  bool contains() const ENTT_NOEXCEPT {
    1423  static_assert(sizeof...(Component) > 1, "!");
    1424  const auto htype = handler_family::type<Component...>();
    1425  return (htype < handlers.size() && handlers[htype]);
    1426  }
    1427 
    1467  template<typename... Component>
    1468  PersistentView<Entity, Component...> view(persistent_t) {
    1469  prepare<Component...>();
    1470  const auto htype = handler_family::type<Component...>();
    1471  return PersistentView<Entity, Component...>{*handlers[htype], (assure<Component>(), pool<Component>())...};
    1472  }
    1473 
    1497  template<typename Component>
    1498  RawView<Entity, Component> view(raw_t) {
    1499  assure<Component>();
    1500  return RawView<Entity, Component>{pool<Component>()};
    1501  }
    1502 
    1529  template<typename It>
    1530  RuntimeView<Entity> view(It first, It last) {
    1531  static_assert(std::is_convertible<typename std::iterator_traits<It>::value_type, component_type>::value, "!");
    1532  std::vector<const SparseSet<Entity> *> set(last - first);
    1533 
    1534  std::transform(first, last, set.begin(), [this](const component_type ctype) {
    1535  return ctype < pools.size() ? std::get<0>(pools[ctype]).get() : nullptr;
    1536  });
    1537 
    1538  return RuntimeView<Entity>{std::move(set)};
    1539  }
    1540 
    1551  Snapshot<Entity> snapshot() const ENTT_NOEXCEPT {
    1552  using follow_fn_type = entity_type(const Registry &, const entity_type);
    1553  const entity_type seed = available ? (next | (entities[next] & ~traits_type::entity_mask)) : next;
    1554 
    1555  follow_fn_type *follow = [](const Registry &registry, const entity_type entity) -> entity_type {
    1556  const auto &entities = registry.entities;
    1557  const auto entt = entity & traits_type::entity_mask;
    1558  const auto next = entities[entt] & traits_type::entity_mask;
    1559  return (next | (entities[next] & ~traits_type::entity_mask));
    1560  };
    1561 
    1562  return { *this, seed, follow };
    1563  }
    1564 
    1580  SnapshotLoader<Entity> restore() ENTT_NOEXCEPT {
    1581  using assure_fn_type = void(Registry &, const entity_type, const bool);
    1582 
    1583  assure_fn_type *assure = [](Registry &registry, const entity_type entity, const bool destroyed) {
    1584  using promotion_type = std::conditional_t<sizeof(size_type) >= sizeof(entity_type), size_type, entity_type>;
    1585  // explicit promotion to avoid warnings with std::uint16_t
    1586  const auto entt = promotion_type{entity} & traits_type::entity_mask;
    1587  auto &entities = registry.entities;
    1588 
    1589  if(!(entt < entities.size())) {
    1590  auto curr = entities.size();
    1591  entities.resize(entt + 1);
    1592  std::iota(entities.data() + curr, entities.data() + entt, entity_type(curr));
    1593  }
    1594 
    1595  entities[entt] = entity;
    1596 
    1597  if(destroyed) {
    1598  registry.destroy(entity);
    1599  const auto version = (entity & (~traits_type::entity_mask));
    1600  entities[entt] = ((entities[entt] & traits_type::entity_mask) | version);
    1601  }
    1602  };
    1603 
    1604  return { (*this = {}), assure };
    1605  }
    1606 
    1607 private:
    1608  std::vector<std::unique_ptr<SparseSet<Entity>>> handlers;
    1609  std::vector<std::tuple<std::unique_ptr<SparseSet<Entity>>, signal_type, signal_type>> pools;
    1610  std::vector<std::tuple<std::unique_ptr<Attachee>, signal_type, signal_type>> tags;
    1611  std::vector<entity_type> entities;
    1612  size_type available{};
    1613  entity_type next{};
    1614 };
    1615 
    1616 
    1623 using DefaultRegistry = Registry<std::uint32_t>;
    1624 
    1625 
    1626 }
    1627 
    1628 
    1629 #endif // ENTT_ENTITY_REGISTRY_HPP
    entt::Registry::each
    void each(Func func) const
    Iterates all the entities that are still in use.
    Definition: registry.hpp:1249
    +
    entt::Registry::discard
    void discard()
    Discards all the data structures used for a given persitent view.
    Definition: registry.hpp:1409
    +
    entt::Registry::sink_type
    typename signal_type::sink_type sink_type
    Type of sink for the given component.
    Definition: registry.hpp:160
    +
    entt::Registry::sort
    void sort(Compare compare, Sort sort=Sort{}, Args &&... args)
    Sorts the pool of entities for the given component.
    Definition: registry.hpp:1123
    +
    entt::Registry::orphans
    void orphans(Func func) const
    Iterates orphans and applies them the given function object.
    Definition: registry.hpp:1310
    +
    entt::Registry::size
    size_type size() const ENTT_NOEXCEPT
    Returns the number of entities created so far.
    Definition: registry.hpp:223
    +
    entt::Registry::has
    bool has() const ENTT_NOEXCEPT
    Checks if the given tag has an owner.
    Definition: registry.hpp:669
    +
    entt::Registry::alive
    size_type alive() const ENTT_NOEXCEPT
    Returns the number of entities still in use.
    Definition: registry.hpp:231
    +
    entt::Registry::reset
    void reset()
    Resets the pool of the given component.
    Definition: registry.hpp:1201
    +
    entt::Registry::accommodate
    Component & accommodate(const entity_type entity, Args &&... args)
    Assigns or replaces the given component for an entity.
    Definition: registry.hpp:956
    +
    entt::Registry::destroy
    void destroy(const entity_type entity)
    Destroys an entity and lets the registry recycle the identifier.
    Definition: registry.hpp:509
    entt::Registry
    Fast and reliable entity-component system.
    Definition: registry.hpp:40
    entt::raw_t
    Raw view type used to disambiguate overloads.
    Definition: utility.hpp:17
    entt::persistent_t
    Persistent view type used to disambiguate overloads.
    Definition: utility.hpp:13
    -
    entt::Registry::destruction
    sink_type destruction() ENTT_NOEXCEPT
    Returns a sink object for the given component.
    Definition: registry.hpp:1031
    -
    entt::Registry::type
    static component_type type() ENTT_NOEXCEPT
    Returns the numeric identifier of a type of component at runtime.
    Definition: registry.hpp:176
    -
    entt::Registry::size
    size_type size() const ENTT_NOEXCEPT
    Returns the number of existing components of the given type.
    Definition: registry.hpp:186
    +
    entt::Registry::destruction
    sink_type destruction() ENTT_NOEXCEPT
    Returns a sink object for the given component.
    Definition: registry.hpp:1076
    +
    entt::Registry::type
    static component_type type() ENTT_NOEXCEPT
    Returns the numeric identifier of a type of component at runtime.
    Definition: registry.hpp:205
    +
    entt::Registry::size
    size_type size() const ENTT_NOEXCEPT
    Returns the number of existing components of the given type.
    Definition: registry.hpp:215
    entt::SnapshotLoader
    Utility class to restore a snapshot as a whole.
    Definition: snapshot.hpp:261
    -
    entt::Registry::assign
    Component & assign(const entity_type entity, Args &&... args)
    Assigns the given component to an entity.
    Definition: registry.hpp:574
    -
    entt::Registry::prepare
    void prepare()
    Prepares the internal data structures used by persistent views.
    Definition: registry.hpp:1329
    -
    entt::RawView
    Raw view.
    Definition: view.hpp:1300
    -
    entt::Registry::move
    entity_type move(const entity_type entity) ENTT_NOEXCEPT
    Changes the owner of the given tag.
    Definition: registry.hpp:857
    +
    entt::Registry::assign
    Component & assign(const entity_type entity, Args &&... args)
    Assigns the given component to an entity.
    Definition: registry.hpp:619
    +
    entt::Registry::prepare
    void prepare()
    Prepares the internal data structures used by persistent views.
    Definition: registry.hpp:1374
    +
    entt::RawView
    Raw view.
    Definition: view.hpp:1295
    +
    entt::Registry::move
    entity_type move(const entity_type entity) ENTT_NOEXCEPT
    Changes the owner of the given tag.
    Definition: registry.hpp:902
    entt
    EnTT default namespace.
    Definition: algorithm.hpp:10
    -
    entt::Registry::destroy
    void destroy(Type...)
    Destroys the entities that own he given components, if any.
    Definition: registry.hpp:515
    +
    entt::Registry::destroy
    void destroy(Type...)
    Destroys the entities that own the given components, if any.
    Definition: registry.hpp:560
    entt::Snapshot
    Utility class to create snapshots from a registry.
    Definition: snapshot.hpp:38
    -
    entt::Registry::empty
    bool empty() const ENTT_NOEXCEPT
    Checks if there exists at least an entity still in use.
    Definition: registry.hpp:259
    -
    entt::Registry::has
    bool has(const entity_type entity) const ENTT_NOEXCEPT
    Checks if an entity has all the given components.
    Definition: registry.hpp:668
    -
    entt::Registry::destruction
    sink_type destruction(tag_t) ENTT_NOEXCEPT
    Returns a sink object for the given tag.
    Definition: registry.hpp:1002
    -
    entt::Registry::destroy
    void destroy(tag_t)
    Destroys the entity that owns the given tag, if any.
    Definition: registry.hpp:438
    -
    entt::Registry::replace
    Tag & replace(tag_t, Args &&... args)
    Replaces the given tag.
    Definition: registry.hpp:811
    +
    entt::Registry::empty
    bool empty() const ENTT_NOEXCEPT
    Checks if there exists at least an entity still in use.
    Definition: registry.hpp:296
    +
    entt::Registry::has
    bool has(const entity_type entity) const ENTT_NOEXCEPT
    Checks if an entity has all the given components.
    Definition: registry.hpp:713
    +
    entt::Registry::destruction
    sink_type destruction(tag_t) ENTT_NOEXCEPT
    Returns a sink object for the given tag.
    Definition: registry.hpp:1047
    +
    entt::Registry::destroy
    void destroy(tag_t)
    Destroys the entity that owns the given tag, if any.
    Definition: registry.hpp:483
    +
    entt::Registry::replace
    Tag & replace(tag_t, Args &&... args)
    Replaces the given tag.
    Definition: registry.hpp:856
    entt::Registry::Registry
    Registry()=default
    Default constructor.
    entt::SparseSet
    Sparse set.
    Definition: sparse_set.hpp:29
    -
    entt::Registry::construction
    sink_type construction() ENTT_NOEXCEPT
    Returns a sink object for the given component.
    Definition: registry.hpp:973
    -
    entt::Registry::contains
    bool contains() const ENTT_NOEXCEPT
    Checks if a persistent view has already been prepared.
    Definition: registry.hpp:1397
    -
    entt::Registry::type
    static tag_type type(tag_t) ENTT_NOEXCEPT
    Returns the numeric identifier of a type of tag at runtime.
    Definition: registry.hpp:159
    -
    entt::Registry::raw
    const Component * raw() const ENTT_NOEXCEPT
    Direct access to the list of components of a given pool.
    Definition: registry.hpp:278
    -
    entt::Registry::version
    version_type version(const entity_type entity) const ENTT_NOEXCEPT
    Returns the version stored along with an entity identifier.
    Definition: registry.hpp:358
    -
    entt::Registry::version_type
    typename traits_type::version_type version_type
    Underlying version type.
    Definition: registry.hpp:123
    -
    entt::Registry::reset
    void reset()
    Resets a whole registry.
    Definition: registry.hpp:1176
    +
    entt::Registry::construction
    sink_type construction() ENTT_NOEXCEPT
    Returns a sink object for the given component.
    Definition: registry.hpp:1018
    +
    entt::Registry::contains
    bool contains() const ENTT_NOEXCEPT
    Checks if a persistent view has already been prepared.
    Definition: registry.hpp:1422
    +
    entt::Registry::type
    static tag_type type(tag_t) ENTT_NOEXCEPT
    Returns the numeric identifier of a type of tag at runtime.
    Definition: registry.hpp:188
    +
    entt::Registry::raw
    const Component * raw() const ENTT_NOEXCEPT
    Direct access to the list of components of a given pool.
    Definition: registry.hpp:315
    +
    entt::Registry::version
    version_type version(const entity_type entity) const ENTT_NOEXCEPT
    Returns the version stored along with an entity identifier.
    Definition: registry.hpp:404
    +
    entt::Registry::version_type
    typename traits_type::version_type version_type
    Underlying version type.
    Definition: registry.hpp:152
    +
    entt::Registry::reset
    void reset()
    Resets a whole registry.
    Definition: registry.hpp:1221
    entt::Family::type
    static family_type type() ENTT_NOEXCEPT
    Returns an unique identifier for the given type.
    Definition: family.hpp:40
    -
    entt::Registry::create
    entity_type create()
    Creates a new entity and returns it.
    Definition: registry.hpp:402
    -
    entt::Registry::empty
    bool empty() const ENTT_NOEXCEPT
    Checks whether the pool of the given component is empty.
    Definition: registry.hpp:251
    -
    entt::Registry::view
    View< Entity, Component... > view()
    Returns a standard view for the given components.
    Definition: registry.hpp:1308
    -
    entt::Registry::current
    version_type current(const entity_type entity) const ENTT_NOEXCEPT
    Returns the actual version for an entity identifier.
    Definition: registry.hpp:379
    -
    entt::Registry::reserve
    void reserve(const size_type cap)
    Increases the capacity of the pool for the given component.
    Definition: registry.hpp:208
    -
    entt::Registry::view
    PersistentView< Entity, Component... > view(persistent_t)
    Returns a persistent view for the given components.
    Definition: registry.hpp:1443
    -
    entt::Registry::raw
    Component * raw() ENTT_NOEXCEPT
    Direct access to the list of components of a given pool.
    Definition: registry.hpp:297
    -
    entt::Registry::construction
    sink_type construction(tag_t) ENTT_NOEXCEPT
    Returns a sink object for the given tag.
    Definition: registry.hpp:944
    -
    entt::Registry::view
    RawView< Entity, Component > view(raw_t)
    Returns a raw view for the given component.
    Definition: registry.hpp:1473
    +
    entt::Registry::create
    entity_type create()
    Creates a new entity and returns it.
    Definition: registry.hpp:448
    +
    entt::Registry::empty
    bool empty() const ENTT_NOEXCEPT
    Checks whether the pool of the given component is empty.
    Definition: registry.hpp:288
    +
    entt::Registry::view
    View< Entity, Component... > view()
    Returns a standard view for the given components.
    Definition: registry.hpp:1353
    +
    entt::Registry::current
    version_type current(const entity_type entity) const ENTT_NOEXCEPT
    Returns the actual version for an entity identifier.
    Definition: registry.hpp:425
    +
    entt::Registry::reserve
    void reserve(const size_type cap)
    Increases the capacity of the pool for the given component.
    Definition: registry.hpp:245
    +
    entt::Registry::view
    PersistentView< Entity, Component... > view(persistent_t)
    Returns a persistent view for the given components.
    Definition: registry.hpp:1468
    +
    entt::Registry::raw
    Component * raw() ENTT_NOEXCEPT
    Direct access to the list of components of a given pool.
    Definition: registry.hpp:334
    +
    entt::Registry::construction
    sink_type construction(tag_t) ENTT_NOEXCEPT
    Returns a sink object for the given tag.
    Definition: registry.hpp:989
    +
    entt::Registry::view
    RawView< Entity, Component > view(raw_t)
    Returns a raw view for the given component.
    Definition: registry.hpp:1498
    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:125
    -
    entt::Registry::sort
    void sort()
    Sorts two pools of components in the same way.
    Definition: registry.hpp:1114
    -
    entt::Registry::data
    const entity_type * data() const ENTT_NOEXCEPT
    Direct access to the list of entities of a given pool.
    Definition: registry.hpp:316
    -
    entt::Registry::restore
    SnapshotLoader< Entity > restore() ENTT_NOEXCEPT
    Returns a temporary object to use to load snapshots.
    Definition: registry.hpp:1555
    -
    entt::Registry::valid
    bool valid(const entity_type entity) const ENTT_NOEXCEPT
    Checks if an entity identifier refers to a valid entity.
    Definition: registry.hpp:325
    -
    entt::Registry::component_type
    typename component_family::family_type component_type
    Unsigned integer type.
    Definition: registry.hpp:129
    -
    entt::Registry::assign
    Tag & assign(tag_t, const entity_type entity, Args &&... args)
    Attaches the given tag to an entity.
    Definition: registry.hpp:543
    -
    entt::Registry::entity_type
    typename traits_type::entity_type entity_type
    Underlying entity identifier.
    Definition: registry.hpp:121
    +
    entt::Registry::size_type
    std::size_t size_type
    Unsigned integer type.
    Definition: registry.hpp:154
    +
    entt::Registry::sort
    void sort()
    Sorts two pools of components in the same way.
    Definition: registry.hpp:1159
    +
    entt::Registry::data
    const entity_type * data() const ENTT_NOEXCEPT
    Direct access to the list of entities of a given pool.
    Definition: registry.hpp:353
    +
    entt::Registry::restore
    SnapshotLoader< Entity > restore() ENTT_NOEXCEPT
    Returns a temporary object to use to load snapshots.
    Definition: registry.hpp:1580
    +
    entt::Registry::valid
    bool valid(const entity_type entity) const ENTT_NOEXCEPT
    Checks if an entity identifier refers to a valid entity.
    Definition: registry.hpp:362
    +
    entt::Registry::component_type
    typename component_family::family_type component_type
    Unsigned integer type.
    Definition: registry.hpp:158
    +
    entt::Registry::entity
    entity_type entity(const entity_type entity) const ENTT_NOEXCEPT
    Returns the entity identifier without the version.
    Definition: registry.hpp:395
    +
    entt::Registry::assign
    Tag & assign(tag_t, const entity_type entity, Args &&... args)
    Attaches the given tag to an entity.
    Definition: registry.hpp:588
    +
    entt::Registry::entity_type
    typename traits_type::entity_type entity_type
    Underlying entity identifier.
    Definition: registry.hpp:150
    entt::View
    Multi component view.
    Definition: view.hpp:466
    entt::StdSort
    Function object to wrap std::sort in a class type.
    Definition: algorithm.hpp:21
    entt::PersistentView
    Persistent view.
    Definition: view.hpp:71
    entt::SigH
    Unmanaged signal handler declaration.
    Definition: sigh.hpp:112
    entt::Family::family_type
    std::size_t family_type
    Unsigned integer type.
    Definition: family.hpp:33
    -
    entt::Registry::view
    RuntimeView< Entity > view(It first, It last)
    Returns a runtime view for the given components.
    Definition: registry.hpp:1505
    -
    entt::Registry::capacity
    size_type capacity() const ENTT_NOEXCEPT
    Returns the number of entities that a registry has currently allocated space for. ...
    Definition: registry.hpp:240
    -
    entt::Registry::fast
    bool fast(const entity_type entity) const ENTT_NOEXCEPT
    Checks if an entity identifier refers to a valid entity.
    Definition: registry.hpp:347
    +
    entt::Registry::view
    RuntimeView< Entity > view(It first, It last)
    Returns a runtime view for the given components.
    Definition: registry.hpp:1530
    +
    entt::Registry::capacity
    size_type capacity() const ENTT_NOEXCEPT
    Returns the number of entities that a registry has currently allocated space for. ...
    Definition: registry.hpp:277
    +
    entt::Registry::fast
    bool fast(const entity_type entity) const ENTT_NOEXCEPT
    Checks if an entity identifier refers to a valid entity.
    Definition: registry.hpp:384
    entt::Family
    Dynamic identifier generator.
    Definition: family.hpp:22
    -
    entt::Registry::reset
    void reset(const entity_type entity)
    Resets the given component for an entity.
    Definition: registry.hpp:1135
    +
    entt::Registry::reset
    void reset(const entity_type entity)
    Resets the given component for an entity.
    Definition: registry.hpp:1180
    entt::tag_t
    Tag class type used to disambiguate overloads.
    Definition: utility.hpp:9
    -
    entt::Registry::replace
    Component & replace(const entity_type entity, Args &&... args)
    Replaces the given component for an entity.
    Definition: registry.hpp:836
    -
    entt::Registry::capacity
    size_type capacity() const ENTT_NOEXCEPT
    Returns the capacity of the pool for the given component.
    Definition: registry.hpp:231
    -
    entt::Registry::snapshot
    Snapshot< Entity > snapshot() const ENTT_NOEXCEPT
    Returns a temporary object to use to create snapshots.
    Definition: registry.hpp:1526
    -
    entt::Registry::tag_type
    typename tag_family::family_type tag_type
    Unsigned integer type.
    Definition: registry.hpp:127
    -
    entt::Registry::has
    bool has(tag_t, const entity_type entity) const ENTT_NOEXCEPT
    Checks if an entity owns the given tag.
    Definition: registry.hpp:651
    -
    entt::Registry::attachee
    entity_type attachee() const ENTT_NOEXCEPT
    Gets the owner of the given tag, if any.
    Definition: registry.hpp:879
    -
    entt::Registry::orphan
    bool orphan(const entity_type entity) const
    Checks if an entity is an orphan.
    Definition: registry.hpp:1231
    -
    entt::RuntimeView
    Runtime view.
    Definition: view.hpp:1595
    +
    entt::Registry::replace
    Component & replace(const entity_type entity, Args &&... args)
    Replaces the given component for an entity.
    Definition: registry.hpp:881
    +
    entt::Registry::capacity
    size_type capacity() const ENTT_NOEXCEPT
    Returns the capacity of the pool for the given component.
    Definition: registry.hpp:268
    +
    entt::Registry::snapshot
    Snapshot< Entity > snapshot() const ENTT_NOEXCEPT
    Returns a temporary object to use to create snapshots.
    Definition: registry.hpp:1551
    +
    entt::Registry::tag_type
    typename tag_family::family_type tag_type
    Unsigned integer type.
    Definition: registry.hpp:156
    +
    entt::Registry::has
    bool has(tag_t, const entity_type entity) const ENTT_NOEXCEPT
    Checks if an entity owns the given tag.
    Definition: registry.hpp:696
    +
    entt::Registry::attachee
    entity_type attachee() const ENTT_NOEXCEPT
    Gets the owner of the given tag, if any.
    Definition: registry.hpp:924
    +
    entt::Registry::orphan
    bool orphan(const entity_type entity) const
    Checks if an entity is an orphan.
    Definition: registry.hpp:1276
    +
    entt::RuntimeView
    Runtime view.
    Definition: view.hpp:1590
    entt::entt_traits
    Entity traits.
    Definition: entt_traits.hpp:18
    -
    entt::Registry::reserve
    void reserve(const size_type cap)
    Increases the capacity of a registry in terms of entities.
    Definition: registry.hpp:221
    +
    entt::Registry::reserve
    void reserve(const size_type cap)
    Increases the capacity of a registry in terms of entities.
    Definition: registry.hpp:258
    diff --git a/scheduler_8hpp_source.html b/scheduler_8hpp_source.html index 6871d1a19..b6a8a0381 100644 --- a/scheduler_8hpp_source.html +++ b/scheduler_8hpp_source.html @@ -5,7 +5,7 @@ -entt: src/entt/process/scheduler.hpp Source File +EnTT: src/entt/process/scheduler.hpp Source File @@ -21,8 +21,8 @@ -
    entt -  2.7.1 +
    EnTT +  2.7.2
    diff --git a/search/all_0.js b/search/all_0.js index 272581c28..2cd4b91e1 100644 --- a/search/all_0.js +++ b/search/all_0.js @@ -3,7 +3,7 @@ var searchData= ['abort',['abort',['../classentt_1_1Process.html#ae7a9c2acd493969267ce4a6d2e2884b8',1,'entt::Process::abort()'],['../classentt_1_1Scheduler.html#af2494e025703d03a87117d6e897c87db',1,'entt::Scheduler::abort()']]], ['accommodate',['accommodate',['../classentt_1_1Prototype.html#adaec9cc16436af85ef938fc9686cd02d',1,'entt::Prototype::accommodate(registry_type &other, const entity_type dst) const'],['../classentt_1_1Prototype.html#a37299298c61bb06a75b697296e328477',1,'entt::Prototype::accommodate(const entity_type dst) const'],['../classentt_1_1Registry.html#a6333a56f3a5a58882963a11bbbcf2ac2',1,'entt::Registry::accommodate()']]], ['actor',['Actor',['../structentt_1_1Actor.html',1,'entt::Actor< Entity >'],['../structentt_1_1Actor.html#a000a099327600af5eaf86990fe886260',1,'entt::Actor::Actor(Registry< Entity > &reg)'],['../structentt_1_1Actor.html#a02fb1433a35bb6df68a79a8bdd80036c',1,'entt::Actor::Actor(const Actor &)=default'],['../structentt_1_1Actor.html#a851508562e73c601be2965929b31c218',1,'entt::Actor::Actor(Actor &&)=default']]], - ['alive',['alive',['../classentt_1_1Process.html#ad18ce3558d2325d622fb2b8ab51c49d5',1,'entt::Process']]], + ['alive',['alive',['../classentt_1_1Registry.html#a4288576a8d41018b63838d4afdd01717',1,'entt::Registry::alive()'],['../classentt_1_1Process.html#ad18ce3558d2325d622fb2b8ab51c49d5',1,'entt::Process::alive()']]], ['assign',['assign',['../structentt_1_1Actor.html#a0a161248d739e780833e534f7d1cf638',1,'entt::Actor::assign(tag_t, Args &&... args)'],['../structentt_1_1Actor.html#a7631fdb2de787c10b016a71905906147',1,'entt::Actor::assign(Args &&... args)'],['../classentt_1_1Prototype.html#a0a52cda550a678ee14272cff7b2fcf35',1,'entt::Prototype::assign(registry_type &other, const entity_type dst) const'],['../classentt_1_1Prototype.html#ab7bf733f40f1071d73d4f3245526c038',1,'entt::Prototype::assign(const entity_type dst) const'],['../classentt_1_1Registry.html#a93b5717af287a2b97e0ef9695c51ed58',1,'entt::Registry::assign(tag_t, const entity_type entity, Args &&... args)'],['../classentt_1_1Registry.html#a01f87450271067dda6c87f0c7c9b80dd',1,'entt::Registry::assign(const entity_type entity, Args &&... args)']]], ['attach',['attach',['../classentt_1_1Scheduler.html#a1a836000f65e8e275119c0f77ec46674',1,'entt::Scheduler::attach(Args &&... args)'],['../classentt_1_1Scheduler.html#a5915b9783b278a6006d4857feefc0e3b',1,'entt::Scheduler::attach(Func &&func)']]], ['attachee',['attachee',['../classentt_1_1Registry.html#af157dcabe4fe027e2f9cd45f4958f3b9',1,'entt::Registry']]] diff --git a/search/all_2.js b/search/all_2.js index 68cbe0079..7d1177433 100644 --- a/search/all_2.js +++ b/search/all_2.js @@ -1,5 +1,6 @@ var searchData= [ + ['contributing',['Contributing',['../autotoc_md0.html',1,'']]], ['capacity',['capacity',['../classentt_1_1Registry.html#a38e5391f9c1b4a8ea814f0abcf7a3323',1,'entt::Registry::capacity() const ENTT_NOEXCEPT'],['../classentt_1_1Registry.html#aefe4ec26db45257de26da19147a9e3f3',1,'entt::Registry::capacity() const ENTT_NOEXCEPT'],['../classentt_1_1SparseSet_3_01Entity_01_4.html#affd4ddc4bc12517d84772a40b0d992d5',1,'entt::SparseSet< Entity >::capacity()']]], ['cbegin',['cbegin',['../classentt_1_1SparseSet_3_01Entity_01_4.html#a1ba1127cc520b39c2d147da99000866f',1,'entt::SparseSet< Entity >::cbegin()'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#af38e9a34f90809eae7b2d51882cc2302',1,'entt::SparseSet< Entity, Type >::cbegin()'],['../classentt_1_1PersistentView.html#a5a6d810548ae9959047cc1a6249c5aff',1,'entt::PersistentView::cbegin()'],['../classentt_1_1View.html#a2cefabdbdd85098f9ac789a47fcc930a',1,'entt::View::cbegin()'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a2cefabdbdd85098f9ac789a47fcc930a',1,'entt::View< Entity, Component >::cbegin()'],['../classentt_1_1RawView.html#a2550b7ceee635d59bac8eddce6523cf3',1,'entt::RawView::cbegin()'],['../classentt_1_1RuntimeView.html#a838fbbbceba139250db0dd186de86506',1,'entt::RuntimeView::cbegin()']]], ['cend',['cend',['../classentt_1_1SparseSet_3_01Entity_01_4.html#aaec7e4e14421c38084ef57b13d40a15d',1,'entt::SparseSet< Entity >::cend()'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#ae5994b196eca429c708722ba4b720208',1,'entt::SparseSet< Entity, Type >::cend()'],['../classentt_1_1PersistentView.html#a8ae9798901deacb27827f23b9ab51fe2',1,'entt::PersistentView::cend()'],['../classentt_1_1View.html#ab57c0ac7a0bb1487f525757a07a6bd71',1,'entt::View::cend()'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#ab57c0ac7a0bb1487f525757a07a6bd71',1,'entt::View< Entity, Component >::cend()'],['../classentt_1_1RawView.html#aedfe14bbc1b65afecc549cc65354575f',1,'entt::RawView::cend()'],['../classentt_1_1RuntimeView.html#a111c068457853eb5c55845e68fd7b8a6',1,'entt::RuntimeView::cend()']]], diff --git a/search/all_4.js b/search/all_4.js index 7f06fdd6d..15198cfb9 100644 --- a/search/all_4.js +++ b/search/all_4.js @@ -6,7 +6,7 @@ var searchData= ['end',['end',['../classentt_1_1SparseSet_3_01Entity_01_4.html#a956957bcafba7391d1008110596d5714',1,'entt::SparseSet< Entity >::end() const ENTT_NOEXCEPT'],['../classentt_1_1SparseSet_3_01Entity_01_4.html#a14720d48f6d553a06813379ee6d7092f',1,'entt::SparseSet< Entity >::end() ENTT_NOEXCEPT'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#aa04fe0d91fc40c8982cdfada8664e9b1',1,'entt::SparseSet< Entity, Type >::end() const ENTT_NOEXCEPT'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#a43b4c3d129ab2b6559154f8db037bfd5',1,'entt::SparseSet< Entity, Type >::end() ENTT_NOEXCEPT'],['../classentt_1_1PersistentView.html#a0e614f77f05085e951e761d8ca967a84',1,'entt::PersistentView::end() const ENTT_NOEXCEPT'],['../classentt_1_1PersistentView.html#a470ef6edb944f127e26f7e3398cbded1',1,'entt::PersistentView::end() ENTT_NOEXCEPT'],['../classentt_1_1View.html#af0cbc67f83e47cb4cbb3a1a26d7cd263',1,'entt::View::end() const ENTT_NOEXCEPT'],['../classentt_1_1View.html#a34bca7c2c996fe26e150c0a7a2dbb69d',1,'entt::View::end() ENTT_NOEXCEPT'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#af0cbc67f83e47cb4cbb3a1a26d7cd263',1,'entt::View< Entity, Component >::end() const ENTT_NOEXCEPT'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a34bca7c2c996fe26e150c0a7a2dbb69d',1,'entt::View< Entity, Component >::end() ENTT_NOEXCEPT'],['../classentt_1_1RawView.html#ad7ad0559b9b4a440813e1752b0814bb4',1,'entt::RawView::end() const ENTT_NOEXCEPT'],['../classentt_1_1RawView.html#a8ebfe24e5a5e428b429f470755d0a1f7',1,'entt::RawView::end() ENTT_NOEXCEPT'],['../classentt_1_1RuntimeView.html#af8040215c3db60033388328ddff9a5d8',1,'entt::RuntimeView::end() const ENTT_NOEXCEPT'],['../classentt_1_1RuntimeView.html#afc2af975c32c247e0c333d4e49c0208c',1,'entt::RuntimeView::end() ENTT_NOEXCEPT']]], ['enqueue',['enqueue',['../classentt_1_1Dispatcher.html#a431743aa289ce022f7ee87cd7fb3eedf',1,'entt::Dispatcher']]], ['entities',['entities',['../classentt_1_1Snapshot.html#aa77d63e06c40969adca662fca3a2ca08',1,'entt::Snapshot::entities()'],['../classentt_1_1SnapshotLoader.html#a7bff030b50995a78f79217eecfb90535',1,'entt::SnapshotLoader::entities()'],['../classentt_1_1ContinuousLoader.html#a26eadd32f719c24de2305347a5066197',1,'entt::ContinuousLoader::entities()']]], - ['entity',['entity',['../structentt_1_1Actor.html#afb70b6f30071680efab23715a7e61a29',1,'entt::Actor']]], + ['entity',['entity',['../structentt_1_1Actor.html#afb70b6f30071680efab23715a7e61a29',1,'entt::Actor::entity()'],['../classentt_1_1Registry.html#a43374c03910bf8b7337992d1bcc88e30',1,'entt::Registry::entity()']]], ['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',['../structentt_1_1Actor.html#a809cbe96d54fe86b470246a34e873a4e',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_1Prototype.html#ab4542df6834170b6f0d96828d094269d',1,'entt::Prototype::entity_type()'],['../classentt_1_1Registry.html#ad434a1920dd2c6a9a31ab482e2f29038',1,'entt::Registry::entity_type()'],['../classentt_1_1ContinuousLoader.html#ae2ddecfaeb16ddbf340b6ca643036c6f',1,'entt::ContinuousLoader::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#a61be0e712de89d1eb275e14bbc59174e',1,'entt::View::entity_type()'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a75fc64bf381a3003d8acf03ed66728f2',1,'entt::View< Entity, Component >::entity_type()'],['../classentt_1_1RawView.html#a544ee87b4a856cfa5c49ea4581c85a35',1,'entt::RawView::entity_type()'],['../classentt_1_1RuntimeView.html#ad5b5d664d388179dc164814e6268a774',1,'entt::RuntimeView::entity_type()']]], @@ -16,6 +16,5 @@ var searchData= ['entt_5ftraits_3c_20std_3a_3auint32_5ft_20_3e',['entt_traits< std::uint32_t >',['../structentt_1_1entt__traits_3_01std_1_1uint32__t_01_4.html',1,'entt']]], ['entt_5ftraits_3c_20std_3a_3auint64_5ft_20_3e',['entt_traits< std::uint64_t >',['../structentt_1_1entt__traits_3_01std_1_1uint64__t_01_4.html',1,'entt']]], ['erase',['erase',['../classentt_1_1Emitter.html#ab15f07d10744ce8aa74964fa5623375c',1,'entt::Emitter']]], - ['extent',['extent',['../classentt_1_1SparseSet_3_01Entity_01_4.html#ab314d3642b6a5b90bbcb170ba83b7978',1,'entt::SparseSet< Entity >']]], - ['entt_20framework',['EnTT Framework',['../index.html',1,'']]] + ['extent',['extent',['../classentt_1_1SparseSet_3_01Entity_01_4.html#ab314d3642b6a5b90bbcb170ba83b7978',1,'entt::SparseSet< Entity >']]] ]; diff --git a/search/all_9.js b/search/all_9.js index 14c692f22..ec9117c10 100644 --- a/search/all_9.js +++ b/search/all_9.js @@ -1,5 +1,6 @@ var searchData= [ + ['label',['label',['../namespaceentt.html#a8512c4b75207424bd97724a17cd1eeb0',1,'entt']]], ['listener',['Listener',['../classentt_1_1Emitter.html#a1a5bb5d6a7626aec285cc73bfc1e80ef',1,'entt::Emitter']]], ['load',['load',['../classentt_1_1ResourceCache.html#a12155caf98459157ed5dbf3b3c4d545f',1,'entt::ResourceCache']]] ]; diff --git a/search/all_c.js b/search/all_c.js index dd1fb01f3..018957c14 100644 --- a/search/all_c.js +++ b/search/all_c.js @@ -3,13 +3,14 @@ var searchData= ['object_5ftype',['object_type',['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#af7db79dfb4e031a63fa526d4f7d54915',1,'entt::SparseSet< Entity, Type >']]], ['on',['on',['../classentt_1_1Emitter.html#a1df9a54b806806add57c3168cbb2bdf1',1,'entt::Emitter']]], ['once',['once',['../classentt_1_1Emitter.html#a1145cc27235acf0e24e1956ba0b15393',1,'entt::Emitter']]], + ['oneshotbubblesort',['OneShotBubbleSort',['../structentt_1_1OneShotBubbleSort.html',1,'entt']]], ['operator_20bool',['operator bool',['../classentt_1_1ResourceHandle.html#a4da18e304419e8d070fbc095236b4403',1,'entt::ResourceHandle']]], ['operator_20const_20char_20_2a',['operator const char *',['../classentt_1_1HashedString.html#ac93c062eb14c80be82bd75bb6e853be0',1,'entt::HashedString']]], ['operator_20const_20resource_20_26',['operator const Resource &',['../classentt_1_1ResourceHandle.html#aa728424029a170454b7e61056af0926a',1,'entt::ResourceHandle']]], ['operator_20hash_5ftype',['operator hash_type',['../classentt_1_1HashedString.html#a47843deb0d550b5a6e1129a9b913d85f',1,'entt::HashedString']]], ['operator_20type',['operator Type',['../structentt_1_1Monostate.html#ae16dec68153e1cf761d8c2379c4e3e8c',1,'entt::Monostate']]], ['operator_21_3d',['operator!=',['../namespaceentt.html#a8a638f5585d404bbdcfd8efdfeb39203',1,'entt::operator!=(const HashedString &lhs, const HashedString &rhs) ENTT_NOEXCEPT'],['../namespaceentt.html#aef8743ab32f59bd2905b9fa2938318b6',1,'entt::operator!=(const Delegate< Ret(Args...)> &lhs, const Delegate< Ret(Args...)> &rhs) ENTT_NOEXCEPT'],['../namespaceentt.html#a13ce28be581233dd1e9179a126dd979d',1,'entt::operator!=(const SigH< Ret(Args...)> &lhs, const SigH< Ret(Args...)> &rhs) ENTT_NOEXCEPT']]], - ['operator_28_29',['operator()',['../structentt_1_1StdSort.html#a3363910b5a138b20f96d8a967a7bbd8b',1,'entt::StdSort::operator()()'],['../structentt_1_1InsertionSort.html#a53f94456eb885d9a02344b33b39f8815',1,'entt::InsertionSort::operator()()'],['../classentt_1_1Prototype.html#ac7cb69aad2015e94f3a0a9ad42b82f1b',1,'entt::Prototype::operator()(registry_type &other, const entity_type dst) const ENTT_NOEXCEPT'],['../classentt_1_1Prototype.html#a6b0560c31432fb6591a772ce9a322728',1,'entt::Prototype::operator()(const entity_type dst) const ENTT_NOEXCEPT'],['../classentt_1_1Prototype.html#a7c401ecc89b0c88ab15ed2dd7686b54e',1,'entt::Prototype::operator()(registry_type &other) const ENTT_NOEXCEPT'],['../classentt_1_1Prototype.html#ad39dd5c5449cc647a1402543ebe411fe',1,'entt::Prototype::operator()() const ENTT_NOEXCEPT'],['../classentt_1_1Delegate_3_01Ret_07Args_8_8_8_08_4.html#a3259f295bc4ea1da8307d1be65c83d6a',1,'entt::Delegate< Ret(Args...)>::operator()()']]], + ['operator_28_29',['operator()',['../structentt_1_1StdSort.html#a3363910b5a138b20f96d8a967a7bbd8b',1,'entt::StdSort::operator()()'],['../structentt_1_1InsertionSort.html#a53f94456eb885d9a02344b33b39f8815',1,'entt::InsertionSort::operator()()'],['../structentt_1_1OneShotBubbleSort.html#a9c8c582c4a83a9faaf1e328296daf971',1,'entt::OneShotBubbleSort::operator()()'],['../classentt_1_1Prototype.html#ac7cb69aad2015e94f3a0a9ad42b82f1b',1,'entt::Prototype::operator()(registry_type &other, const entity_type dst) const ENTT_NOEXCEPT'],['../classentt_1_1Prototype.html#a6b0560c31432fb6591a772ce9a322728',1,'entt::Prototype::operator()(const entity_type dst) const ENTT_NOEXCEPT'],['../classentt_1_1Prototype.html#a7c401ecc89b0c88ab15ed2dd7686b54e',1,'entt::Prototype::operator()(registry_type &other) const ENTT_NOEXCEPT'],['../classentt_1_1Prototype.html#ad39dd5c5449cc647a1402543ebe411fe',1,'entt::Prototype::operator()() const ENTT_NOEXCEPT'],['../classentt_1_1Delegate_3_01Ret_07Args_8_8_8_08_4.html#a3259f295bc4ea1da8307d1be65c83d6a',1,'entt::Delegate< Ret(Args...)>::operator()()']]], ['operator_2a',['operator*',['../classentt_1_1ResourceHandle.html#a737a5c2e623d30f372ba4876fe3d0fd3',1,'entt::ResourceHandle']]], ['operator_2d_3e',['operator->',['../classentt_1_1ResourceHandle.html#a55727b34cb2bcbff11a680bae2fd793e',1,'entt::ResourceHandle']]], ['operator_3d',['operator=',['../structentt_1_1Monostate.html#a9e94509f038e4a634ce776cdc23548cf',1,'entt::Monostate::operator=()'],['../structentt_1_1Actor.html#af65a5bd2973d27a9adb1a62b746111fe',1,'entt::Actor::operator=(const Actor &)=default'],['../structentt_1_1Actor.html#adbb2c4045a701b76d5fd514ec9221c02',1,'entt::Actor::operator=(Actor &&)=default'],['../classentt_1_1Prototype.html#a65529171240b1b7c348445c7ba4f319e',1,'entt::Prototype::operator=(const Prototype &)=delete'],['../classentt_1_1Prototype.html#a9faf0b8878925090431a9e6acaed06c5',1,'entt::Prototype::operator=(Prototype &&other)'],['../classentt_1_1Registry.html#a6ff250745f1774984a9524d63855f26d',1,'entt::Registry::operator=(const Registry &)=delete'],['../classentt_1_1Registry.html#ade7432a219317a6912553feb2971188b',1,'entt::Registry::operator=(Registry &&)=default'],['../classentt_1_1Snapshot.html#a3375f7d701d086fc21e04e6077c954fc',1,'entt::Snapshot::operator=(const Snapshot &)=delete'],['../classentt_1_1Snapshot.html#a627c0ea635facdd8b8246d1b97de11e3',1,'entt::Snapshot::operator=(Snapshot &&)=default'],['../classentt_1_1SnapshotLoader.html#ad1f8a300b9c5ccf0598cd90ab0e0062f',1,'entt::SnapshotLoader::operator=(const SnapshotLoader &)=delete'],['../classentt_1_1SnapshotLoader.html#a69ed990a8a614e5a1cb90960c216784b',1,'entt::SnapshotLoader::operator=(SnapshotLoader &&)=default'],['../classentt_1_1ContinuousLoader.html#add60e853e8b948f8f3c9f5c73207cb2a',1,'entt::ContinuousLoader::operator=(const ContinuousLoader &)=delete'],['../classentt_1_1ContinuousLoader.html#a3e0c1b78fbd9ba85857c066b5c89adb5',1,'entt::ContinuousLoader::operator=(ContinuousLoader &&)=default'],['../classentt_1_1SparseSet_3_01Entity_01_4.html#a34ffc79377cef381ef5af2e75d61cf4d',1,'entt::SparseSet< Entity >::operator=(const SparseSet &)=delete'],['../classentt_1_1SparseSet_3_01Entity_01_4.html#a24ddfc9e45d7b70639124fe7c2800384',1,'entt::SparseSet< Entity >::operator=(SparseSet &&)=default'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#aa700bb907a18470dce144f84822c67ae',1,'entt::SparseSet< Entity, Type >::operator=(const SparseSet &)=delete'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#a52a81e838ae87413116ab9165ab9ba86',1,'entt::SparseSet< Entity, Type >::operator=(SparseSet &&)=default'],['../classentt_1_1Scheduler.html#a66fa731504da02dfaa607e1c3f153120',1,'entt::Scheduler::operator=(const Scheduler &)=delete'],['../classentt_1_1Scheduler.html#a929ec57792af25f0552f25ad445c7731',1,'entt::Scheduler::operator=(Scheduler &&)=default'],['../classentt_1_1ResourceCache.html#abe56c919c4a2606f87d7d8351261a0e8',1,'entt::ResourceCache::operator=(const ResourceCache &) ENTT_NOEXCEPT=delete'],['../classentt_1_1ResourceCache.html#a18ddc0a0bae71d8124d775d9ddebc550',1,'entt::ResourceCache::operator=(ResourceCache &&) ENTT_NOEXCEPT=default'],['../classentt_1_1ResourceHandle.html#a017670d5037cf65ea0b81b5c094004ac',1,'entt::ResourceHandle::operator=(const ResourceHandle &) ENTT_NOEXCEPT=default'],['../classentt_1_1ResourceHandle.html#a5c6a854be6eca84bd76d8e05f05f657b',1,'entt::ResourceHandle::operator=(ResourceHandle &&) ENTT_NOEXCEPT=default'],['../structentt_1_1Emitter_1_1Connection.html#aa1dba0de2aaa8426f4b42e6c52aa80ea',1,'entt::Emitter::Connection::operator=(const Connection &)=default'],['../structentt_1_1Emitter_1_1Connection.html#a26bc490e1d62f8e7863052f28cc5672c',1,'entt::Emitter::Connection::operator=(Connection &&)=default'],['../classentt_1_1Emitter.html#ace3403fe310953f720dbddff016fe715',1,'entt::Emitter::operator=(const Emitter &)=delete'],['../classentt_1_1Emitter.html#a8d06e737c14bf6be779135529424ca64',1,'entt::Emitter::operator=(Emitter &&)=default']]], diff --git a/search/all_f.js b/search/all_f.js index e7ec18d78..ebb49a239 100644 --- a/search/all_f.js +++ b/search/all_f.js @@ -13,7 +13,7 @@ var searchData= ['sink_5ftype',['sink_type',['../classentt_1_1Registry.html#ada8da3c42b6f37209255eef008581b0b',1,'entt::Registry::sink_type()'],['../classentt_1_1Dispatcher.html#a3b34b8591cdd82022dba3c542054fe68',1,'entt::Dispatcher::sink_type()'],['../classentt_1_1SigH_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4.html#afe3b68f9dc0a2bfe92081c256d0108b7',1,'entt::SigH< Ret(Args...), Collector >::sink_type()']]], ['size',['size',['../classentt_1_1Registry.html#a88d7621801898d0a551cfd98b29a7cd0',1,'entt::Registry::size() const ENTT_NOEXCEPT'],['../classentt_1_1Registry.html#a1be83159fed73573014e6e2919ecabf3',1,'entt::Registry::size() const ENTT_NOEXCEPT'],['../classentt_1_1SparseSet_3_01Entity_01_4.html#a6dc502e9af33ac00af110e5eb8414bc1',1,'entt::SparseSet< Entity >::size()'],['../classentt_1_1PersistentView.html#ad6b816b2acc684733d79ac680005f8da',1,'entt::PersistentView::size()'],['../classentt_1_1View.html#a2244b847c1e148f901ea3b83ec2d6703',1,'entt::View::size()'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a2244b847c1e148f901ea3b83ec2d6703',1,'entt::View< Entity, Component >::size()'],['../classentt_1_1RawView.html#a56cd44cbd4cf15fcaacdcfd9e2b0f710',1,'entt::RawView::size()'],['../classentt_1_1RuntimeView.html#a1532f09ceaac574965c9190554c74f55',1,'entt::RuntimeView::size()'],['../classentt_1_1Scheduler.html#a59aea2fac213df785278870474a3abb5',1,'entt::Scheduler::size()'],['../classentt_1_1ResourceCache.html#a1fb9767a303a85f09497751a7d70623f',1,'entt::ResourceCache::size()'],['../classentt_1_1SigH_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4.html#a5f0c4724d805b4ecdd30045a13ed93ec',1,'entt::SigH< Ret(Args...), Collector >::size()']]], ['size_5ftype',['size_type',['../classentt_1_1Prototype.html#a2a593566474356ad2a03fea9b122de93',1,'entt::Prototype::size_type()'],['../classentt_1_1Registry.html#a741ffda6e06838c5593ba97adc7658e2',1,'entt::Registry::size_type()'],['../classentt_1_1SparseSet_3_01Entity_01_4.html#ab81c48dcee7a1104ee82794613ee7ed2',1,'entt::SparseSet< Entity >::size_type()'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#a27a88e2bb0822de41131741d9ffcded5',1,'entt::SparseSet< Entity, Type >::size_type()'],['../classentt_1_1PersistentView.html#ac2e81caacece38b84f46c4430cd8cf4e',1,'entt::PersistentView::size_type()'],['../classentt_1_1View.html#ab3f86ec55935bbbb00077bbe07f15c4b',1,'entt::View::size_type()'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#afa754b0f10b28dbdb2149b5b8d0fdf73',1,'entt::View< Entity, Component >::size_type()'],['../classentt_1_1RawView.html#afc530c9c64688b522ac643fdb5a0bb6e',1,'entt::RawView::size_type()'],['../classentt_1_1RuntimeView.html#a64ed96d1933ffff0e76f96a0cb38428e',1,'entt::RuntimeView::size_type()'],['../classentt_1_1Scheduler.html#a2d76dbf324cf960ac8f2fc6d87d40eba',1,'entt::Scheduler::size_type()'],['../classentt_1_1ResourceCache.html#a439daf6009e24ae40b1d7689c60ead48',1,'entt::ResourceCache::size_type()'],['../classentt_1_1SigH_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4.html#a7635c4c773fee73faf6eddda2d4abb87',1,'entt::SigH< Ret(Args...), Collector >::size_type()']]], - ['snapshot',['Snapshot',['../classentt_1_1Snapshot.html',1,'entt::Snapshot< Entity >'],['../classentt_1_1Registry.html#a00a0b4949a4cc0cb87e88cc6d1171a9d',1,'entt::Registry::snapshot()'],['../classentt_1_1Snapshot.html#a80f9a56ce8667a5d9947cdaac686fd8d',1,'entt::Snapshot::Snapshot(const Snapshot &)=delete'],['../classentt_1_1Snapshot.html#a3682df1db11f032bfa9ead93c0cec479',1,'entt::Snapshot::Snapshot(Snapshot &&)=default']]], + ['snapshot',['Snapshot',['../classentt_1_1Snapshot.html',1,'entt::Snapshot< Entity >'],['../classentt_1_1Snapshot.html#a80f9a56ce8667a5d9947cdaac686fd8d',1,'entt::Snapshot::Snapshot(const Snapshot &)=delete'],['../classentt_1_1Snapshot.html#a3682df1db11f032bfa9ead93c0cec479',1,'entt::Snapshot::Snapshot(Snapshot &&)=default'],['../classentt_1_1Registry.html#a00a0b4949a4cc0cb87e88cc6d1171a9d',1,'entt::Registry::snapshot()']]], ['snapshotloader',['SnapshotLoader',['../classentt_1_1SnapshotLoader.html',1,'entt::SnapshotLoader< Entity >'],['../classentt_1_1SnapshotLoader.html#a7cc32b25447bf6d13ac36a814e446f4c',1,'entt::SnapshotLoader::SnapshotLoader(const SnapshotLoader &)=delete'],['../classentt_1_1SnapshotLoader.html#ad20cadc8bb3699629cb3ae54bf07b39a',1,'entt::SnapshotLoader::SnapshotLoader(SnapshotLoader &&)=default']]], ['sort',['sort',['../classentt_1_1Registry.html#acb72e05f3128b6604b438707eabdfa4a',1,'entt::Registry::sort(Compare compare, Sort sort=Sort{}, Args &&... args)'],['../classentt_1_1Registry.html#aa3abb830a7ba342266b62ff1a2965754',1,'entt::Registry::sort()'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#a8d2f225354c91f10b427e02dc211d24f',1,'entt::SparseSet< Entity, Type >::sort()'],['../classentt_1_1PersistentView.html#accde3d4b4a904e79c832f6b05f324b05',1,'entt::PersistentView::sort()']]], ['sparseset',['SparseSet',['../classentt_1_1SparseSet.html',1,'entt::SparseSet<... >'],['../classentt_1_1SparseSet_3_01Entity_01_4.html#ac21f0c7137814008016648e166061426',1,'entt::SparseSet< Entity >::SparseSet() ENTT_NOEXCEPT=default'],['../classentt_1_1SparseSet_3_01Entity_01_4.html#aa4ad5318f2be78e8e4336bdf4b012905',1,'entt::SparseSet< Entity >::SparseSet(const SparseSet &)=delete'],['../classentt_1_1SparseSet_3_01Entity_01_4.html#acdfceb557303dee515fe906a13ac759e',1,'entt::SparseSet< Entity >::SparseSet(SparseSet &&)=default'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#a80cd93fb003c8edd8583fb679464a36e',1,'entt::SparseSet< Entity, Type >::SparseSet() ENTT_NOEXCEPT=default'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#a52d68a9763bed211729df965cb7ab859',1,'entt::SparseSet< Entity, Type >::SparseSet(const SparseSet &)=delete'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#a11cbb29701b5a1b1a6e4b77d19d29cec',1,'entt::SparseSet< Entity, Type >::SparseSet(SparseSet &&)=default']]], diff --git a/search/classes_9.js b/search/classes_9.js index 3820dea84..48cb2fab0 100644 --- a/search/classes_9.js +++ b/search/classes_9.js @@ -1,9 +1,4 @@ var searchData= [ - ['persistent_5ft',['persistent_t',['../structentt_1_1persistent__t.html',1,'entt']]], - ['persistentview',['PersistentView',['../classentt_1_1PersistentView.html',1,'entt']]], - ['process',['Process',['../classentt_1_1Process.html',1,'entt']]], - ['process_3c_20processadaptor_3c_20func_2c_20delta_20_3e_2c_20delta_20_3e',['Process< ProcessAdaptor< Func, Delta >, Delta >',['../classentt_1_1Process.html',1,'entt']]], - ['processadaptor',['ProcessAdaptor',['../structentt_1_1ProcessAdaptor.html',1,'entt']]], - ['prototype',['Prototype',['../classentt_1_1Prototype.html',1,'entt']]] + ['oneshotbubblesort',['OneShotBubbleSort',['../structentt_1_1OneShotBubbleSort.html',1,'entt']]] ]; diff --git a/search/classes_a.js b/search/classes_a.js index 6154b5021..3820dea84 100644 --- a/search/classes_a.js +++ b/search/classes_a.js @@ -1,10 +1,9 @@ var searchData= [ - ['raw_5ft',['raw_t',['../structentt_1_1raw__t.html',1,'entt']]], - ['rawview',['RawView',['../classentt_1_1RawView.html',1,'entt']]], - ['registry',['Registry',['../classentt_1_1Registry.html',1,'entt']]], - ['resourcecache',['ResourceCache',['../classentt_1_1ResourceCache.html',1,'entt']]], - ['resourcehandle',['ResourceHandle',['../classentt_1_1ResourceHandle.html',1,'entt']]], - ['resourceloader',['ResourceLoader',['../classentt_1_1ResourceLoader.html',1,'entt']]], - ['runtimeview',['RuntimeView',['../classentt_1_1RuntimeView.html',1,'entt']]] + ['persistent_5ft',['persistent_t',['../structentt_1_1persistent__t.html',1,'entt']]], + ['persistentview',['PersistentView',['../classentt_1_1PersistentView.html',1,'entt']]], + ['process',['Process',['../classentt_1_1Process.html',1,'entt']]], + ['process_3c_20processadaptor_3c_20func_2c_20delta_20_3e_2c_20delta_20_3e',['Process< ProcessAdaptor< Func, Delta >, Delta >',['../classentt_1_1Process.html',1,'entt']]], + ['processadaptor',['ProcessAdaptor',['../structentt_1_1ProcessAdaptor.html',1,'entt']]], + ['prototype',['Prototype',['../classentt_1_1Prototype.html',1,'entt']]] ]; diff --git a/search/classes_b.js b/search/classes_b.js index 260c5e21d..6154b5021 100644 --- a/search/classes_b.js +++ b/search/classes_b.js @@ -1,16 +1,10 @@ var searchData= [ - ['scheduler',['Scheduler',['../classentt_1_1Scheduler.html',1,'entt']]], - ['servicelocator',['ServiceLocator',['../structentt_1_1ServiceLocator.html',1,'entt']]], - ['sigh',['SigH',['../classentt_1_1SigH.html',1,'entt']]], - ['sigh_3c_20ret_28args_2e_2e_2e_29_2c_20collector_20_3e',['SigH< Ret(Args...), Collector >',['../classentt_1_1SigH_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4.html',1,'entt']]], - ['sigh_3c_20void_28const_20event_20_26_29_3e',['SigH< void(const Event &)>',['../classentt_1_1SigH.html',1,'entt']]], - ['sink',['Sink',['../classentt_1_1Sink.html',1,'entt']]], - ['sink_3c_20ret_28args_2e_2e_2e_29_3e',['Sink< Ret(Args...)>',['../classentt_1_1Sink_3_01Ret_07Args_8_8_8_08_4.html',1,'entt']]], - ['snapshot',['Snapshot',['../classentt_1_1Snapshot.html',1,'entt']]], - ['snapshotloader',['SnapshotLoader',['../classentt_1_1SnapshotLoader.html',1,'entt']]], - ['sparseset',['SparseSet',['../classentt_1_1SparseSet.html',1,'entt']]], - ['sparseset_3c_20entity_20_3e',['SparseSet< Entity >',['../classentt_1_1SparseSet_3_01Entity_01_4.html',1,'entt']]], - ['sparseset_3c_20entity_2c_20type_20_3e',['SparseSet< Entity, Type >',['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html',1,'entt']]], - ['stdsort',['StdSort',['../structentt_1_1StdSort.html',1,'entt']]] + ['raw_5ft',['raw_t',['../structentt_1_1raw__t.html',1,'entt']]], + ['rawview',['RawView',['../classentt_1_1RawView.html',1,'entt']]], + ['registry',['Registry',['../classentt_1_1Registry.html',1,'entt']]], + ['resourcecache',['ResourceCache',['../classentt_1_1ResourceCache.html',1,'entt']]], + ['resourcehandle',['ResourceHandle',['../classentt_1_1ResourceHandle.html',1,'entt']]], + ['resourceloader',['ResourceLoader',['../classentt_1_1ResourceLoader.html',1,'entt']]], + ['runtimeview',['RuntimeView',['../classentt_1_1RuntimeView.html',1,'entt']]] ]; diff --git a/search/classes_c.js b/search/classes_c.js index 467e6c4c1..260c5e21d 100644 --- a/search/classes_c.js +++ b/search/classes_c.js @@ -1,4 +1,16 @@ var searchData= [ - ['tag_5ft',['tag_t',['../structentt_1_1tag__t.html',1,'entt']]] + ['scheduler',['Scheduler',['../classentt_1_1Scheduler.html',1,'entt']]], + ['servicelocator',['ServiceLocator',['../structentt_1_1ServiceLocator.html',1,'entt']]], + ['sigh',['SigH',['../classentt_1_1SigH.html',1,'entt']]], + ['sigh_3c_20ret_28args_2e_2e_2e_29_2c_20collector_20_3e',['SigH< Ret(Args...), Collector >',['../classentt_1_1SigH_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4.html',1,'entt']]], + ['sigh_3c_20void_28const_20event_20_26_29_3e',['SigH< void(const Event &)>',['../classentt_1_1SigH.html',1,'entt']]], + ['sink',['Sink',['../classentt_1_1Sink.html',1,'entt']]], + ['sink_3c_20ret_28args_2e_2e_2e_29_3e',['Sink< Ret(Args...)>',['../classentt_1_1Sink_3_01Ret_07Args_8_8_8_08_4.html',1,'entt']]], + ['snapshot',['Snapshot',['../classentt_1_1Snapshot.html',1,'entt']]], + ['snapshotloader',['SnapshotLoader',['../classentt_1_1SnapshotLoader.html',1,'entt']]], + ['sparseset',['SparseSet',['../classentt_1_1SparseSet.html',1,'entt']]], + ['sparseset_3c_20entity_20_3e',['SparseSet< Entity >',['../classentt_1_1SparseSet_3_01Entity_01_4.html',1,'entt']]], + ['sparseset_3c_20entity_2c_20type_20_3e',['SparseSet< Entity, Type >',['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html',1,'entt']]], + ['stdsort',['StdSort',['../structentt_1_1StdSort.html',1,'entt']]] ]; diff --git a/search/classes_d.js b/search/classes_d.js index adad9ed1c..467e6c4c1 100644 --- a/search/classes_d.js +++ b/search/classes_d.js @@ -1,5 +1,4 @@ var searchData= [ - ['view',['View',['../classentt_1_1View.html',1,'entt']]], - ['view_3c_20entity_2c_20component_20_3e',['View< Entity, Component >',['../classentt_1_1View_3_01Entity_00_01Component_01_4.html',1,'entt']]] + ['tag_5ft',['tag_t',['../structentt_1_1tag__t.html',1,'entt']]] ]; diff --git a/search/classes_e.html b/search/classes_e.html new file mode 100644 index 000000000..9a9f48c36 --- /dev/null +++ b/search/classes_e.html @@ -0,0 +1,26 @@ + + + + + + + + + +
    +
    Loading...
    +
    + +
    Searching...
    +
    No Matches
    + +
    + + diff --git a/search/classes_e.js b/search/classes_e.js new file mode 100644 index 000000000..adad9ed1c --- /dev/null +++ b/search/classes_e.js @@ -0,0 +1,5 @@ +var searchData= +[ + ['view',['View',['../classentt_1_1View.html',1,'entt']]], + ['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/functions_0.js b/search/functions_0.js index 61c1bf735..27335ee65 100644 --- a/search/functions_0.js +++ b/search/functions_0.js @@ -3,7 +3,7 @@ var searchData= ['abort',['abort',['../classentt_1_1Process.html#ae7a9c2acd493969267ce4a6d2e2884b8',1,'entt::Process::abort()'],['../classentt_1_1Scheduler.html#af2494e025703d03a87117d6e897c87db',1,'entt::Scheduler::abort()']]], ['accommodate',['accommodate',['../classentt_1_1Prototype.html#adaec9cc16436af85ef938fc9686cd02d',1,'entt::Prototype::accommodate(registry_type &other, const entity_type dst) const'],['../classentt_1_1Prototype.html#a37299298c61bb06a75b697296e328477',1,'entt::Prototype::accommodate(const entity_type dst) const'],['../classentt_1_1Registry.html#a6333a56f3a5a58882963a11bbbcf2ac2',1,'entt::Registry::accommodate()']]], ['actor',['Actor',['../structentt_1_1Actor.html#a000a099327600af5eaf86990fe886260',1,'entt::Actor::Actor(Registry< Entity > &reg)'],['../structentt_1_1Actor.html#a02fb1433a35bb6df68a79a8bdd80036c',1,'entt::Actor::Actor(const Actor &)=default'],['../structentt_1_1Actor.html#a851508562e73c601be2965929b31c218',1,'entt::Actor::Actor(Actor &&)=default']]], - ['alive',['alive',['../classentt_1_1Process.html#ad18ce3558d2325d622fb2b8ab51c49d5',1,'entt::Process']]], + ['alive',['alive',['../classentt_1_1Registry.html#a4288576a8d41018b63838d4afdd01717',1,'entt::Registry::alive()'],['../classentt_1_1Process.html#ad18ce3558d2325d622fb2b8ab51c49d5',1,'entt::Process::alive()']]], ['assign',['assign',['../structentt_1_1Actor.html#a0a161248d739e780833e534f7d1cf638',1,'entt::Actor::assign(tag_t, Args &&... args)'],['../structentt_1_1Actor.html#a7631fdb2de787c10b016a71905906147',1,'entt::Actor::assign(Args &&... args)'],['../classentt_1_1Prototype.html#a0a52cda550a678ee14272cff7b2fcf35',1,'entt::Prototype::assign(registry_type &other, const entity_type dst) const'],['../classentt_1_1Prototype.html#ab7bf733f40f1071d73d4f3245526c038',1,'entt::Prototype::assign(const entity_type dst) const'],['../classentt_1_1Registry.html#a93b5717af287a2b97e0ef9695c51ed58',1,'entt::Registry::assign(tag_t, const entity_type entity, Args &&... args)'],['../classentt_1_1Registry.html#a01f87450271067dda6c87f0c7c9b80dd',1,'entt::Registry::assign(const entity_type entity, Args &&... args)']]], ['attach',['attach',['../classentt_1_1Scheduler.html#a1a836000f65e8e275119c0f77ec46674',1,'entt::Scheduler::attach(Args &&... args)'],['../classentt_1_1Scheduler.html#a5915b9783b278a6006d4857feefc0e3b',1,'entt::Scheduler::attach(Func &&func)']]], ['attachee',['attachee',['../classentt_1_1Registry.html#af157dcabe4fe027e2f9cd45f4958f3b9',1,'entt::Registry']]] diff --git a/search/functions_4.js b/search/functions_4.js index 7bbcc3ee0..75649df41 100644 --- a/search/functions_4.js +++ b/search/functions_4.js @@ -6,7 +6,7 @@ var searchData= ['end',['end',['../classentt_1_1SparseSet_3_01Entity_01_4.html#a956957bcafba7391d1008110596d5714',1,'entt::SparseSet< Entity >::end() const ENTT_NOEXCEPT'],['../classentt_1_1SparseSet_3_01Entity_01_4.html#a14720d48f6d553a06813379ee6d7092f',1,'entt::SparseSet< Entity >::end() ENTT_NOEXCEPT'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#aa04fe0d91fc40c8982cdfada8664e9b1',1,'entt::SparseSet< Entity, Type >::end() const ENTT_NOEXCEPT'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#a43b4c3d129ab2b6559154f8db037bfd5',1,'entt::SparseSet< Entity, Type >::end() ENTT_NOEXCEPT'],['../classentt_1_1PersistentView.html#a0e614f77f05085e951e761d8ca967a84',1,'entt::PersistentView::end() const ENTT_NOEXCEPT'],['../classentt_1_1PersistentView.html#a470ef6edb944f127e26f7e3398cbded1',1,'entt::PersistentView::end() ENTT_NOEXCEPT'],['../classentt_1_1View.html#af0cbc67f83e47cb4cbb3a1a26d7cd263',1,'entt::View::end() const ENTT_NOEXCEPT'],['../classentt_1_1View.html#a34bca7c2c996fe26e150c0a7a2dbb69d',1,'entt::View::end() ENTT_NOEXCEPT'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#af0cbc67f83e47cb4cbb3a1a26d7cd263',1,'entt::View< Entity, Component >::end() const ENTT_NOEXCEPT'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a34bca7c2c996fe26e150c0a7a2dbb69d',1,'entt::View< Entity, Component >::end() ENTT_NOEXCEPT'],['../classentt_1_1RawView.html#ad7ad0559b9b4a440813e1752b0814bb4',1,'entt::RawView::end() const ENTT_NOEXCEPT'],['../classentt_1_1RawView.html#a8ebfe24e5a5e428b429f470755d0a1f7',1,'entt::RawView::end() ENTT_NOEXCEPT'],['../classentt_1_1RuntimeView.html#af8040215c3db60033388328ddff9a5d8',1,'entt::RuntimeView::end() const ENTT_NOEXCEPT'],['../classentt_1_1RuntimeView.html#afc2af975c32c247e0c333d4e49c0208c',1,'entt::RuntimeView::end() ENTT_NOEXCEPT']]], ['enqueue',['enqueue',['../classentt_1_1Dispatcher.html#a431743aa289ce022f7ee87cd7fb3eedf',1,'entt::Dispatcher']]], ['entities',['entities',['../classentt_1_1Snapshot.html#aa77d63e06c40969adca662fca3a2ca08',1,'entt::Snapshot::entities()'],['../classentt_1_1SnapshotLoader.html#a7bff030b50995a78f79217eecfb90535',1,'entt::SnapshotLoader::entities()'],['../classentt_1_1ContinuousLoader.html#a26eadd32f719c24de2305347a5066197',1,'entt::ContinuousLoader::entities()']]], - ['entity',['entity',['../structentt_1_1Actor.html#afb70b6f30071680efab23715a7e61a29',1,'entt::Actor']]], + ['entity',['entity',['../structentt_1_1Actor.html#afb70b6f30071680efab23715a7e61a29',1,'entt::Actor::entity()'],['../classentt_1_1Registry.html#a43374c03910bf8b7337992d1bcc88e30',1,'entt::Registry::entity()']]], ['erase',['erase',['../classentt_1_1Emitter.html#ab15f07d10744ce8aa74964fa5623375c',1,'entt::Emitter']]], ['extent',['extent',['../classentt_1_1SparseSet_3_01Entity_01_4.html#ab314d3642b6a5b90bbcb170ba83b7978',1,'entt::SparseSet< Entity >']]] ]; diff --git a/search/functions_a.js b/search/functions_a.js index 150b65aab..62eba0478 100644 --- a/search/functions_a.js +++ b/search/functions_a.js @@ -8,7 +8,7 @@ var searchData= ['operator_20hash_5ftype',['operator hash_type',['../classentt_1_1HashedString.html#a47843deb0d550b5a6e1129a9b913d85f',1,'entt::HashedString']]], ['operator_20type',['operator Type',['../structentt_1_1Monostate.html#ae16dec68153e1cf761d8c2379c4e3e8c',1,'entt::Monostate']]], ['operator_21_3d',['operator!=',['../namespaceentt.html#a8a638f5585d404bbdcfd8efdfeb39203',1,'entt::operator!=(const HashedString &lhs, const HashedString &rhs) ENTT_NOEXCEPT'],['../namespaceentt.html#aef8743ab32f59bd2905b9fa2938318b6',1,'entt::operator!=(const Delegate< Ret(Args...)> &lhs, const Delegate< Ret(Args...)> &rhs) ENTT_NOEXCEPT'],['../namespaceentt.html#a13ce28be581233dd1e9179a126dd979d',1,'entt::operator!=(const SigH< Ret(Args...)> &lhs, const SigH< Ret(Args...)> &rhs) ENTT_NOEXCEPT']]], - ['operator_28_29',['operator()',['../structentt_1_1StdSort.html#a3363910b5a138b20f96d8a967a7bbd8b',1,'entt::StdSort::operator()()'],['../structentt_1_1InsertionSort.html#a53f94456eb885d9a02344b33b39f8815',1,'entt::InsertionSort::operator()()'],['../classentt_1_1Prototype.html#ac7cb69aad2015e94f3a0a9ad42b82f1b',1,'entt::Prototype::operator()(registry_type &other, const entity_type dst) const ENTT_NOEXCEPT'],['../classentt_1_1Prototype.html#a6b0560c31432fb6591a772ce9a322728',1,'entt::Prototype::operator()(const entity_type dst) const ENTT_NOEXCEPT'],['../classentt_1_1Prototype.html#a7c401ecc89b0c88ab15ed2dd7686b54e',1,'entt::Prototype::operator()(registry_type &other) const ENTT_NOEXCEPT'],['../classentt_1_1Prototype.html#ad39dd5c5449cc647a1402543ebe411fe',1,'entt::Prototype::operator()() const ENTT_NOEXCEPT'],['../classentt_1_1Delegate_3_01Ret_07Args_8_8_8_08_4.html#a3259f295bc4ea1da8307d1be65c83d6a',1,'entt::Delegate< Ret(Args...)>::operator()()']]], + ['operator_28_29',['operator()',['../structentt_1_1StdSort.html#a3363910b5a138b20f96d8a967a7bbd8b',1,'entt::StdSort::operator()()'],['../structentt_1_1InsertionSort.html#a53f94456eb885d9a02344b33b39f8815',1,'entt::InsertionSort::operator()()'],['../structentt_1_1OneShotBubbleSort.html#a9c8c582c4a83a9faaf1e328296daf971',1,'entt::OneShotBubbleSort::operator()()'],['../classentt_1_1Prototype.html#ac7cb69aad2015e94f3a0a9ad42b82f1b',1,'entt::Prototype::operator()(registry_type &other, const entity_type dst) const ENTT_NOEXCEPT'],['../classentt_1_1Prototype.html#a6b0560c31432fb6591a772ce9a322728',1,'entt::Prototype::operator()(const entity_type dst) const ENTT_NOEXCEPT'],['../classentt_1_1Prototype.html#a7c401ecc89b0c88ab15ed2dd7686b54e',1,'entt::Prototype::operator()(registry_type &other) const ENTT_NOEXCEPT'],['../classentt_1_1Prototype.html#ad39dd5c5449cc647a1402543ebe411fe',1,'entt::Prototype::operator()() const ENTT_NOEXCEPT'],['../classentt_1_1Delegate_3_01Ret_07Args_8_8_8_08_4.html#a3259f295bc4ea1da8307d1be65c83d6a',1,'entt::Delegate< Ret(Args...)>::operator()()']]], ['operator_2a',['operator*',['../classentt_1_1ResourceHandle.html#a737a5c2e623d30f372ba4876fe3d0fd3',1,'entt::ResourceHandle']]], ['operator_2d_3e',['operator->',['../classentt_1_1ResourceHandle.html#a55727b34cb2bcbff11a680bae2fd793e',1,'entt::ResourceHandle']]], ['operator_3d',['operator=',['../structentt_1_1Monostate.html#a9e94509f038e4a634ce776cdc23548cf',1,'entt::Monostate::operator=()'],['../structentt_1_1Actor.html#af65a5bd2973d27a9adb1a62b746111fe',1,'entt::Actor::operator=(const Actor &)=default'],['../structentt_1_1Actor.html#adbb2c4045a701b76d5fd514ec9221c02',1,'entt::Actor::operator=(Actor &&)=default'],['../classentt_1_1Prototype.html#a65529171240b1b7c348445c7ba4f319e',1,'entt::Prototype::operator=(const Prototype &)=delete'],['../classentt_1_1Prototype.html#a9faf0b8878925090431a9e6acaed06c5',1,'entt::Prototype::operator=(Prototype &&other)'],['../classentt_1_1Registry.html#a6ff250745f1774984a9524d63855f26d',1,'entt::Registry::operator=(const Registry &)=delete'],['../classentt_1_1Registry.html#ade7432a219317a6912553feb2971188b',1,'entt::Registry::operator=(Registry &&)=default'],['../classentt_1_1Snapshot.html#a3375f7d701d086fc21e04e6077c954fc',1,'entt::Snapshot::operator=(const Snapshot &)=delete'],['../classentt_1_1Snapshot.html#a627c0ea635facdd8b8246d1b97de11e3',1,'entt::Snapshot::operator=(Snapshot &&)=default'],['../classentt_1_1SnapshotLoader.html#ad1f8a300b9c5ccf0598cd90ab0e0062f',1,'entt::SnapshotLoader::operator=(const SnapshotLoader &)=delete'],['../classentt_1_1SnapshotLoader.html#a69ed990a8a614e5a1cb90960c216784b',1,'entt::SnapshotLoader::operator=(SnapshotLoader &&)=default'],['../classentt_1_1ContinuousLoader.html#add60e853e8b948f8f3c9f5c73207cb2a',1,'entt::ContinuousLoader::operator=(const ContinuousLoader &)=delete'],['../classentt_1_1ContinuousLoader.html#a3e0c1b78fbd9ba85857c066b5c89adb5',1,'entt::ContinuousLoader::operator=(ContinuousLoader &&)=default'],['../classentt_1_1SparseSet_3_01Entity_01_4.html#a34ffc79377cef381ef5af2e75d61cf4d',1,'entt::SparseSet< Entity >::operator=(const SparseSet &)=delete'],['../classentt_1_1SparseSet_3_01Entity_01_4.html#a24ddfc9e45d7b70639124fe7c2800384',1,'entt::SparseSet< Entity >::operator=(SparseSet &&)=default'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#aa700bb907a18470dce144f84822c67ae',1,'entt::SparseSet< Entity, Type >::operator=(const SparseSet &)=delete'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#a52a81e838ae87413116ab9165ab9ba86',1,'entt::SparseSet< Entity, Type >::operator=(SparseSet &&)=default'],['../classentt_1_1Scheduler.html#a66fa731504da02dfaa607e1c3f153120',1,'entt::Scheduler::operator=(const Scheduler &)=delete'],['../classentt_1_1Scheduler.html#a929ec57792af25f0552f25ad445c7731',1,'entt::Scheduler::operator=(Scheduler &&)=default'],['../classentt_1_1ResourceCache.html#abe56c919c4a2606f87d7d8351261a0e8',1,'entt::ResourceCache::operator=(const ResourceCache &) ENTT_NOEXCEPT=delete'],['../classentt_1_1ResourceCache.html#a18ddc0a0bae71d8124d775d9ddebc550',1,'entt::ResourceCache::operator=(ResourceCache &&) ENTT_NOEXCEPT=default'],['../classentt_1_1ResourceHandle.html#a017670d5037cf65ea0b81b5c094004ac',1,'entt::ResourceHandle::operator=(const ResourceHandle &) ENTT_NOEXCEPT=default'],['../classentt_1_1ResourceHandle.html#a5c6a854be6eca84bd76d8e05f05f657b',1,'entt::ResourceHandle::operator=(ResourceHandle &&) ENTT_NOEXCEPT=default'],['../structentt_1_1Emitter_1_1Connection.html#aa1dba0de2aaa8426f4b42e6c52aa80ea',1,'entt::Emitter::Connection::operator=(const Connection &)=default'],['../structentt_1_1Emitter_1_1Connection.html#a26bc490e1d62f8e7863052f28cc5672c',1,'entt::Emitter::Connection::operator=(Connection &&)=default'],['../classentt_1_1Emitter.html#ace3403fe310953f720dbddff016fe715',1,'entt::Emitter::operator=(const Emitter &)=delete'],['../classentt_1_1Emitter.html#a8d06e737c14bf6be779135529424ca64',1,'entt::Emitter::operator=(Emitter &&)=default']]], diff --git a/search/functions_d.js b/search/functions_d.js index 734821b54..c607cc275 100644 --- a/search/functions_d.js +++ b/search/functions_d.js @@ -6,7 +6,7 @@ var searchData= ['shrink',['shrink',['../classentt_1_1ContinuousLoader.html#a959dc40d6285e8175e95c3679c6698d6',1,'entt::ContinuousLoader']]], ['sink',['sink',['../classentt_1_1Dispatcher.html#a091aa6ab261f34eee355c2b7180f709b',1,'entt::Dispatcher::sink()'],['../classentt_1_1SigH_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4.html#a20b7fde8e36650f0e4cd31bd54ac1fc7',1,'entt::SigH< Ret(Args...), Collector >::sink()']]], ['size',['size',['../classentt_1_1Registry.html#a88d7621801898d0a551cfd98b29a7cd0',1,'entt::Registry::size() const ENTT_NOEXCEPT'],['../classentt_1_1Registry.html#a1be83159fed73573014e6e2919ecabf3',1,'entt::Registry::size() const ENTT_NOEXCEPT'],['../classentt_1_1SparseSet_3_01Entity_01_4.html#a6dc502e9af33ac00af110e5eb8414bc1',1,'entt::SparseSet< Entity >::size()'],['../classentt_1_1PersistentView.html#ad6b816b2acc684733d79ac680005f8da',1,'entt::PersistentView::size()'],['../classentt_1_1View.html#a2244b847c1e148f901ea3b83ec2d6703',1,'entt::View::size()'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a2244b847c1e148f901ea3b83ec2d6703',1,'entt::View< Entity, Component >::size()'],['../classentt_1_1RawView.html#a56cd44cbd4cf15fcaacdcfd9e2b0f710',1,'entt::RawView::size()'],['../classentt_1_1RuntimeView.html#a1532f09ceaac574965c9190554c74f55',1,'entt::RuntimeView::size()'],['../classentt_1_1Scheduler.html#a59aea2fac213df785278870474a3abb5',1,'entt::Scheduler::size()'],['../classentt_1_1ResourceCache.html#a1fb9767a303a85f09497751a7d70623f',1,'entt::ResourceCache::size()'],['../classentt_1_1SigH_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4.html#a5f0c4724d805b4ecdd30045a13ed93ec',1,'entt::SigH< Ret(Args...), Collector >::size()']]], - ['snapshot',['snapshot',['../classentt_1_1Registry.html#a00a0b4949a4cc0cb87e88cc6d1171a9d',1,'entt::Registry::snapshot()'],['../classentt_1_1Snapshot.html#a80f9a56ce8667a5d9947cdaac686fd8d',1,'entt::Snapshot::Snapshot(const Snapshot &)=delete'],['../classentt_1_1Snapshot.html#a3682df1db11f032bfa9ead93c0cec479',1,'entt::Snapshot::Snapshot(Snapshot &&)=default']]], + ['snapshot',['Snapshot',['../classentt_1_1Snapshot.html#a80f9a56ce8667a5d9947cdaac686fd8d',1,'entt::Snapshot::Snapshot(const Snapshot &)=delete'],['../classentt_1_1Snapshot.html#a3682df1db11f032bfa9ead93c0cec479',1,'entt::Snapshot::Snapshot(Snapshot &&)=default'],['../classentt_1_1Registry.html#a00a0b4949a4cc0cb87e88cc6d1171a9d',1,'entt::Registry::snapshot()']]], ['snapshotloader',['SnapshotLoader',['../classentt_1_1SnapshotLoader.html#a7cc32b25447bf6d13ac36a814e446f4c',1,'entt::SnapshotLoader::SnapshotLoader(const SnapshotLoader &)=delete'],['../classentt_1_1SnapshotLoader.html#ad20cadc8bb3699629cb3ae54bf07b39a',1,'entt::SnapshotLoader::SnapshotLoader(SnapshotLoader &&)=default']]], ['sort',['sort',['../classentt_1_1Registry.html#acb72e05f3128b6604b438707eabdfa4a',1,'entt::Registry::sort(Compare compare, Sort sort=Sort{}, Args &&... args)'],['../classentt_1_1Registry.html#aa3abb830a7ba342266b62ff1a2965754',1,'entt::Registry::sort()'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#a8d2f225354c91f10b427e02dc211d24f',1,'entt::SparseSet< Entity, Type >::sort()'],['../classentt_1_1PersistentView.html#accde3d4b4a904e79c832f6b05f324b05',1,'entt::PersistentView::sort()']]], ['sparseset',['SparseSet',['../classentt_1_1SparseSet_3_01Entity_01_4.html#ac21f0c7137814008016648e166061426',1,'entt::SparseSet< Entity >::SparseSet() ENTT_NOEXCEPT=default'],['../classentt_1_1SparseSet_3_01Entity_01_4.html#aa4ad5318f2be78e8e4336bdf4b012905',1,'entt::SparseSet< Entity >::SparseSet(const SparseSet &)=delete'],['../classentt_1_1SparseSet_3_01Entity_01_4.html#acdfceb557303dee515fe906a13ac759e',1,'entt::SparseSet< Entity >::SparseSet(SparseSet &&)=default'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#a80cd93fb003c8edd8583fb679464a36e',1,'entt::SparseSet< Entity, Type >::SparseSet() ENTT_NOEXCEPT=default'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#a52d68a9763bed211729df965cb7ab859',1,'entt::SparseSet< Entity, Type >::SparseSet(const SparseSet &)=delete'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#a11cbb29701b5a1b1a6e4b77d19d29cec',1,'entt::SparseSet< Entity, Type >::SparseSet(SparseSet &&)=default']]], diff --git a/search/pages_0.js b/search/pages_0.js index be5016f4d..13b21952d 100644 --- a/search/pages_0.js +++ b/search/pages_0.js @@ -1,4 +1,4 @@ var searchData= [ - ['entt_20framework',['EnTT Framework',['../index.html',1,'']]] + ['contributing',['Contributing',['../autotoc_md0.html',1,'']]] ]; diff --git a/search/searchdata.js b/search/searchdata.js index 3aeb28f67..a3463b0dd 100644 --- a/search/searchdata.js +++ b/search/searchdata.js @@ -1,13 +1,13 @@ var indexSectionsWithContent = { 0: "abcdefghilmnoprstuv~", - 1: "abcdefhimprstv", + 1: "abcdefhimoprstv", 2: "e", 3: "abcdefghlmoprstuv~", 4: "env", 5: "cdefhilorstv", 6: "ers", - 7: "e" + 7: "c" }; var indexSectionNames = diff --git a/search/typedefs_6.js b/search/typedefs_6.js index d8cfe6694..1f5add80c 100644 --- a/search/typedefs_6.js +++ b/search/typedefs_6.js @@ -1,4 +1,5 @@ var searchData= [ + ['label',['label',['../namespaceentt.html#a8512c4b75207424bd97724a17cd1eeb0',1,'entt']]], ['listener',['Listener',['../classentt_1_1Emitter.html#a1a5bb5d6a7626aec285cc73bfc1e80ef',1,'entt::Emitter']]] ]; diff --git a/sigh_8hpp_source.html b/sigh_8hpp_source.html index f9154ea92..0dd5b7a07 100644 --- a/sigh_8hpp_source.html +++ b/sigh_8hpp_source.html @@ -5,7 +5,7 @@ -entt: src/entt/signal/sigh.hpp Source File +EnTT: src/entt/signal/sigh.hpp Source File @@ -21,8 +21,8 @@ -
    entt -  2.7.1 +
    EnTT +  2.7.2
    diff --git a/snapshot_8hpp_source.html b/snapshot_8hpp_source.html index 1afc2f615..8156bbdc6 100644 --- a/snapshot_8hpp_source.html +++ b/snapshot_8hpp_source.html @@ -5,7 +5,7 @@ -entt: src/entt/entity/snapshot.hpp Source File +EnTT: src/entt/entity/snapshot.hpp Source File @@ -21,8 +21,8 @@ -
    entt -  2.7.1 +
    EnTT +  2.7.2
    @@ -67,7 +67,7 @@ $(function() {
    snapshot.hpp
    -
    1 #ifndef ENTT_ENTITY_SNAPSHOT_HPP
    2 #define ENTT_ENTITY_SNAPSHOT_HPP
    3 
    4 
    5 #include <array>
    6 #include <cstddef>
    7 #include <utility>
    8 #include <cassert>
    9 #include <iterator>
    10 #include <type_traits>
    11 #include <unordered_map>
    12 #include "../config/config.h"
    13 #include "entt_traits.hpp"
    14 #include "utility.hpp"
    15 
    16 
    17 namespace entt {
    18 
    19 
    23 template<typename>
    24 class Registry;
    25 
    26 
    37 template<typename Entity>
    38 class Snapshot final {
    40  friend class Registry<Entity>;
    41 
    42  using follow_fn_type = Entity(const Registry<Entity> &, const Entity);
    43 
    44  Snapshot(const Registry<Entity> &registry, Entity seed, follow_fn_type *follow) ENTT_NOEXCEPT
    45  : registry{registry},
    46  seed{seed},
    47  follow{follow}
    48  {}
    49 
    50  template<typename Component, typename Archive, typename It>
    51  void get(Archive &archive, std::size_t sz, It first, It last) const {
    52  archive(static_cast<Entity>(sz));
    53 
    54  while(first != last) {
    55  const auto entity = *(first++);
    56 
    57  if(registry.template has<Component>(entity)) {
    58  archive(entity, registry.template get<Component>(entity));
    59  }
    60  }
    61  }
    62 
    63  template<typename... Component, typename Archive, typename It, std::size_t... Indexes>
    64  void component(Archive &archive, It first, It last, std::index_sequence<Indexes...>) const {
    65  std::array<std::size_t, sizeof...(Indexes)> size{};
    66  auto begin = first;
    67 
    68  while(begin != last) {
    69  const auto entity = *(begin++);
    70  using accumulator_type = std::size_t[];
    71  accumulator_type accumulator = { (registry.template has<Component>(entity) ? ++size[Indexes] : size[Indexes])... };
    72  (void)accumulator;
    73  }
    74 
    75  using accumulator_type = int[];
    76  accumulator_type accumulator = { (get<Component>(archive, size[Indexes], first, last), 0)... };
    77  (void)accumulator;
    78  }
    79 
    80 public:
    82  Snapshot(const Snapshot &) = delete;
    84  Snapshot(Snapshot &&) = default;
    85 
    87  Snapshot & operator=(const Snapshot &) = delete;
    89  Snapshot & operator=(Snapshot &&) = default;
    90 
    101  template<typename Archive>
    102  const Snapshot & entities(Archive &archive) const {
    103  archive(static_cast<Entity>(registry.size()));
    104  registry.each([&archive](const auto entity) { archive(entity); });
    105  return *this;
    106  }
    107 
    118  template<typename Archive>
    119  const Snapshot & destroyed(Archive &archive) const {
    120  auto size = registry.capacity() - registry.size();
    121  archive(static_cast<Entity>(size));
    122  auto curr = seed;
    123 
    124  for(; size; --size) {
    125  archive(curr);
    126  curr = follow(registry, curr);
    127  }
    128 
    129  return *this;
    130  }
    131 
    143  template<typename Component, typename Archive>
    144  const Snapshot & component(Archive &archive) const {
    145  const auto sz = registry.template size<Component>();
    146  const auto *entities = registry.template data<Component>();
    147 
    148  archive(static_cast<Entity>(sz));
    149 
    150  for(std::remove_const_t<decltype(sz)> i{}; i < sz; ++i) {
    151  const auto entity = entities[i];
    152  archive(entity, registry.template get<Component>(entity));
    153  };
    154 
    155  return *this;
    156  }
    157 
    169  template<typename... Component, typename Archive>
    170  std::enable_if_t<(sizeof...(Component) > 1), const Snapshot &>
    171  component(Archive &archive) const {
    172  using accumulator_type = int[];
    173  accumulator_type accumulator = { 0, (component<Component>(archive), 0)... };
    174  (void)accumulator;
    175  return *this;
    176  }
    177 
    192  template<typename... Component, typename Archive, typename It>
    193  const Snapshot & component(Archive &archive, It first, It last) const {
    194  component<Component...>(archive, first, last, std::make_index_sequence<sizeof...(Component)>{});
    195  return *this;
    196  }
    197 
    209  template<typename Tag, typename Archive>
    210  const Snapshot & tag(Archive &archive) const {
    211  const bool has = registry.template has<Tag>();
    212 
    213  // numerical length is forced for tags to facilitate loading
    214  archive(has ? Entity(1): Entity{});
    215 
    216  if(has) {
    217  archive(registry.template attachee<Tag>(), registry.template get<Tag>());
    218  }
    219 
    220  return *this;
    221  }
    222 
    234  template<typename... Tag, typename Archive>
    235  std::enable_if_t<(sizeof...(Tag) > 1), const Snapshot &>
    236  tag(Archive &archive) const {
    237  using accumulator_type = int[];
    238  accumulator_type accumulator = { 0, (tag<Tag>(archive), 0)... };
    239  (void)accumulator;
    240  return *this;
    241  }
    242 
    243 private:
    244  const Registry<Entity> &registry;
    245  const Entity seed;
    246  follow_fn_type *follow;
    247 };
    248 
    249 
    260 template<typename Entity>
    261 class SnapshotLoader final {
    263  friend class Registry<Entity>;
    264 
    265  using assure_fn_type = void(Registry<Entity> &, const Entity, const bool);
    266 
    267  SnapshotLoader(Registry<Entity> &registry, assure_fn_type *assure_fn) ENTT_NOEXCEPT
    268  : registry{registry},
    269  assure_fn{assure_fn}
    270  {
    271  // restore a snapshot as a whole requires a clean registry
    272  assert(!registry.capacity());
    273  }
    274 
    275  template<typename Archive>
    276  void assure(Archive &archive, bool destroyed) const {
    277  Entity length{};
    278  archive(length);
    279 
    280  while(length--) {
    281  Entity entity{};
    282  archive(entity);
    283  assure_fn(registry, entity, destroyed);
    284  }
    285  }
    286 
    287  template<typename Type, typename Archive, typename... Args>
    288  void assign(Archive &archive, Args... args) const {
    289  Entity length{};
    290  archive(length);
    291 
    292  while(length--) {
    293  Entity entity{};
    294  Type instance{};
    295  archive(entity, instance);
    296  static constexpr auto destroyed = false;
    297  assure_fn(registry, entity, destroyed);
    298  registry.template assign<Type>(args..., entity, static_cast<const Type &>(instance));
    299  }
    300  }
    301 
    302 public:
    304  SnapshotLoader(const SnapshotLoader &) = delete;
    306  SnapshotLoader(SnapshotLoader &&) = default;
    307 
    309  SnapshotLoader & operator=(const SnapshotLoader &) = delete;
    311  SnapshotLoader & operator=(SnapshotLoader &&) = default;
    312 
    323  template<typename Archive>
    324  const SnapshotLoader & entities(Archive &archive) const {
    325  static constexpr auto destroyed = false;
    326  assure(archive, destroyed);
    327  return *this;
    328  }
    329 
    340  template<typename Archive>
    341  const SnapshotLoader & destroyed(Archive &archive) const {
    342  static constexpr auto destroyed = true;
    343  assure(archive, destroyed);
    344  return *this;
    345  }
    346 
    360  template<typename... Component, typename Archive>
    361  const SnapshotLoader & component(Archive &archive) const {
    362  using accumulator_type = int[];
    363  accumulator_type accumulator = { 0, (assign<Component>(archive), 0)... };
    364  (void)accumulator;
    365  return *this;
    366  }
    367 
    381  template<typename... Tag, typename Archive>
    382  const SnapshotLoader & tag(Archive &archive) const {
    383  using accumulator_type = int[];
    384  accumulator_type accumulator = { 0, (assign<Tag>(archive, tag_t{}), 0)... };
    385  (void)accumulator;
    386  return *this;
    387  }
    388 
    399  const SnapshotLoader & orphans() const {
    400  registry.orphans([this](const auto entity) {
    401  registry.destroy(entity);
    402  });
    403 
    404  return *this;
    405  }
    406 
    407 private:
    408  Registry<Entity> &registry;
    409  assure_fn_type *assure_fn;
    410 };
    411 
    412 
    429 template<typename Entity>
    430 class ContinuousLoader final {
    431  using traits_type = entt_traits<Entity>;
    432 
    433  void destroy(Entity entity) {
    434  const auto it = remloc.find(entity);
    435 
    436  if(it == remloc.cend()) {
    437  const auto local = registry.create();
    438  remloc.emplace(entity, std::make_pair(local, true));
    439  registry.destroy(local);
    440  }
    441  }
    442 
    443  void restore(Entity entity) {
    444  const auto it = remloc.find(entity);
    445 
    446  if(it == remloc.cend()) {
    447  const auto local = registry.create();
    448  remloc.emplace(entity, std::make_pair(local, true));
    449  } else {
    450  remloc[entity].first =
    451  registry.valid(remloc[entity].first)
    452  ? remloc[entity].first
    453  : registry.create();
    454 
    455  // set the dirty flag
    456  remloc[entity].second = true;
    457  }
    458  }
    459 
    460  template<typename Type, typename Member>
    461  std::enable_if_t<std::is_same<Member, Entity>::value>
    462  update(Type &instance, Member Type:: *member) {
    463  instance.*member = map(instance.*member);
    464  }
    465 
    466  template<typename Type, typename Member>
    467  std::enable_if_t<std::is_same<typename std::iterator_traits<typename Member::iterator>::value_type, Entity>::value>
    468  update(Type &instance, Member Type:: *member) {
    469  for(auto &entity: instance.*member) {
    470  entity = map(entity);
    471  }
    472  }
    473 
    474  template<typename Other, typename Type, typename Member>
    475  std::enable_if_t<!std::is_same<Other, Type>::value>
    476  update(Other &, Member Type:: *) {}
    477 
    478  template<typename Archive>
    479  void assure(Archive &archive, void(ContinuousLoader:: *member)(Entity)) {
    480  Entity length{};
    481  archive(length);
    482 
    483  while(length--) {
    484  Entity entity{};
    485  archive(entity);
    486  (this->*member)(entity);
    487  }
    488  }
    489 
    490  template<typename Component>
    491  void reset() {
    492  for(auto &&ref: remloc) {
    493  const auto local = ref.second.first;
    494 
    495  if(registry.valid(local)) {
    496  registry.template reset<Component>(local);
    497  }
    498  }
    499  }
    500 
    501  template<typename Other, typename Archive, typename Func, typename... Type, typename... Member>
    502  void assign(Archive &archive, Func func, Member Type:: *... member) {
    503  Entity length{};
    504  archive(length);
    505 
    506  while(length--) {
    507  Entity entity{};
    508  Other instance{};
    509 
    510  archive(entity, instance);
    511  restore(entity);
    512 
    513  using accumulator_type = int[];
    514  accumulator_type accumulator = { 0, (update(instance, member), 0)... };
    515  (void)accumulator;
    516 
    517  func(map(entity), instance);
    518  }
    519  }
    520 
    521 public:
    523  using entity_type = Entity;
    524 
    529  ContinuousLoader(Registry<entity_type> &registry) ENTT_NOEXCEPT
    530  : registry{registry}
    531  {}
    532 
    534  ContinuousLoader(const ContinuousLoader &) = delete;
    536  ContinuousLoader(ContinuousLoader &&) = default;
    537 
    539  ContinuousLoader & operator=(const ContinuousLoader &) = delete;
    541  ContinuousLoader & operator=(ContinuousLoader &&) = default;
    542 
    553  template<typename Archive>
    554  ContinuousLoader & entities(Archive &archive) {
    555  assure(archive, &ContinuousLoader::restore);
    556  return *this;
    557  }
    558 
    569  template<typename Archive>
    570  ContinuousLoader & destroyed(Archive &archive) {
    571  assure(archive, &ContinuousLoader::destroy);
    572  return *this;
    573  }
    574 
    594  template<typename... Component, typename Archive, typename... Type, typename... Member>
    595  ContinuousLoader & component(Archive &archive, Member Type:: *... member) {
    596  auto apply = [this](const auto entity, const auto &component) {
    597  registry.template accommodate<std::decay_t<decltype(component)>>(entity, component);
    598  };
    599 
    600  using accumulator_type = int[];
    601  accumulator_type accumulator = { 0, (reset<Component>(), assign<Component>(archive, apply, member...), 0)... };
    602  (void)accumulator;
    603  return *this;
    604  }
    605 
    625  template<typename... Tag, typename Archive, typename... Type, typename... Member>
    626  ContinuousLoader & tag(Archive &archive, Member Type:: *... member) {
    627  auto apply = [this](const auto entity, const auto &tag) {
    628  registry.template assign<std::decay_t<decltype(tag)>>(tag_t{}, entity, tag);
    629  };
    630 
    631  using accumulator_type = int[];
    632  accumulator_type accumulator = { 0, (registry.template remove<Tag>(), assign<Tag>(archive, apply, member...), 0)... };
    633  (void)accumulator;
    634  return *this;
    635  }
    636 
    645  ContinuousLoader & shrink() {
    646  auto it = remloc.begin();
    647 
    648  while(it != remloc.cend()) {
    649  const auto local = it->second.first;
    650  bool &dirty = it->second.second;
    651 
    652  if(dirty) {
    653  dirty = false;
    654  ++it;
    655  } else {
    656  if(registry.valid(local)) {
    657  registry.destroy(local);
    658  }
    659 
    660  it = remloc.erase(it);
    661  }
    662  }
    663 
    664  return *this;
    665  }
    666 
    677  ContinuousLoader & orphans() {
    678  registry.orphans([this](const auto entity) {
    679  registry.destroy(entity);
    680  });
    681 
    682  return *this;
    683  }
    684 
    690  bool has(entity_type entity) const ENTT_NOEXCEPT {
    691  return (remloc.find(entity) != remloc.cend());
    692  }
    693 
    706  entity_type map(entity_type entity) const ENTT_NOEXCEPT {
    707  assert(has(entity));
    708  return remloc.find(entity)->second.first;
    709  }
    710 
    711 private:
    712  std::unordered_map<Entity, std::pair<Entity, bool>> remloc;
    713  Registry<Entity> &registry;
    714 };
    715 
    716 
    717 }
    718 
    719 
    720 #endif // ENTT_ENTITY_SNAPSHOT_HPP
    entt::ContinuousLoader::tag
    ContinuousLoader & tag(Archive &archive, Member Type::*... member)
    Restores tags and assigns them to the right entities.
    Definition: snapshot.hpp:626
    +
    1 #ifndef ENTT_ENTITY_SNAPSHOT_HPP
    2 #define ENTT_ENTITY_SNAPSHOT_HPP
    3 
    4 
    5 #include <array>
    6 #include <cstddef>
    7 #include <utility>
    8 #include <cassert>
    9 #include <iterator>
    10 #include <type_traits>
    11 #include <unordered_map>
    12 #include "../config/config.h"
    13 #include "entt_traits.hpp"
    14 #include "utility.hpp"
    15 
    16 
    17 namespace entt {
    18 
    19 
    23 template<typename>
    24 class Registry;
    25 
    26 
    37 template<typename Entity>
    38 class Snapshot final {
    40  friend class Registry<Entity>;
    41 
    42  using follow_fn_type = Entity(const Registry<Entity> &, const Entity);
    43 
    44  Snapshot(const Registry<Entity> &registry, Entity seed, follow_fn_type *follow) ENTT_NOEXCEPT
    45  : registry{registry},
    46  seed{seed},
    47  follow{follow}
    48  {}
    49 
    50  template<typename Component, typename Archive, typename It>
    51  void get(Archive &archive, std::size_t sz, It first, It last) const {
    52  archive(static_cast<Entity>(sz));
    53 
    54  while(first != last) {
    55  const auto entity = *(first++);
    56 
    57  if(registry.template has<Component>(entity)) {
    58  archive(entity, registry.template get<Component>(entity));
    59  }
    60  }
    61  }
    62 
    63  template<typename... Component, typename Archive, typename It, std::size_t... Indexes>
    64  void component(Archive &archive, It first, It last, std::index_sequence<Indexes...>) const {
    65  std::array<std::size_t, sizeof...(Indexes)> size{};
    66  auto begin = first;
    67 
    68  while(begin != last) {
    69  const auto entity = *(begin++);
    70  using accumulator_type = std::size_t[];
    71  accumulator_type accumulator = { (registry.template has<Component>(entity) ? ++size[Indexes] : size[Indexes])... };
    72  (void)accumulator;
    73  }
    74 
    75  using accumulator_type = int[];
    76  accumulator_type accumulator = { (get<Component>(archive, size[Indexes], first, last), 0)... };
    77  (void)accumulator;
    78  }
    79 
    80 public:
    82  Snapshot(const Snapshot &) = delete;
    84  Snapshot(Snapshot &&) = default;
    85 
    87  Snapshot & operator=(const Snapshot &) = delete;
    89  Snapshot & operator=(Snapshot &&) = default;
    90 
    101  template<typename Archive>
    102  const Snapshot & entities(Archive &archive) const {
    103  archive(static_cast<Entity>(registry.alive()));
    104  registry.each([&archive](const auto entity) { archive(entity); });
    105  return *this;
    106  }
    107 
    118  template<typename Archive>
    119  const Snapshot & destroyed(Archive &archive) const {
    120  auto size = registry.size() - registry.alive();
    121  archive(static_cast<Entity>(size));
    122  auto curr = seed;
    123 
    124  for(; size; --size) {
    125  archive(curr);
    126  curr = follow(registry, curr);
    127  }
    128 
    129  return *this;
    130  }
    131 
    143  template<typename Component, typename Archive>
    144  const Snapshot & component(Archive &archive) const {
    145  const auto sz = registry.template size<Component>();
    146  const auto *entities = registry.template data<Component>();
    147 
    148  archive(static_cast<Entity>(sz));
    149 
    150  for(std::remove_const_t<decltype(sz)> i{}; i < sz; ++i) {
    151  const auto entity = entities[i];
    152  archive(entity, registry.template get<Component>(entity));
    153  };
    154 
    155  return *this;
    156  }
    157 
    169  template<typename... Component, typename Archive>
    170  std::enable_if_t<(sizeof...(Component) > 1), const Snapshot &>
    171  component(Archive &archive) const {
    172  using accumulator_type = int[];
    173  accumulator_type accumulator = { 0, (component<Component>(archive), 0)... };
    174  (void)accumulator;
    175  return *this;
    176  }
    177 
    192  template<typename... Component, typename Archive, typename It>
    193  const Snapshot & component(Archive &archive, It first, It last) const {
    194  component<Component...>(archive, first, last, std::make_index_sequence<sizeof...(Component)>{});
    195  return *this;
    196  }
    197 
    209  template<typename Tag, typename Archive>
    210  const Snapshot & tag(Archive &archive) const {
    211  const bool has = registry.template has<Tag>();
    212 
    213  // numerical length is forced for tags to facilitate loading
    214  archive(has ? Entity(1): Entity{});
    215 
    216  if(has) {
    217  archive(registry.template attachee<Tag>(), registry.template get<Tag>());
    218  }
    219 
    220  return *this;
    221  }
    222 
    234  template<typename... Tag, typename Archive>
    235  std::enable_if_t<(sizeof...(Tag) > 1), const Snapshot &>
    236  tag(Archive &archive) const {
    237  using accumulator_type = int[];
    238  accumulator_type accumulator = { 0, (tag<Tag>(archive), 0)... };
    239  (void)accumulator;
    240  return *this;
    241  }
    242 
    243 private:
    244  const Registry<Entity> &registry;
    245  const Entity seed;
    246  follow_fn_type *follow;
    247 };
    248 
    249 
    260 template<typename Entity>
    261 class SnapshotLoader final {
    263  friend class Registry<Entity>;
    264 
    265  using assure_fn_type = void(Registry<Entity> &, const Entity, const bool);
    266 
    267  SnapshotLoader(Registry<Entity> &registry, assure_fn_type *assure_fn) ENTT_NOEXCEPT
    268  : registry{registry},
    269  assure_fn{assure_fn}
    270  {
    271  // restore a snapshot as a whole requires a clean registry
    272  assert(!registry.capacity());
    273  }
    274 
    275  template<typename Archive>
    276  void assure(Archive &archive, bool destroyed) const {
    277  Entity length{};
    278  archive(length);
    279 
    280  while(length--) {
    281  Entity entity{};
    282  archive(entity);
    283  assure_fn(registry, entity, destroyed);
    284  }
    285  }
    286 
    287  template<typename Type, typename Archive, typename... Args>
    288  void assign(Archive &archive, Args... args) const {
    289  Entity length{};
    290  archive(length);
    291 
    292  while(length--) {
    293  Entity entity{};
    294  Type instance{};
    295  archive(entity, instance);
    296  static constexpr auto destroyed = false;
    297  assure_fn(registry, entity, destroyed);
    298  registry.template assign<Type>(args..., entity, static_cast<const Type &>(instance));
    299  }
    300  }
    301 
    302 public:
    304  SnapshotLoader(const SnapshotLoader &) = delete;
    306  SnapshotLoader(SnapshotLoader &&) = default;
    307 
    309  SnapshotLoader & operator=(const SnapshotLoader &) = delete;
    311  SnapshotLoader & operator=(SnapshotLoader &&) = default;
    312 
    323  template<typename Archive>
    324  const SnapshotLoader & entities(Archive &archive) const {
    325  static constexpr auto destroyed = false;
    326  assure(archive, destroyed);
    327  return *this;
    328  }
    329 
    340  template<typename Archive>
    341  const SnapshotLoader & destroyed(Archive &archive) const {
    342  static constexpr auto destroyed = true;
    343  assure(archive, destroyed);
    344  return *this;
    345  }
    346 
    360  template<typename... Component, typename Archive>
    361  const SnapshotLoader & component(Archive &archive) const {
    362  using accumulator_type = int[];
    363  accumulator_type accumulator = { 0, (assign<Component>(archive), 0)... };
    364  (void)accumulator;
    365  return *this;
    366  }
    367 
    381  template<typename... Tag, typename Archive>
    382  const SnapshotLoader & tag(Archive &archive) const {
    383  using accumulator_type = int[];
    384  accumulator_type accumulator = { 0, (assign<Tag>(archive, tag_t{}), 0)... };
    385  (void)accumulator;
    386  return *this;
    387  }
    388 
    399  const SnapshotLoader & orphans() const {
    400  registry.orphans([this](const auto entity) {
    401  registry.destroy(entity);
    402  });
    403 
    404  return *this;
    405  }
    406 
    407 private:
    408  Registry<Entity> &registry;
    409  assure_fn_type *assure_fn;
    410 };
    411 
    412 
    429 template<typename Entity>
    430 class ContinuousLoader final {
    431  using traits_type = entt_traits<Entity>;
    432 
    433  void destroy(Entity entity) {
    434  const auto it = remloc.find(entity);
    435 
    436  if(it == remloc.cend()) {
    437  const auto local = registry.create();
    438  remloc.emplace(entity, std::make_pair(local, true));
    439  registry.destroy(local);
    440  }
    441  }
    442 
    443  void restore(Entity entity) {
    444  const auto it = remloc.find(entity);
    445 
    446  if(it == remloc.cend()) {
    447  const auto local = registry.create();
    448  remloc.emplace(entity, std::make_pair(local, true));
    449  } else {
    450  remloc[entity].first =
    451  registry.valid(remloc[entity].first)
    452  ? remloc[entity].first
    453  : registry.create();
    454 
    455  // set the dirty flag
    456  remloc[entity].second = true;
    457  }
    458  }
    459 
    460  template<typename Type, typename Member>
    461  std::enable_if_t<std::is_same<Member, Entity>::value>
    462  update(Type &instance, Member Type:: *member) {
    463  instance.*member = map(instance.*member);
    464  }
    465 
    466  template<typename Type, typename Member>
    467  std::enable_if_t<std::is_same<typename std::iterator_traits<typename Member::iterator>::value_type, Entity>::value>
    468  update(Type &instance, Member Type:: *member) {
    469  for(auto &entity: instance.*member) {
    470  entity = map(entity);
    471  }
    472  }
    473 
    474  template<typename Other, typename Type, typename Member>
    475  std::enable_if_t<!std::is_same<Other, Type>::value>
    476  update(Other &, Member Type:: *) {}
    477 
    478  template<typename Archive>
    479  void assure(Archive &archive, void(ContinuousLoader:: *member)(Entity)) {
    480  Entity length{};
    481  archive(length);
    482 
    483  while(length--) {
    484  Entity entity{};
    485  archive(entity);
    486  (this->*member)(entity);
    487  }
    488  }
    489 
    490  template<typename Component>
    491  void reset() {
    492  for(auto &&ref: remloc) {
    493  const auto local = ref.second.first;
    494 
    495  if(registry.valid(local)) {
    496  registry.template reset<Component>(local);
    497  }
    498  }
    499  }
    500 
    501  template<typename Other, typename Archive, typename Func, typename... Type, typename... Member>
    502  void assign(Archive &archive, Func func, Member Type:: *... member) {
    503  Entity length{};
    504  archive(length);
    505 
    506  while(length--) {
    507  Entity entity{};
    508  Other instance{};
    509 
    510  archive(entity, instance);
    511  restore(entity);
    512 
    513  using accumulator_type = int[];
    514  accumulator_type accumulator = { 0, (update(instance, member), 0)... };
    515  (void)accumulator;
    516 
    517  func(map(entity), instance);
    518  }
    519  }
    520 
    521 public:
    523  using entity_type = Entity;
    524 
    529  ContinuousLoader(Registry<entity_type> &registry) ENTT_NOEXCEPT
    530  : registry{registry}
    531  {}
    532 
    534  ContinuousLoader(const ContinuousLoader &) = delete;
    536  ContinuousLoader(ContinuousLoader &&) = default;
    537 
    539  ContinuousLoader & operator=(const ContinuousLoader &) = delete;
    541  ContinuousLoader & operator=(ContinuousLoader &&) = default;
    542 
    553  template<typename Archive>
    554  ContinuousLoader & entities(Archive &archive) {
    555  assure(archive, &ContinuousLoader::restore);
    556  return *this;
    557  }
    558 
    569  template<typename Archive>
    570  ContinuousLoader & destroyed(Archive &archive) {
    571  assure(archive, &ContinuousLoader::destroy);
    572  return *this;
    573  }
    574 
    594  template<typename... Component, typename Archive, typename... Type, typename... Member>
    595  ContinuousLoader & component(Archive &archive, Member Type:: *... member) {
    596  auto apply = [this](const auto entity, const auto &component) {
    597  registry.template accommodate<std::decay_t<decltype(component)>>(entity, component);
    598  };
    599 
    600  using accumulator_type = int[];
    601  accumulator_type accumulator = { 0, (reset<Component>(), assign<Component>(archive, apply, member...), 0)... };
    602  (void)accumulator;
    603  return *this;
    604  }
    605 
    625  template<typename... Tag, typename Archive, typename... Type, typename... Member>
    626  ContinuousLoader & tag(Archive &archive, Member Type:: *... member) {
    627  auto apply = [this](const auto entity, const auto &tag) {
    628  registry.template assign<std::decay_t<decltype(tag)>>(tag_t{}, entity, tag);
    629  };
    630 
    631  using accumulator_type = int[];
    632  accumulator_type accumulator = { 0, (registry.template remove<Tag>(), assign<Tag>(archive, apply, member...), 0)... };
    633  (void)accumulator;
    634  return *this;
    635  }
    636 
    645  ContinuousLoader & shrink() {
    646  auto it = remloc.begin();
    647 
    648  while(it != remloc.cend()) {
    649  const auto local = it->second.first;
    650  bool &dirty = it->second.second;
    651 
    652  if(dirty) {
    653  dirty = false;
    654  ++it;
    655  } else {
    656  if(registry.valid(local)) {
    657  registry.destroy(local);
    658  }
    659 
    660  it = remloc.erase(it);
    661  }
    662  }
    663 
    664  return *this;
    665  }
    666 
    677  ContinuousLoader & orphans() {
    678  registry.orphans([this](const auto entity) {
    679  registry.destroy(entity);
    680  });
    681 
    682  return *this;
    683  }
    684 
    690  bool has(entity_type entity) const ENTT_NOEXCEPT {
    691  return (remloc.find(entity) != remloc.cend());
    692  }
    693 
    706  entity_type map(entity_type entity) const ENTT_NOEXCEPT {
    707  assert(has(entity));
    708  return remloc.find(entity)->second.first;
    709  }
    710 
    711 private:
    712  std::unordered_map<Entity, std::pair<Entity, bool>> remloc;
    713  Registry<Entity> &registry;
    714 };
    715 
    716 
    717 }
    718 
    719 
    720 #endif // ENTT_ENTITY_SNAPSHOT_HPP
    entt::ContinuousLoader::tag
    ContinuousLoader & tag(Archive &archive, Member Type::*... member)
    Restores tags and assigns them to the right entities.
    Definition: snapshot.hpp:626
    entt::ContinuousLoader::map
    entity_type map(entity_type entity) const ENTT_NOEXCEPT
    Returns the identifier to which an entity refers.
    Definition: snapshot.hpp:706
    entt::Registry
    Fast and reliable entity-component system.
    Definition: registry.hpp:40
    entt::SnapshotLoader
    Utility class to restore a snapshot as a whole.
    Definition: snapshot.hpp:261
    diff --git a/sparse__set_8hpp_source.html b/sparse__set_8hpp_source.html index 396039b35..97e289ccc 100644 --- a/sparse__set_8hpp_source.html +++ b/sparse__set_8hpp_source.html @@ -5,7 +5,7 @@ -entt: src/entt/entity/sparse_set.hpp Source File +EnTT: src/entt/entity/sparse_set.hpp Source File @@ -21,8 +21,8 @@ -
    entt -  2.7.1 +
    EnTT +  2.7.2
    @@ -67,7 +67,7 @@ $(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 <iterator>
    7 #include <numeric>
    8 #include <utility>
    9 #include <vector>
    10 #include <cstddef>
    11 #include <cassert>
    12 #include <type_traits>
    13 #include "../config/config.h"
    14 #include "../core/algorithm.hpp"
    15 #include "entt_traits.hpp"
    16 #include "entity.hpp"
    17 
    18 
    19 namespace entt {
    20 
    21 
    28 template<typename...>
    29 class SparseSet;
    30 
    31 
    59 template<typename Entity>
    60 class SparseSet<Entity> {
    61  using traits_type = entt_traits<Entity>;
    62 
    63  class Iterator final {
    64  friend class SparseSet<Entity>;
    65 
    66  using entity_type = Entity;
    67  using index_type = typename traits_type::difference_type;
    68 
    69  Iterator(const entity_type *direct, index_type index) ENTT_NOEXCEPT
    70  : direct{direct}, index{index}
    71  {}
    72 
    73  public:
    74  using difference_type = index_type;
    75  using value_type = const entity_type;
    76  using pointer = value_type *;
    77  using reference = value_type &;
    78  using iterator_category = std::random_access_iterator_tag;
    79 
    80  Iterator() ENTT_NOEXCEPT = default;
    81 
    82  Iterator(const Iterator &) ENTT_NOEXCEPT = default;
    83  Iterator & operator=(const Iterator &) ENTT_NOEXCEPT = default;
    84 
    85  Iterator & operator++() ENTT_NOEXCEPT {
    86  return --index, *this;
    87  }
    88 
    89  Iterator operator++(int) ENTT_NOEXCEPT {
    90  Iterator orig = *this;
    91  return ++(*this), orig;
    92  }
    93 
    94  Iterator & operator--() ENTT_NOEXCEPT {
    95  return ++index, *this;
    96  }
    97 
    98  Iterator operator--(int) ENTT_NOEXCEPT {
    99  Iterator orig = *this;
    100  return --(*this), orig;
    101  }
    102 
    103  Iterator & operator+=(const difference_type value) ENTT_NOEXCEPT {
    104  index -= value;
    105  return *this;
    106  }
    107 
    108  Iterator operator+(const difference_type value) const ENTT_NOEXCEPT {
    109  return Iterator{direct, index-value};
    110  }
    111 
    112  inline Iterator & operator-=(const difference_type value) ENTT_NOEXCEPT {
    113  return (*this += -value);
    114  }
    115 
    116  inline Iterator operator-(const difference_type value) const ENTT_NOEXCEPT {
    117  return (*this + -value);
    118  }
    119 
    120  difference_type operator-(const Iterator &other) const ENTT_NOEXCEPT {
    121  return other.index - index;
    122  }
    123 
    124  reference operator[](const difference_type value) const ENTT_NOEXCEPT {
    125  return direct[index-value-1];
    126  }
    127 
    128  bool operator==(const Iterator &other) const ENTT_NOEXCEPT {
    129  return other.index == index;
    130  }
    131 
    132  inline bool operator!=(const Iterator &other) const ENTT_NOEXCEPT {
    133  return !(*this == other);
    134  }
    135 
    136  bool operator<(const Iterator &other) const ENTT_NOEXCEPT {
    137  return index > other.index;
    138  }
    139 
    140  bool operator>(const Iterator &other) const ENTT_NOEXCEPT {
    141  return index < other.index;
    142  }
    143 
    144  inline bool operator<=(const Iterator &other) const ENTT_NOEXCEPT {
    145  return !(*this > other);
    146  }
    147 
    148  inline bool operator>=(const Iterator &other) const ENTT_NOEXCEPT {
    149  return !(*this < other);
    150  }
    151 
    152  pointer operator->() const ENTT_NOEXCEPT {
    153  return (direct+index-1);
    154  }
    155 
    156  inline reference operator*() const ENTT_NOEXCEPT {
    157  return *operator->();
    158  }
    159 
    160  private:
    161  pointer direct;
    162  index_type index;
    163  };
    164 
    165 public:
    167  using entity_type = Entity;
    169  using size_type = std::size_t;
    171  using iterator_type = Iterator;
    173  using const_iterator_type = Iterator;
    174 
    176  SparseSet() ENTT_NOEXCEPT = default;
    177 
    179  virtual ~SparseSet() ENTT_NOEXCEPT = default;
    180 
    182  SparseSet(const SparseSet &) = delete;
    184  SparseSet(SparseSet &&) = default;
    185 
    187  SparseSet & operator=(const SparseSet &) = delete;
    189  SparseSet & operator=(SparseSet &&) = default;
    190 
    199  void reserve(const size_type cap) {
    200  direct.reserve(cap);
    201  }
    202 
    208  size_type capacity() const ENTT_NOEXCEPT {
    209  return direct.capacity();
    210  }
    211 
    222  size_type extent() const ENTT_NOEXCEPT {
    223  return reverse.size();
    224  }
    225 
    236  size_type size() const ENTT_NOEXCEPT {
    237  return direct.size();
    238  }
    239 
    244  bool empty() const ENTT_NOEXCEPT {
    245  return direct.empty();
    246  }
    247 
    263  const entity_type * data() const ENTT_NOEXCEPT {
    264  return direct.data();
    265  }
    266 
    279  const_iterator_type cbegin() const ENTT_NOEXCEPT {
    280  const typename traits_type::difference_type pos = direct.size();
    281  return const_iterator_type{direct.data(), pos};
    282  }
    283 
    296  inline const_iterator_type begin() const ENTT_NOEXCEPT {
    297  return cbegin();
    298  }
    299 
    312  inline iterator_type begin() ENTT_NOEXCEPT {
    313  return cbegin();
    314  }
    315 
    329  const_iterator_type cend() const ENTT_NOEXCEPT {
    330  return const_iterator_type{direct.data(), {}};
    331  }
    332 
    346  inline const_iterator_type end() const ENTT_NOEXCEPT {
    347  return cend();
    348  }
    349 
    363  inline iterator_type end() ENTT_NOEXCEPT {
    364  return cend();
    365  }
    366 
    372  inline const entity_type & operator[](const size_type pos) const ENTT_NOEXCEPT {
    373  return cbegin()[pos];
    374  }
    375 
    381  bool has(const entity_type entity) const ENTT_NOEXCEPT {
    382  const auto pos = size_type(entity & traits_type::entity_mask);
    383  // testing against null permits to avoid accessing the direct vector
    384  return (pos < reverse.size()) && (reverse[pos] != null);
    385  }
    386 
    404  bool fast(const entity_type entity) const ENTT_NOEXCEPT {
    405  const auto pos = size_type(entity & traits_type::entity_mask);
    406  assert(pos < reverse.size());
    407  // testing against null permits to avoid accessing the direct vector
    408  return (reverse[pos] != null);
    409  }
    410 
    423  size_type get(const entity_type entity) const ENTT_NOEXCEPT {
    424  assert(has(entity));
    425  return reverse[entity & traits_type::entity_mask];
    426  }
    427 
    439  void construct(const entity_type entity) {
    440  assert(!has(entity));
    441  const auto pos = size_type(entity & traits_type::entity_mask);
    442 
    443  if(!(pos < reverse.size())) {
    444  // null is safe in all cases for our purposes
    445  reverse.resize(pos+1, null);
    446  }
    447 
    448  reverse[pos] = entity_type(direct.size());
    449  direct.push_back(entity);
    450  }
    451 
    463  virtual void destroy(const entity_type entity) {
    464  assert(has(entity));
    465  const auto back = direct.back();
    466  auto &candidate = reverse[entity & traits_type::entity_mask];
    467  // swapping isn't required here, we are getting rid of the last element
    468  reverse[back & traits_type::entity_mask] = candidate;
    469  direct[candidate] = back;
    470  candidate = null;
    471  direct.pop_back();
    472  }
    473 
    489  void swap(const size_type lhs, const size_type rhs) ENTT_NOEXCEPT {
    490  assert(lhs < direct.size());
    491  assert(rhs < direct.size());
    492  auto &src = direct[lhs];
    493  auto &dst = direct[rhs];
    494  std::swap(reverse[src & traits_type::entity_mask], reverse[dst & traits_type::entity_mask]);
    495  std::swap(src, dst);
    496  }
    497 
    517  void respect(const SparseSet<Entity> &other) ENTT_NOEXCEPT {
    518  auto from = other.cbegin();
    519  auto to = other.cend();
    520 
    521  size_type pos = direct.size() - 1;
    522 
    523  while(pos && from != to) {
    524  if(has(*from)) {
    525  if(*from != direct[pos]) {
    526  swap(pos, get(*from));
    527  }
    528 
    529  --pos;
    530  }
    531 
    532  ++from;
    533  }
    534  }
    535 
    539  virtual void reset() {
    540  reverse.clear();
    541  direct.clear();
    542  }
    543 
    544 private:
    545  std::vector<entity_type> reverse;
    546  std::vector<entity_type> direct;
    547 };
    548 
    549 
    572 template<typename Entity, typename Type>
    573 class SparseSet<Entity, Type>: public SparseSet<Entity> {
    574  using underlying_type = SparseSet<Entity>;
    575  using traits_type = entt_traits<Entity>;
    576 
    577  template<bool Const>
    578  class Iterator final {
    579  friend class SparseSet<Entity, Type>;
    580 
    581  using instance_type = std::conditional_t<Const, const Type, Type>;
    582  using index_type = typename traits_type::difference_type;
    583 
    584  Iterator(instance_type *instances, index_type index) ENTT_NOEXCEPT
    585  : instances{instances}, index{index}
    586  {}
    587 
    588  public:
    589  using difference_type = index_type;
    590  using value_type = instance_type;
    591  using pointer = value_type *;
    592  using reference = value_type &;
    593  using iterator_category = std::random_access_iterator_tag;
    594 
    595  Iterator() ENTT_NOEXCEPT = default;
    596 
    597  Iterator(const Iterator &) ENTT_NOEXCEPT = default;
    598  Iterator & operator=(const Iterator &) ENTT_NOEXCEPT = default;
    599 
    600  Iterator & operator++() ENTT_NOEXCEPT {
    601  return --index, *this;
    602  }
    603 
    604  Iterator operator++(int) ENTT_NOEXCEPT {
    605  Iterator orig = *this;
    606  return ++(*this), orig;
    607  }
    608 
    609  Iterator & operator--() ENTT_NOEXCEPT {
    610  return ++index, *this;
    611  }
    612 
    613  Iterator operator--(int) ENTT_NOEXCEPT {
    614  Iterator orig = *this;
    615  return --(*this), orig;
    616  }
    617 
    618  Iterator & operator+=(const difference_type value) ENTT_NOEXCEPT {
    619  index -= value;
    620  return *this;
    621  }
    622 
    623  Iterator operator+(const difference_type value) const ENTT_NOEXCEPT {
    624  return Iterator{instances, index-value};
    625  }
    626 
    627  inline Iterator & operator-=(const difference_type value) ENTT_NOEXCEPT {
    628  return (*this += -value);
    629  }
    630 
    631  inline Iterator operator-(const difference_type value) const ENTT_NOEXCEPT {
    632  return (*this + -value);
    633  }
    634 
    635  difference_type operator-(const Iterator &other) const ENTT_NOEXCEPT {
    636  return other.index - index;
    637  }
    638 
    639  reference operator[](const difference_type value) const ENTT_NOEXCEPT {
    640  return instances[index-value-1];
    641  }
    642 
    643  bool operator==(const Iterator &other) const ENTT_NOEXCEPT {
    644  return other.index == index;
    645  }
    646 
    647  inline bool operator!=(const Iterator &other) const ENTT_NOEXCEPT {
    648  return !(*this == other);
    649  }
    650 
    651  bool operator<(const Iterator &other) const ENTT_NOEXCEPT {
    652  return index > other.index;
    653  }
    654 
    655  bool operator>(const Iterator &other) const ENTT_NOEXCEPT {
    656  return index < other.index;
    657  }
    658 
    659  inline bool operator<=(const Iterator &other) const ENTT_NOEXCEPT {
    660  return !(*this > other);
    661  }
    662 
    663  inline bool operator>=(const Iterator &other) const ENTT_NOEXCEPT {
    664  return !(*this < other);
    665  }
    666 
    667  pointer operator->() const ENTT_NOEXCEPT {
    668  return (instances+index-1);
    669  }
    670 
    671  inline reference operator*() const ENTT_NOEXCEPT {
    672  return *operator->();
    673  }
    674 
    675  private:
    676  pointer instances;
    677  index_type index;
    678  };
    679 
    680 public:
    682  using object_type = Type;
    684  using entity_type = typename underlying_type::entity_type;
    686  using size_type = typename underlying_type::size_type;
    688  using iterator_type = Iterator<false>;
    690  using const_iterator_type = Iterator<true>;
    691 
    693  SparseSet() ENTT_NOEXCEPT = default;
    694 
    696  SparseSet(const SparseSet &) = delete;
    698  SparseSet(SparseSet &&) = default;
    699 
    701  SparseSet & operator=(const SparseSet &) = delete;
    703  SparseSet & operator=(SparseSet &&) = default;
    704 
    713  void reserve(const size_type cap) {
    714  underlying_type::reserve(cap);
    715  instances.reserve(cap);
    716  }
    717 
    733  const object_type * raw() const ENTT_NOEXCEPT {
    734  return instances.data();
    735  }
    736 
    752  object_type * raw() ENTT_NOEXCEPT {
    753  return instances.data();
    754  }
    755 
    768  const_iterator_type cbegin() const ENTT_NOEXCEPT {
    769  const typename traits_type::difference_type pos = instances.size();
    770  return const_iterator_type{instances.data(), pos};
    771  }
    772 
    785  inline const_iterator_type begin() const ENTT_NOEXCEPT {
    786  return cbegin();
    787  }
    788 
    801  iterator_type begin() ENTT_NOEXCEPT {
    802  const typename traits_type::difference_type pos = instances.size();
    803  return iterator_type{instances.data(), pos};
    804  }
    805 
    820  const_iterator_type cend() const ENTT_NOEXCEPT {
    821  return const_iterator_type{instances.data(), {}};
    822  }
    823 
    838  inline const_iterator_type end() const ENTT_NOEXCEPT {
    839  return cend();
    840  }
    841 
    856  iterator_type end() ENTT_NOEXCEPT {
    857  return iterator_type{instances.data(), {}};
    858  }
    859 
    865  inline const object_type & operator[](const size_type pos) const ENTT_NOEXCEPT {
    866  return cbegin()[pos];
    867  }
    868 
    874  inline object_type & operator[](const size_type pos) ENTT_NOEXCEPT {
    875  return const_cast<object_type &>(const_cast<const SparseSet *>(this)->operator[](pos));
    876  }
    877 
    890  const object_type & get(const entity_type entity) const ENTT_NOEXCEPT {
    891  return instances[underlying_type::get(entity)];
    892  }
    893 
    906  inline object_type & get(const entity_type entity) ENTT_NOEXCEPT {
    907  return const_cast<object_type &>(const_cast<const SparseSet *>(this)->get(entity));
    908  }
    909 
    930  template<typename... Args>
    931  std::enable_if_t<std::is_constructible<Type, Args...>::value, object_type &>
    932  construct(const entity_type entity, Args &&... args) {
    933  underlying_type::construct(entity);
    934  instances.emplace_back(std::forward<Args>(args)...);
    935  return instances.back();
    936  }
    937 
    958  template<typename... Args>
    959  std::enable_if_t<!std::is_constructible<Type, Args...>::value, object_type &>
    960  construct(const entity_type entity, Args &&... args) {
    961  underlying_type::construct(entity);
    962  instances.emplace_back(Type{std::forward<Args>(args)...});
    963  return instances.back();
    964  }
    965 
    977  void destroy(const entity_type entity) override {
    978  // swapping isn't required here, we are getting rid of the last element
    979  // however, we must protect ourselves from self assignments (see #37)
    980  auto tmp = std::move(instances.back());
    981  instances[underlying_type::get(entity)] = std::move(tmp);
    982  instances.pop_back();
    983  underlying_type::destroy(entity);
    984  }
    985 
    1027  template<typename Compare, typename Sort = StdSort, typename... Args>
    1028  void sort(Compare compare, Sort sort = Sort{}, Args &&... args) {
    1029  std::vector<size_type> copy(instances.size());
    1030  std::iota(copy.begin(), copy.end(), 0);
    1031 
    1032  sort(copy.begin(), copy.end(), [this, compare = std::move(compare)](const auto lhs, const auto rhs) {
    1033  return compare(const_cast<const object_type &>(instances[rhs]), const_cast<const object_type &>(instances[lhs]));
    1034  }, std::forward<Args>(args)...);
    1035 
    1036  for(size_type pos = 0, last = copy.size(); pos < last; ++pos) {
    1037  auto curr = pos;
    1038  auto next = copy[curr];
    1039 
    1040  while(curr != next) {
    1041  const auto lhs = copy[curr];
    1042  const auto rhs = copy[next];
    1043  std::swap(instances[lhs], instances[rhs]);
    1044  underlying_type::swap(lhs, rhs);
    1045  copy[curr] = curr;
    1046  curr = next;
    1047  next = copy[curr];
    1048  }
    1049  }
    1050  }
    1051 
    1075  void respect(const SparseSet<Entity> &other) ENTT_NOEXCEPT {
    1076  auto from = other.cbegin();
    1077  auto to = other.cend();
    1078 
    1079  size_type pos = underlying_type::size() - 1;
    1080  const auto *local = underlying_type::data();
    1081 
    1082  while(pos && from != to) {
    1083  const auto curr = *from;
    1084 
    1085  if(underlying_type::has(curr)) {
    1086  if(curr != *(local + pos)) {
    1087  auto candidate = underlying_type::get(curr);
    1088  std::swap(instances[pos], instances[candidate]);
    1089  underlying_type::swap(pos, candidate);
    1090  }
    1091 
    1092  --pos;
    1093  }
    1094 
    1095  ++from;
    1096  }
    1097  }
    1098 
    1102  void reset() override {
    1103  underlying_type::reset();
    1104  instances.clear();
    1105  }
    1106 
    1107 private:
    1108  std::vector<object_type> instances;
    1109 };
    1110 
    1111 
    1112 }
    1113 
    1114 
    1115 #endif // ENTT_ENTITY_SPARSE_SET_HPP
    entt::SparseSet< Entity >::swap
    void swap(const size_type lhs, const size_type rhs) ENTT_NOEXCEPT
    Swaps the position of two entities in the internal packed array.
    Definition: sparse_set.hpp:489
    +
    1 #ifndef ENTT_ENTITY_SPARSE_SET_HPP
    2 #define ENTT_ENTITY_SPARSE_SET_HPP
    3 
    4 
    5 #include <algorithm>
    6 #include <iterator>
    7 #include <numeric>
    8 #include <utility>
    9 #include <vector>
    10 #include <cstddef>
    11 #include <cassert>
    12 #include <type_traits>
    13 #include "../config/config.h"
    14 #include "../core/algorithm.hpp"
    15 #include "entt_traits.hpp"
    16 #include "entity.hpp"
    17 
    18 
    19 namespace entt {
    20 
    21 
    28 template<typename...>
    29 class SparseSet;
    30 
    31 
    59 template<typename Entity>
    60 class SparseSet<Entity> {
    61  using traits_type = entt_traits<Entity>;
    62 
    63  class Iterator final {
    64  friend class SparseSet<Entity>;
    65 
    66  using direct_type = const std::vector<Entity>;
    67  using index_type = typename traits_type::difference_type;
    68 
    69  Iterator(direct_type *direct, index_type index) ENTT_NOEXCEPT
    70  : direct{direct}, index{index}
    71  {}
    72 
    73  public:
    74  using difference_type = index_type;
    75  using value_type = const Entity;
    76  using pointer = value_type *;
    77  using reference = value_type &;
    78  using iterator_category = std::random_access_iterator_tag;
    79 
    80  Iterator() ENTT_NOEXCEPT = default;
    81 
    82  Iterator(const Iterator &) ENTT_NOEXCEPT = default;
    83  Iterator & operator=(const Iterator &) ENTT_NOEXCEPT = default;
    84 
    85  Iterator & operator++() ENTT_NOEXCEPT {
    86  return --index, *this;
    87  }
    88 
    89  Iterator operator++(int) ENTT_NOEXCEPT {
    90  Iterator orig = *this;
    91  return ++(*this), orig;
    92  }
    93 
    94  Iterator & operator--() ENTT_NOEXCEPT {
    95  return ++index, *this;
    96  }
    97 
    98  Iterator operator--(int) ENTT_NOEXCEPT {
    99  Iterator orig = *this;
    100  return --(*this), orig;
    101  }
    102 
    103  Iterator & operator+=(const difference_type value) ENTT_NOEXCEPT {
    104  index -= value;
    105  return *this;
    106  }
    107 
    108  Iterator operator+(const difference_type value) const ENTT_NOEXCEPT {
    109  return Iterator{direct, index-value};
    110  }
    111 
    112  inline Iterator & operator-=(const difference_type value) ENTT_NOEXCEPT {
    113  return (*this += -value);
    114  }
    115 
    116  inline Iterator operator-(const difference_type value) const ENTT_NOEXCEPT {
    117  return (*this + -value);
    118  }
    119 
    120  difference_type operator-(const Iterator &other) const ENTT_NOEXCEPT {
    121  return other.index - index;
    122  }
    123 
    124  reference operator[](const difference_type value) const ENTT_NOEXCEPT {
    125  return (*direct)[index-value-1];
    126  }
    127 
    128  bool operator==(const Iterator &other) const ENTT_NOEXCEPT {
    129  return other.index == index;
    130  }
    131 
    132  inline bool operator!=(const Iterator &other) const ENTT_NOEXCEPT {
    133  return !(*this == other);
    134  }
    135 
    136  bool operator<(const Iterator &other) const ENTT_NOEXCEPT {
    137  return index > other.index;
    138  }
    139 
    140  bool operator>(const Iterator &other) const ENTT_NOEXCEPT {
    141  return index < other.index;
    142  }
    143 
    144  inline bool operator<=(const Iterator &other) const ENTT_NOEXCEPT {
    145  return !(*this > other);
    146  }
    147 
    148  inline bool operator>=(const Iterator &other) const ENTT_NOEXCEPT {
    149  return !(*this < other);
    150  }
    151 
    152  pointer operator->() const ENTT_NOEXCEPT {
    153  return &(*direct)[index-1];
    154  }
    155 
    156  inline reference operator*() const ENTT_NOEXCEPT {
    157  return *operator->();
    158  }
    159 
    160  private:
    161  direct_type *direct;
    162  index_type index;
    163  };
    164 
    165 public:
    167  using entity_type = Entity;
    169  using size_type = std::size_t;
    171  using iterator_type = Iterator;
    173  using const_iterator_type = Iterator;
    174 
    176  SparseSet() ENTT_NOEXCEPT = default;
    177 
    179  virtual ~SparseSet() ENTT_NOEXCEPT = default;
    180 
    182  SparseSet(const SparseSet &) = delete;
    184  SparseSet(SparseSet &&) = default;
    185 
    187  SparseSet & operator=(const SparseSet &) = delete;
    189  SparseSet & operator=(SparseSet &&) = default;
    190 
    199  void reserve(const size_type cap) {
    200  direct.reserve(cap);
    201  }
    202 
    208  size_type capacity() const ENTT_NOEXCEPT {
    209  return direct.capacity();
    210  }
    211 
    222  size_type extent() const ENTT_NOEXCEPT {
    223  return reverse.size();
    224  }
    225 
    236  size_type size() const ENTT_NOEXCEPT {
    237  return direct.size();
    238  }
    239 
    244  bool empty() const ENTT_NOEXCEPT {
    245  return direct.empty();
    246  }
    247 
    263  const entity_type * data() const ENTT_NOEXCEPT {
    264  return direct.data();
    265  }
    266 
    279  const_iterator_type cbegin() const ENTT_NOEXCEPT {
    280  const typename traits_type::difference_type pos = direct.size();
    281  return const_iterator_type{&direct, pos};
    282  }
    283 
    296  inline const_iterator_type begin() const ENTT_NOEXCEPT {
    297  return cbegin();
    298  }
    299 
    312  inline iterator_type begin() ENTT_NOEXCEPT {
    313  return cbegin();
    314  }
    315 
    329  const_iterator_type cend() const ENTT_NOEXCEPT {
    330  return const_iterator_type{&direct, {}};
    331  }
    332 
    346  inline const_iterator_type end() const ENTT_NOEXCEPT {
    347  return cend();
    348  }
    349 
    363  inline iterator_type end() ENTT_NOEXCEPT {
    364  return cend();
    365  }
    366 
    372  inline const entity_type & operator[](const size_type pos) const ENTT_NOEXCEPT {
    373  return cbegin()[pos];
    374  }
    375 
    381  bool has(const entity_type entity) const ENTT_NOEXCEPT {
    382  const auto pos = size_type(entity & traits_type::entity_mask);
    383  // testing against null permits to avoid accessing the direct vector
    384  return (pos < reverse.size()) && (reverse[pos] != null);
    385  }
    386 
    404  bool fast(const entity_type entity) const ENTT_NOEXCEPT {
    405  const auto pos = size_type(entity & traits_type::entity_mask);
    406  assert(pos < reverse.size());
    407  // testing against null permits to avoid accessing the direct vector
    408  return (reverse[pos] != null);
    409  }
    410 
    423  size_type get(const entity_type entity) const ENTT_NOEXCEPT {
    424  assert(has(entity));
    425  return reverse[entity & traits_type::entity_mask];
    426  }
    427 
    439  void construct(const entity_type entity) {
    440  assert(!has(entity));
    441  const auto pos = size_type(entity & traits_type::entity_mask);
    442 
    443  if(!(pos < reverse.size())) {
    444  // null is safe in all cases for our purposes
    445  reverse.resize(pos+1, null);
    446  }
    447 
    448  reverse[pos] = entity_type(direct.size());
    449  direct.push_back(entity);
    450  }
    451 
    463  virtual void destroy(const entity_type entity) {
    464  assert(has(entity));
    465  const auto back = direct.back();
    466  auto &candidate = reverse[entity & traits_type::entity_mask];
    467  // swapping isn't required here, we are getting rid of the last element
    468  reverse[back & traits_type::entity_mask] = candidate;
    469  direct[candidate] = back;
    470  candidate = null;
    471  direct.pop_back();
    472  }
    473 
    489  void swap(const size_type lhs, const size_type rhs) ENTT_NOEXCEPT {
    490  assert(lhs < direct.size());
    491  assert(rhs < direct.size());
    492  auto &src = direct[lhs];
    493  auto &dst = direct[rhs];
    494  std::swap(reverse[src & traits_type::entity_mask], reverse[dst & traits_type::entity_mask]);
    495  std::swap(src, dst);
    496  }
    497 
    517  void respect(const SparseSet<Entity> &other) ENTT_NOEXCEPT {
    518  auto from = other.cbegin();
    519  auto to = other.cend();
    520 
    521  size_type pos = direct.size() - 1;
    522 
    523  while(pos && from != to) {
    524  if(has(*from)) {
    525  if(*from != direct[pos]) {
    526  swap(pos, get(*from));
    527  }
    528 
    529  --pos;
    530  }
    531 
    532  ++from;
    533  }
    534  }
    535 
    539  virtual void reset() {
    540  reverse.clear();
    541  direct.clear();
    542  }
    543 
    544 private:
    545  std::vector<entity_type> reverse;
    546  std::vector<entity_type> direct;
    547 };
    548 
    549 
    572 template<typename Entity, typename Type>
    573 class SparseSet<Entity, Type>: public SparseSet<Entity> {
    574  using underlying_type = SparseSet<Entity>;
    575  using traits_type = entt_traits<Entity>;
    576 
    577  template<bool Const>
    578  class Iterator final {
    579  friend class SparseSet<Entity, Type>;
    580 
    581  using instance_type = std::conditional_t<Const, const std::vector<Type>, std::vector<Type>>;
    582  using index_type = typename traits_type::difference_type;
    583 
    584  Iterator(instance_type *instances, index_type index) ENTT_NOEXCEPT
    585  : instances{instances}, index{index}
    586  {}
    587 
    588  public:
    589  using difference_type = index_type;
    590  using value_type = std::conditional_t<Const, const Type, Type>;
    591  using pointer = value_type *;
    592  using reference = value_type &;
    593  using iterator_category = std::random_access_iterator_tag;
    594 
    595  Iterator() ENTT_NOEXCEPT = default;
    596 
    597  Iterator(const Iterator &) ENTT_NOEXCEPT = default;
    598  Iterator & operator=(const Iterator &) ENTT_NOEXCEPT = default;
    599 
    600  Iterator & operator++() ENTT_NOEXCEPT {
    601  return --index, *this;
    602  }
    603 
    604  Iterator operator++(int) ENTT_NOEXCEPT {
    605  Iterator orig = *this;
    606  return ++(*this), orig;
    607  }
    608 
    609  Iterator & operator--() ENTT_NOEXCEPT {
    610  return ++index, *this;
    611  }
    612 
    613  Iterator operator--(int) ENTT_NOEXCEPT {
    614  Iterator orig = *this;
    615  return --(*this), orig;
    616  }
    617 
    618  Iterator & operator+=(const difference_type value) ENTT_NOEXCEPT {
    619  index -= value;
    620  return *this;
    621  }
    622 
    623  Iterator operator+(const difference_type value) const ENTT_NOEXCEPT {
    624  return Iterator{instances, index-value};
    625  }
    626 
    627  inline Iterator & operator-=(const difference_type value) ENTT_NOEXCEPT {
    628  return (*this += -value);
    629  }
    630 
    631  inline Iterator operator-(const difference_type value) const ENTT_NOEXCEPT {
    632  return (*this + -value);
    633  }
    634 
    635  difference_type operator-(const Iterator &other) const ENTT_NOEXCEPT {
    636  return other.index - index;
    637  }
    638 
    639  reference operator[](const difference_type value) const ENTT_NOEXCEPT {
    640  return (*instances)[index-value-1];
    641  }
    642 
    643  bool operator==(const Iterator &other) const ENTT_NOEXCEPT {
    644  return other.index == index;
    645  }
    646 
    647  inline bool operator!=(const Iterator &other) const ENTT_NOEXCEPT {
    648  return !(*this == other);
    649  }
    650 
    651  bool operator<(const Iterator &other) const ENTT_NOEXCEPT {
    652  return index > other.index;
    653  }
    654 
    655  bool operator>(const Iterator &other) const ENTT_NOEXCEPT {
    656  return index < other.index;
    657  }
    658 
    659  inline bool operator<=(const Iterator &other) const ENTT_NOEXCEPT {
    660  return !(*this > other);
    661  }
    662 
    663  inline bool operator>=(const Iterator &other) const ENTT_NOEXCEPT {
    664  return !(*this < other);
    665  }
    666 
    667  pointer operator->() const ENTT_NOEXCEPT {
    668  return &(*instances)[index-1];
    669  }
    670 
    671  inline reference operator*() const ENTT_NOEXCEPT {
    672  return *operator->();
    673  }
    674 
    675  private:
    676  instance_type *instances;
    677  index_type index;
    678  };
    679 
    680 public:
    682  using object_type = Type;
    684  using entity_type = typename underlying_type::entity_type;
    686  using size_type = typename underlying_type::size_type;
    688  using iterator_type = Iterator<false>;
    690  using const_iterator_type = Iterator<true>;
    691 
    693  SparseSet() ENTT_NOEXCEPT = default;
    694 
    696  SparseSet(const SparseSet &) = delete;
    698  SparseSet(SparseSet &&) = default;
    699 
    701  SparseSet & operator=(const SparseSet &) = delete;
    703  SparseSet & operator=(SparseSet &&) = default;
    704 
    713  void reserve(const size_type cap) {
    714  underlying_type::reserve(cap);
    715  instances.reserve(cap);
    716  }
    717 
    733  const object_type * raw() const ENTT_NOEXCEPT {
    734  return instances.data();
    735  }
    736 
    752  object_type * raw() ENTT_NOEXCEPT {
    753  return instances.data();
    754  }
    755 
    768  const_iterator_type cbegin() const ENTT_NOEXCEPT {
    769  const typename traits_type::difference_type pos = instances.size();
    770  return const_iterator_type{&instances, pos};
    771  }
    772 
    785  inline const_iterator_type begin() const ENTT_NOEXCEPT {
    786  return cbegin();
    787  }
    788 
    801  iterator_type begin() ENTT_NOEXCEPT {
    802  const typename traits_type::difference_type pos = instances.size();
    803  return iterator_type{&instances, pos};
    804  }
    805 
    820  const_iterator_type cend() const ENTT_NOEXCEPT {
    821  return const_iterator_type{&instances, {}};
    822  }
    823 
    838  inline const_iterator_type end() const ENTT_NOEXCEPT {
    839  return cend();
    840  }
    841 
    856  iterator_type end() ENTT_NOEXCEPT {
    857  return iterator_type{&instances, {}};
    858  }
    859 
    865  inline const object_type & operator[](const size_type pos) const ENTT_NOEXCEPT {
    866  return cbegin()[pos];
    867  }
    868 
    874  inline object_type & operator[](const size_type pos) ENTT_NOEXCEPT {
    875  return const_cast<object_type &>(const_cast<const SparseSet *>(this)->operator[](pos));
    876  }
    877 
    890  const object_type & get(const entity_type entity) const ENTT_NOEXCEPT {
    891  return instances[underlying_type::get(entity)];
    892  }
    893 
    906  inline object_type & get(const entity_type entity) ENTT_NOEXCEPT {
    907  return const_cast<object_type &>(const_cast<const SparseSet *>(this)->get(entity));
    908  }
    909 
    930  template<typename... Args>
    931  std::enable_if_t<std::is_constructible<Type, Args...>::value, object_type &>
    932  construct(const entity_type entity, Args &&... args) {
    933  underlying_type::construct(entity);
    934  instances.emplace_back(std::forward<Args>(args)...);
    935  return instances.back();
    936  }
    937 
    958  template<typename... Args>
    959  std::enable_if_t<!std::is_constructible<Type, Args...>::value, object_type &>
    960  construct(const entity_type entity, Args &&... args) {
    961  underlying_type::construct(entity);
    962  instances.emplace_back(Type{std::forward<Args>(args)...});
    963  return instances.back();
    964  }
    965 
    977  void destroy(const entity_type entity) override {
    978  // swapping isn't required here, we are getting rid of the last element
    979  // however, we must protect ourselves from self assignments (see #37)
    980  auto tmp = std::move(instances.back());
    981  instances[underlying_type::get(entity)] = std::move(tmp);
    982  instances.pop_back();
    983  underlying_type::destroy(entity);
    984  }
    985 
    1027  template<typename Compare, typename Sort = StdSort, typename... Args>
    1028  void sort(Compare compare, Sort sort = Sort{}, Args &&... args) {
    1029  std::vector<size_type> copy(instances.size());
    1030  std::iota(copy.begin(), copy.end(), 0);
    1031 
    1032  sort(copy.begin(), copy.end(), [this, compare = std::move(compare)](const auto lhs, const auto rhs) {
    1033  return compare(const_cast<const object_type &>(instances[rhs]), const_cast<const object_type &>(instances[lhs]));
    1034  }, std::forward<Args>(args)...);
    1035 
    1036  for(size_type pos = 0, last = copy.size(); pos < last; ++pos) {
    1037  auto curr = pos;
    1038  auto next = copy[curr];
    1039 
    1040  while(curr != next) {
    1041  const auto lhs = copy[curr];
    1042  const auto rhs = copy[next];
    1043  std::swap(instances[lhs], instances[rhs]);
    1044  underlying_type::swap(lhs, rhs);
    1045  copy[curr] = curr;
    1046  curr = next;
    1047  next = copy[curr];
    1048  }
    1049  }
    1050  }
    1051 
    1075  void respect(const SparseSet<Entity> &other) ENTT_NOEXCEPT {
    1076  auto from = other.cbegin();
    1077  auto to = other.cend();
    1078 
    1079  size_type pos = underlying_type::size() - 1;
    1080  const auto *local = underlying_type::data();
    1081 
    1082  while(pos && from != to) {
    1083  const auto curr = *from;
    1084 
    1085  if(underlying_type::has(curr)) {
    1086  if(curr != *(local + pos)) {
    1087  auto candidate = underlying_type::get(curr);
    1088  std::swap(instances[pos], instances[candidate]);
    1089  underlying_type::swap(pos, candidate);
    1090  }
    1091 
    1092  --pos;
    1093  }
    1094 
    1095  ++from;
    1096  }
    1097  }
    1098 
    1102  void reset() override {
    1103  underlying_type::reset();
    1104  instances.clear();
    1105  }
    1106 
    1107 private:
    1108  std::vector<object_type> instances;
    1109 };
    1110 
    1111 
    1112 }
    1113 
    1114 
    1115 #endif // ENTT_ENTITY_SPARSE_SET_HPP
    entt::SparseSet< Entity >::swap
    void swap(const size_type lhs, const size_type rhs) ENTT_NOEXCEPT
    Swaps the position of two entities in the internal packed array.
    Definition: sparse_set.hpp:489
    entt::operator!=
    constexpr bool operator!=(const HashedString &lhs, const HashedString &rhs) ENTT_NOEXCEPT
    Compares two hashed strings.
    Definition: hashed_string.hpp:103
    entt::SparseSet< Entity, Type >::cbegin
    const_iterator_type cbegin() const ENTT_NOEXCEPT
    Returns an iterator to the beginning.
    Definition: sparse_set.hpp:768
    entt::SparseSet< Entity >::capacity
    size_type capacity() const ENTT_NOEXCEPT
    Returns the number of elements that a sparse set has currently allocated space for.
    Definition: sparse_set.hpp:208
    diff --git a/structentt_1_1Actor-members.html b/structentt_1_1Actor-members.html index a75e3d207..07d3135de 100644 --- a/structentt_1_1Actor-members.html +++ b/structentt_1_1Actor-members.html @@ -5,7 +5,7 @@ -entt: Member List +EnTT: Member List @@ -21,8 +21,8 @@ -
    entt -  2.7.1 +
    EnTT +  2.7.2
    diff --git a/structentt_1_1Actor.html b/structentt_1_1Actor.html index b714a7cee..47aaded7c 100644 --- a/structentt_1_1Actor.html +++ b/structentt_1_1Actor.html @@ -5,7 +5,7 @@ -entt: entt::Actor< Entity > Struct Template Reference +EnTT: entt::Actor< Entity > Struct Template Reference @@ -21,8 +21,8 @@ -
    entt -  2.7.1 +
    EnTT +  2.7.2
    diff --git a/structentt_1_1Emitter_1_1Connection-members.html b/structentt_1_1Emitter_1_1Connection-members.html index 9750de729..a438c7335 100644 --- a/structentt_1_1Emitter_1_1Connection-members.html +++ b/structentt_1_1Emitter_1_1Connection-members.html @@ -5,7 +5,7 @@ -entt: Member List +EnTT: Member List @@ -21,8 +21,8 @@ -
    entt -  2.7.1 +
    EnTT +  2.7.2
    diff --git a/structentt_1_1Emitter_1_1Connection.html b/structentt_1_1Emitter_1_1Connection.html index 7c254778a..5e0876687 100644 --- a/structentt_1_1Emitter_1_1Connection.html +++ b/structentt_1_1Emitter_1_1Connection.html @@ -5,7 +5,7 @@ -entt: entt::Emitter< Derived >::Connection< Event > Struct Template Reference +EnTT: entt::Emitter< Derived >::Connection< Event > Struct Template Reference @@ -21,8 +21,8 @@ -
    entt -  2.7.1 +
    EnTT +  2.7.2
    @@ -80,15 +80,11 @@ $(function() { Inheritance diagram for entt::Emitter< Derived >::Connection< Event >:
    Inheritance graph
    - -
    [legend]
    Collaboration diagram for entt::Emitter< Derived >::Connection< Event >:
    Collaboration graph
    - -
    [legend]
    diff --git a/structentt_1_1InsertionSort.html b/structentt_1_1InsertionSort.html index 49d59782d..a2466eba4 100644 --- a/structentt_1_1InsertionSort.html +++ b/structentt_1_1InsertionSort.html @@ -5,7 +5,7 @@ -entt: entt::InsertionSort Struct Reference +EnTT: entt::InsertionSort Struct Reference @@ -21,8 +21,8 @@ @@ -67,7 +67,7 @@ $(function() { Public Member Functions | List of all members
    -
    entt::InsertionSort Struct Reference
    +
    entt::InsertionSort Struct Referencefinal
    @@ -80,7 +80,7 @@ $(function() { Public Member Functions
    - +

    diff --git a/structentt_1_1InsertionSort-members.html b/structentt_1_1InsertionSort-members.html index d52258dc7..16f834ae9 100644 --- a/structentt_1_1InsertionSort-members.html +++ b/structentt_1_1InsertionSort-members.html @@ -5,7 +5,7 @@ -entt: Member List +EnTT: Member List @@ -21,8 +21,8 @@

    -
    entt -  2.7.1 +
    EnTT +  2.7.2
    -
    entt -  2.7.1 +
    EnTT +  2.7.2
    template<typename It , typename Compare = std::less<>>
    void operator() (It first, It last, Compare compare=Compare{}) const
     Sorts the element in a range. More...
     Sorts the elements in a range. More...
     

    Detailed Description

    @@ -130,8 +130,8 @@ template<typename It , typename Compare = std::less<>>
    -

    Sorts the element in a range.

    -

    Sorts the element in a range using the given binary comparison function.

    +

    Sorts the elements in a range.

    +

    Sorts the elements in a range using the given binary comparison function.

    Template Parameters
    diff --git a/structentt_1_1Monostate-members.html b/structentt_1_1Monostate-members.html index 9737221fd..ff7cd0558 100644 --- a/structentt_1_1Monostate-members.html +++ b/structentt_1_1Monostate-members.html @@ -5,7 +5,7 @@ -entt: Member List +EnTT: Member List @@ -21,8 +21,8 @@ diff --git a/structentt_1_1Monostate.html b/structentt_1_1Monostate.html index de39e7dcd..faeb20be2 100644 --- a/structentt_1_1Monostate.html +++ b/structentt_1_1Monostate.html @@ -5,7 +5,7 @@ -entt: entt::Monostate< hash_type > Struct Template Reference +EnTT: entt::Monostate< hash_type > Struct Template Reference @@ -21,8 +21,8 @@ diff --git a/structentt_1_1OneShotBubbleSort-members.html b/structentt_1_1OneShotBubbleSort-members.html new file mode 100644 index 000000000..2ac8806cc --- /dev/null +++ b/structentt_1_1OneShotBubbleSort-members.html @@ -0,0 +1,82 @@ + + + + + + + +EnTT: Member List + + + + + + + + + +
    +
    +
    ItType of random access iterator.
    -
    entt -  2.7.1 +
    EnTT +  2.7.2
    -
    entt -  2.7.1 +
    EnTT +  2.7.2
    + + + + + +
    +
    EnTT +  2.7.2 +
    +
    +
    + + + + + + + + +
    +
    + + +
    + +
    + + +
    +
    +
    +
    entt::OneShotBubbleSort Member List
    +
    +
    + +

    This is the complete list of members for entt::OneShotBubbleSort, including all inherited members.

    + + +
    operator()(It first, It last, Compare compare=Compare{}) constentt::OneShotBubbleSortinline
    + +
    +Generated by   +doxygen + 1.8.13 +
    + + diff --git a/structentt_1_1OneShotBubbleSort.html b/structentt_1_1OneShotBubbleSort.html new file mode 100644 index 000000000..d0f4fdd77 --- /dev/null +++ b/structentt_1_1OneShotBubbleSort.html @@ -0,0 +1,166 @@ + + + + + + + +EnTT: entt::OneShotBubbleSort Struct Reference + + + + + + + + + +
    +
    + + + + + + +
    +
    EnTT +  2.7.2 +
    +
    +
    + + + + + + + + +
    +
    + + +
    + +
    + + +
    +
    +
    +Public Member Functions | +List of all members
    +
    +
    entt::OneShotBubbleSort Struct Referencefinal
    +
    +
    + +

    Function object for performing bubble sort (single iteration). + More...

    + +

    #include <algorithm.hpp>

    + + + + + + +

    +Public Member Functions

    template<typename It , typename Compare = std::less<>>
    void operator() (It first, It last, Compare compare=Compare{}) const
     Tries to sort the elements in a range. More...
     
    +

    Detailed Description

    +

    Function object for performing bubble sort (single iteration).

    + +

    Definition at line 76 of file algorithm.hpp.

    +

    Member Function Documentation

    + +

    ◆ operator()()

    + +
    +
    +
    +template<typename It , typename Compare = std::less<>>
    + + + + + +
    + + + + + + + + + + + + + + + + + + + + + + + + +
    void entt::OneShotBubbleSort::operator() (It first,
    It last,
    Compare compare = Compare{} 
    ) const
    +     		+inline
    +
    + +

    Tries to sort the elements in a range.

    +

    Performs a single iteration to sort the elements in a range using the given binary comparison function. The range may not be completely sorted after running this function.

    +
    Template Parameters
    + + + +
    ItType of random access iterator.
    CompareType of comparison function object.
    +
    +
    +
    Parameters
    + + + + +
    firstAn iterator to the first element of the range to sort.
    lastAn iterator past the last element of the range to sort.
    compareA valid comparison function object.
    +
    +
    + +

    Definition at line 91 of file algorithm.hpp.

    + +
    +
    +
    The documentation for this struct was generated from the following file: +
    + +
    +Generated by   +doxygen + 1.8.13 +
    + + diff --git a/structentt_1_1ProcessAdaptor-members.html b/structentt_1_1ProcessAdaptor-members.html index 128a353c0..9890a3424 100644 --- a/structentt_1_1ProcessAdaptor-members.html +++ b/structentt_1_1ProcessAdaptor-members.html @@ -5,7 +5,7 @@ -entt: Member List +EnTT: Member List @@ -21,8 +21,8 @@ -
    entt -  2.7.1 +
    EnTT +  2.7.2
    diff --git a/structentt_1_1ProcessAdaptor.html b/structentt_1_1ProcessAdaptor.html index 134bd7dc4..6abb6ce32 100644 --- a/structentt_1_1ProcessAdaptor.html +++ b/structentt_1_1ProcessAdaptor.html @@ -5,7 +5,7 @@ -entt: entt::ProcessAdaptor< Func, Delta > Struct Template Reference +EnTT: entt::ProcessAdaptor< Func, Delta > Struct Template Reference @@ -21,8 +21,8 @@ -
    entt -  2.7.1 +
    EnTT +  2.7.2
    diff --git a/structentt_1_1ServiceLocator-members.html b/structentt_1_1ServiceLocator-members.html index 007052290..6354ff149 100644 --- a/structentt_1_1ServiceLocator-members.html +++ b/structentt_1_1ServiceLocator-members.html @@ -5,7 +5,7 @@ -entt: Member List +EnTT: Member List @@ -21,8 +21,8 @@ -
    entt -  2.7.1 +
    EnTT +  2.7.2
    diff --git a/structentt_1_1ServiceLocator.html b/structentt_1_1ServiceLocator.html index 272ead750..faeb7d51b 100644 --- a/structentt_1_1ServiceLocator.html +++ b/structentt_1_1ServiceLocator.html @@ -5,7 +5,7 @@ -entt: entt::ServiceLocator< Service > Struct Template Reference +EnTT: entt::ServiceLocator< Service > Struct Template Reference @@ -21,8 +21,8 @@ -
    entt -  2.7.1 +
    EnTT +  2.7.2
    diff --git a/structentt_1_1StdSort-members.html b/structentt_1_1StdSort-members.html index 9cdd85efd..323ed279e 100644 --- a/structentt_1_1StdSort-members.html +++ b/structentt_1_1StdSort-members.html @@ -5,7 +5,7 @@ -entt: Member List +EnTT: Member List @@ -21,8 +21,8 @@ -
    entt -  2.7.1 +
    EnTT +  2.7.2
    diff --git a/structentt_1_1StdSort.html b/structentt_1_1StdSort.html index 0dc3ae52e..2d3b8d73c 100644 --- a/structentt_1_1StdSort.html +++ b/structentt_1_1StdSort.html @@ -5,7 +5,7 @@ -entt: entt::StdSort Struct Reference +EnTT: entt::StdSort Struct Reference @@ -21,8 +21,8 @@ -
    entt -  2.7.1 +
    EnTT +  2.7.2
    @@ -67,7 +67,7 @@ $(function() { Public Member Functions | List of all members
    -
    entt::StdSort Struct Reference
    +
    entt::StdSort Struct Referencefinal
    @@ -80,7 +80,7 @@ $(function() { Public Member Functions template<typename It , typename Compare = std::less<>, typename... Args> void operator() (It first, It last, Compare compare=Compare{}, Args &&... args) const - Sorts the element in a range. More...
    + Sorts the elements in a range. More...
     

    Detailed Description

    @@ -138,8 +138,8 @@ template<typename It , typename Compare = std::less<>, typename... Arg
    -

    Sorts the element in a range.

    -

    Sorts the element in a range using the given binary comparison function.

    +

    Sorts the elements in a range.

    +

    Sorts the elements in a range using the given binary comparison function.

    Template Parameters
    diff --git a/structentt_1_1break__t.html b/structentt_1_1break__t.html index 6c80df2da..37070d2a8 100644 --- a/structentt_1_1break__t.html +++ b/structentt_1_1break__t.html @@ -5,7 +5,7 @@ -entt: entt::break_t Struct Reference +EnTT: entt::break_t Struct Reference @@ -21,8 +21,8 @@ diff --git a/structentt_1_1entt__traits.html b/structentt_1_1entt__traits.html index 3f11baf86..7f7d6ec2d 100644 --- a/structentt_1_1entt__traits.html +++ b/structentt_1_1entt__traits.html @@ -5,7 +5,7 @@ -entt: entt::entt_traits< typename > Struct Template Reference +EnTT: entt::entt_traits< typename > Struct Template Reference @@ -21,8 +21,8 @@ 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 fa8720d9a..0bb4e219a 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 @@ -5,7 +5,7 @@ -entt: Member List +EnTT: Member List @@ -21,8 +21,8 @@ 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 3f4cea890..5c2e19118 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 @@ -5,7 +5,7 @@ -entt: entt::entt_traits< std::uint16_t > Struct Template Reference +EnTT: entt::entt_traits< std::uint16_t > Struct Template Reference @@ -21,8 +21,8 @@ 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 0994265a5..50e268e12 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 @@ -5,7 +5,7 @@ -entt: Member List +EnTT: Member List @@ -21,8 +21,8 @@ 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 2c36b39bb..5074c782b 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 @@ -5,7 +5,7 @@ -entt: entt::entt_traits< std::uint32_t > Struct Template Reference +EnTT: entt::entt_traits< std::uint32_t > Struct Template Reference @@ -21,8 +21,8 @@ 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 45285cb76..4fe556861 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 @@ -5,7 +5,7 @@ -entt: Member List +EnTT: Member List @@ -21,8 +21,8 @@ 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 d1a99198c..fa852cf26 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 @@ -5,7 +5,7 @@ -entt: entt::entt_traits< std::uint64_t > Struct Template Reference +EnTT: entt::entt_traits< std::uint64_t > Struct Template Reference @@ -21,8 +21,8 @@ diff --git a/structentt_1_1persistent__t.html b/structentt_1_1persistent__t.html index 341e10f02..fae89476a 100644 --- a/structentt_1_1persistent__t.html +++ b/structentt_1_1persistent__t.html @@ -5,7 +5,7 @@ -entt: entt::persistent_t Struct Reference +EnTT: entt::persistent_t Struct Reference @@ -21,8 +21,8 @@ diff --git a/structentt_1_1raw__t.html b/structentt_1_1raw__t.html index 4148b51e6..e81c28ab5 100644 --- a/structentt_1_1raw__t.html +++ b/structentt_1_1raw__t.html @@ -5,7 +5,7 @@ -entt: entt::raw_t Struct Reference +EnTT: entt::raw_t Struct Reference @@ -21,8 +21,8 @@ diff --git a/structentt_1_1tag__t.html b/structentt_1_1tag__t.html index bdd8d9e8b..45fef8025 100644 --- a/structentt_1_1tag__t.html +++ b/structentt_1_1tag__t.html @@ -5,7 +5,7 @@ -entt: entt::tag_t Struct Reference +EnTT: entt::tag_t Struct Reference @@ -21,8 +21,8 @@ diff --git a/utility_8hpp_source.html b/utility_8hpp_source.html index edf017675..6b226d674 100644 --- a/utility_8hpp_source.html +++ b/utility_8hpp_source.html @@ -5,7 +5,7 @@ -entt: src/entt/entity/utility.hpp Source File +EnTT: src/entt/entity/utility.hpp Source File @@ -21,8 +21,8 @@ diff --git a/view_8hpp_source.html b/view_8hpp_source.html index 6d559ef97..9d15778d9 100644 --- a/view_8hpp_source.html +++ b/view_8hpp_source.html @@ -5,7 +5,7 @@ -entt: src/entt/entity/view.hpp Source File +EnTT: src/entt/entity/view.hpp Source File @@ -21,8 +21,8 @@ @@ -67,116 +67,116 @@ $(function() {
    view.hpp
    -
    1 #ifndef ENTT_ENTITY_VIEW_HPP
    2 #define ENTT_ENTITY_VIEW_HPP
    3 
    4 
    5 #include <iterator>
    6 #include <cassert>
    7 #include <array>
    8 #include <tuple>
    9 #include <vector>
    10 #include <utility>
    11 #include <algorithm>
    12 #include <type_traits>
    13 #include "../config/config.h"
    14 #include "entt_traits.hpp"
    15 #include "sparse_set.hpp"
    16 
    17 
    18 namespace entt {
    19 
    20 
    24 template<typename>
    25 class Registry;
    26 
    27 
    70 template<typename Entity, typename... Component>
    71 class PersistentView final {
    72  static_assert(sizeof...(Component) > 1, "!");
    73 
    75  friend class Registry<Entity>;
    76 
    77  template<typename Comp>
    78  using pool_type = SparseSet<Entity, Comp>;
    79 
    80  using view_type = SparseSet<Entity>;
    81  using pattern_type = std::tuple<pool_type<Component> &...>;
    82 
    83  PersistentView(view_type &view, pool_type<Component> &... pools) ENTT_NOEXCEPT
    84  : view{view}, pools{pools...}
    85  {}
    86 
    87 public:
    89  using entity_type = typename view_type::entity_type;
    91  using size_type = typename view_type::size_type;
    93  using iterator_type = typename view_type::iterator_type;
    95  using const_iterator_type = typename view_type::const_iterator_type;
    96 
    101  size_type size() const ENTT_NOEXCEPT {
    102  return view.size();
    103  }
    104 
    109  bool empty() const ENTT_NOEXCEPT {
    110  return view.empty();
    111  }
    112 
    125  const entity_type * data() const ENTT_NOEXCEPT {
    126  return view.data();
    127  }
    128 
    143  const_iterator_type cbegin() const ENTT_NOEXCEPT {
    144  return view.cbegin();
    145  }
    146 
    161  inline const_iterator_type begin() const ENTT_NOEXCEPT {
    162  return cbegin();
    163  }
    164 
    179  iterator_type begin() ENTT_NOEXCEPT {
    180  return view.begin();
    181  }
    182 
    198  const_iterator_type cend() const ENTT_NOEXCEPT {
    199  return view.cend();
    200  }
    201 
    217  inline const_iterator_type end() const ENTT_NOEXCEPT {
    218  return cend();
    219  }
    220 
    236  iterator_type end() ENTT_NOEXCEPT {
    237  return view.end();
    238  }
    239 
    245  const entity_type & operator[](const size_type pos) const ENTT_NOEXCEPT {
    246  return view[pos];
    247  }
    248 
    254  bool contains(const entity_type entity) const ENTT_NOEXCEPT {
    255  return view.has(entity) && (view.data()[view.get(entity)] == entity);
    256  }
    257 
    275  template<typename Comp>
    276  const Comp & get(const entity_type entity) const ENTT_NOEXCEPT {
    277  assert(contains(entity));
    278  return std::get<pool_type<Comp> &>(pools).get(entity);
    279  }
    280 
    298  template<typename Comp>
    299  inline Comp & get(const entity_type entity) ENTT_NOEXCEPT {
    300  return const_cast<Comp &>(const_cast<const PersistentView *>(this)->get<Comp>(entity));
    301  }
    302 
    320  template<typename... Comp>
    321  inline std::enable_if_t<(sizeof...(Comp) > 1), std::tuple<const Comp &...>>
    322  get(const entity_type entity) const ENTT_NOEXCEPT {
    323  assert(contains(entity));
    324  return std::tuple<const Comp &...>{get<Comp>(entity)...};
    325  }
    326 
    344  template<typename... Comp>
    345  inline std::enable_if_t<(sizeof...(Comp) > 1), std::tuple<Comp &...>>
    346  get(const entity_type entity) ENTT_NOEXCEPT {
    347  assert(contains(entity));
    348  return std::tuple<Comp &...>{get<Comp>(entity)...};
    349  }
    350 
    367  template<typename Func>
    368  void each(Func func) const {
    369  std::for_each(view.cbegin(), view.cend(), [&func, this](const auto entity) {
    370  func(entity, std::get<pool_type<Component> &>(pools).get(entity)...);
    371  });
    372  }
    373 
    390  template<typename Func>
    391  inline void each(Func func) {
    392  const_cast<const PersistentView *>(this)->each([&func](const entity_type entity, const Component &... component) {
    393  func(entity, const_cast<Component &>(component)...);
    394  });
    395  }
    396 
    413  template<typename Comp>
    414  void sort() {
    415  view.respect(std::get<pool_type<Comp> &>(pools));
    416  }
    417 
    418 private:
    419  view_type &view;
    420  const pattern_type pools;
    421 };
    422 
    423 
    465 template<typename Entity, typename... Component>
    466 class View final {
    467  static_assert(sizeof...(Component) > 1, "!");
    468 
    470  friend class Registry<Entity>;
    471 
    472  template<typename Comp>
    473  using pool_type = SparseSet<Entity, Comp>;
    474 
    475  template<typename Comp>
    476  using component_iterator_type = typename pool_type<Comp>::const_iterator_type;
    477 
    478  using view_type = SparseSet<Entity>;
    479  using underlying_iterator_type = typename view_type::const_iterator_type;
    480  using unchecked_type = std::array<const view_type *, (sizeof...(Component) - 1)>;
    481  using pattern_type = std::tuple<pool_type<Component> &...>;
    482  using traits_type = entt_traits<Entity>;
    483 
    484  class Iterator {
    485  friend class View<Entity, Component...>;
    486 
    487  using extent_type = typename view_type::size_type;
    488 
    489  Iterator(unchecked_type unchecked, underlying_iterator_type begin, underlying_iterator_type end) ENTT_NOEXCEPT
    490  : unchecked{unchecked},
    491  begin{begin},
    492  end{end},
    493  extent{min(std::make_index_sequence<unchecked.size()>{})}
    494  {
    495  if(begin != end && !valid()) {
    496  ++(*this);
    497  }
    498  }
    499 
    500  template<std::size_t... Indexes>
    501  extent_type min(std::index_sequence<Indexes...>) const ENTT_NOEXCEPT {
    502  return std::min({ std::get<Indexes>(unchecked)->extent()... });
    503  }
    504 
    505  bool valid() const ENTT_NOEXCEPT {
    506  const auto entity = *begin;
    507  const auto sz = size_type(entity & traits_type::entity_mask);
    508 
    509  return sz < extent && std::all_of(unchecked.cbegin(), unchecked.cend(), [entity](const view_type *view) {
    510  return view->fast(entity);
    511  });
    512  }
    513 
    514  public:
    515  using difference_type = typename underlying_iterator_type::difference_type;
    516  using value_type = typename underlying_iterator_type::value_type;
    517  using pointer = typename underlying_iterator_type::pointer;
    518  using reference = typename underlying_iterator_type::reference;
    519  using iterator_category = std::forward_iterator_tag;
    520 
    521  Iterator() ENTT_NOEXCEPT = default;
    522 
    523  Iterator(const Iterator &) ENTT_NOEXCEPT = default;
    524  Iterator & operator=(const Iterator &) ENTT_NOEXCEPT = default;
    525 
    526  Iterator & operator++() ENTT_NOEXCEPT {
    527  return (++begin != end && !valid()) ? ++(*this) : *this;
    528  }
    529 
    530  Iterator operator++(int) ENTT_NOEXCEPT {
    531  Iterator orig = *this;
    532  return ++(*this), orig;
    533  }
    534 
    535  bool operator==(const Iterator &other) const ENTT_NOEXCEPT {
    536  return other.begin == begin;
    537  }
    538 
    539  inline bool operator!=(const Iterator &other) const ENTT_NOEXCEPT {
    540  return !(*this == other);
    541  }
    542 
    543  pointer operator->() const ENTT_NOEXCEPT {
    544  return begin.operator->();
    545  }
    546 
    547  inline reference operator*() const ENTT_NOEXCEPT {
    548  return *operator->();
    549  }
    550 
    551  private:
    552  unchecked_type unchecked;
    553  underlying_iterator_type begin;
    554  underlying_iterator_type end;
    555  extent_type extent;
    556  };
    557 
    558  View(pool_type<Component> &... pools) ENTT_NOEXCEPT
    559  : pools{pools...}
    560  {}
    561 
    562  template<typename Comp>
    563  const pool_type<Comp> & pool() const ENTT_NOEXCEPT {
    564  return std::get<pool_type<Comp> &>(pools);
    565  }
    566 
    567  const view_type * candidate() const ENTT_NOEXCEPT {
    568  return std::min({ static_cast<const view_type *>(&pool<Component>())... }, [](const auto *lhs, const auto *rhs) {
    569  return lhs->size() < rhs->size();
    570  });
    571  }
    572 
    573  unchecked_type unchecked(const view_type *view) const ENTT_NOEXCEPT {
    574  unchecked_type other{};
    575  std::size_t pos{};
    576  using accumulator_type = const view_type *[];
    577  accumulator_type accumulator = { (&pool<Component>() == view ? view : other[pos++] = &pool<Component>())... };
    578  (void)accumulator;
    579  return other;
    580  }
    581 
    582  template<typename Comp, typename Other>
    583  inline std::enable_if_t<std::is_same<Comp, Other>::value, const Other &>
    584  get(const component_iterator_type<Comp> &it, const Entity) const ENTT_NOEXCEPT { return *it; }
    585 
    586  template<typename Comp, typename Other>
    587  inline std::enable_if_t<!std::is_same<Comp, Other>::value, const Other &>
    588  get(const component_iterator_type<Comp> &, const Entity entity) const ENTT_NOEXCEPT { return pool<Other>().get(entity); }
    589 
    590  template<typename Comp, typename Func, std::size_t... Indexes>
    591  void each(const pool_type<Comp> &cpool, Func func, std::index_sequence<Indexes...>) const {
    592  const auto other = unchecked(&cpool);
    593  std::array<underlying_iterator_type, sizeof...(Component)> data{{cpool.view_type::cbegin(), std::get<Indexes>(other)->cbegin()...}};
    594  auto raw = std::make_tuple(pool<Component>().cbegin()...);
    595  const auto end = cpool.view_type::cend();
    596  std::size_t pos{};
    597 
    598  // we can directly use the raw iterators if pools are ordered
    599  while(!pos && data[0] != end) {
    600  for(pos = data.size() - 1; pos && *(data[pos]++) == *data[pos-1]; --pos);
    601 
    602  if(!pos) {
    603  func(*(data[0]++), *(std::get<component_iterator_type<Component>>(raw)++)...);
    604  }
    605  }
    606 
    607  const auto extent = std::min({ pool<Component>().extent()... });
    608  auto it = std::get<component_iterator_type<Comp>>(raw);
    609 
    610  // fallback to visit what remains using indirections
    611  for(; data[0] != end; ++data[0], ++it) {
    612  const auto entity = *data[0];
    613  const auto sz = size_type(entity & traits_type::entity_mask);
    614 
    615  if(sz < extent && std::all_of(other.cbegin(), other.cend(), [entity](const view_type *view) { return view->fast(entity); })) {
    616  // avoided at least the indirection due to the sparse set for the pivot type (see get for more details)
    617  func(entity, get<Comp, Component>(it, entity)...);
    618  }
    619  }
    620  }
    621 
    622 public:
    624  using entity_type = typename view_type::entity_type;
    626  using size_type = typename view_type::size_type;
    628  using iterator_type = Iterator;
    630  using const_iterator_type = Iterator;
    631 
    636  size_type size() const ENTT_NOEXCEPT {
    637  return std::min({ pool<Component>().size()... });
    638  }
    639 
    644  bool empty() const ENTT_NOEXCEPT {
    645  return std::max({ pool<Component>().empty()... });
    646  }
    647 
    662  const_iterator_type cbegin() const ENTT_NOEXCEPT {
    663  const auto *view = candidate();
    664  return const_iterator_type{unchecked(view), view->cbegin(), view->cend()};
    665  }
    666 
    681  inline const_iterator_type begin() const ENTT_NOEXCEPT {
    682  return cbegin();
    683  }
    684 
    699  inline iterator_type begin() ENTT_NOEXCEPT {
    700  return cbegin();
    701  }
    702 
    718  const_iterator_type cend() const ENTT_NOEXCEPT {
    719  const auto *view = candidate();
    720  return const_iterator_type{unchecked(view), view->cend(), view->cend()};
    721  }
    722 
    738  inline const_iterator_type end() const ENTT_NOEXCEPT {
    739  return cend();
    740  }
    741 
    757  inline iterator_type end() ENTT_NOEXCEPT {
    758  return cend();
    759  }
    760 
    766  bool contains(const entity_type entity) const ENTT_NOEXCEPT {
    767  const auto sz = size_type(entity & traits_type::entity_mask);
    768  const auto extent = std::min({ pool<Component>().extent()... });
    769  return sz < extent && std::min({ (pool<Component>().has(entity) && (pool<Component>().data()[pool<Component>().view_type::get(entity)] == entity))... });
    770  }
    771 
    789  template<typename Comp>
    790  const Comp & get(const entity_type entity) const ENTT_NOEXCEPT {
    791  assert(contains(entity));
    792  return pool<Comp>().get(entity);
    793  }
    794 
    812  template<typename Comp>
    813  inline Comp & get(const entity_type entity) ENTT_NOEXCEPT {
    814  return const_cast<Comp &>(const_cast<const View *>(this)->get<Comp>(entity));
    815  }
    816 
    834  template<typename... Comp>
    835  inline std::enable_if_t<(sizeof...(Comp) > 1), std::tuple<const Comp &...>>
    836  get(const entity_type entity) const ENTT_NOEXCEPT {
    837  assert(contains(entity));
    838  return std::tuple<const Comp &...>{get<Comp>(entity)...};
    839  }
    840 
    858  template<typename... Comp>
    859  inline std::enable_if_t<(sizeof...(Comp) > 1), std::tuple<Comp &...>>
    860  get(const entity_type entity) ENTT_NOEXCEPT {
    861  assert(contains(entity));
    862  return std::tuple<Comp &...>{get<Comp>(entity)...};
    863  }
    864 
    881  template<typename Func>
    882  void each(Func func) const {
    883  const auto *view = candidate();
    884  using accumulator_type = int[];
    885  accumulator_type accumulator = { (&pool<Component>() == view ? (each(pool<Component>(), std::move(func), std::make_index_sequence<sizeof...(Component)-1>{}), 0) : 0)... };
    886  (void)accumulator;
    887  }
    888 
    905  template<typename Func>
    906  inline void each(Func func) {
    907  const_cast<const View *>(this)->each([&func](const entity_type entity, const Component &... component) {
    908  func(entity, const_cast<Component &>(component)...);
    909  });
    910  }
    911 
    912 private:
    913  const pattern_type pools;
    914 };
    915 
    916 
    955 template<typename Entity, typename Component>
    956 class View<Entity, Component> final {
    958  friend class Registry<Entity>;
    959 
    960  using view_type = SparseSet<Entity>;
    961  using pool_type = SparseSet<Entity, Component>;
    962 
    963  View(pool_type &pool) ENTT_NOEXCEPT
    964  : pool{pool}
    965  {}
    966 
    967 public:
    969  using raw_type = typename pool_type::object_type;
    971  using entity_type = typename pool_type::entity_type;
    973  using size_type = typename pool_type::size_type;
    975  using iterator_type = typename view_type::iterator_type;
    977  using const_iterator_type = typename view_type::const_iterator_type;
    978 
    983  size_type size() const ENTT_NOEXCEPT {
    984  return pool.size();
    985  }
    986 
    991  bool empty() const ENTT_NOEXCEPT {
    992  return pool.empty();
    993  }
    994 
    1007  const raw_type * raw() const ENTT_NOEXCEPT {
    1008  return pool.raw();
    1009  }
    1010 
    1023  inline raw_type * raw() ENTT_NOEXCEPT {
    1024  return const_cast<raw_type *>(const_cast<const View *>(this)->raw());
    1025  }
    1026 
    1039  const entity_type * data() const ENTT_NOEXCEPT {
    1040  return pool.data();
    1041  }
    1042 
    1057  const_iterator_type cbegin() const ENTT_NOEXCEPT {
    1058  return pool.view_type::cbegin();
    1059  }
    1060 
    1075  inline const_iterator_type begin() const ENTT_NOEXCEPT {
    1076  return cbegin();
    1077  }
    1078 
    1093  iterator_type begin() ENTT_NOEXCEPT {
    1094  return pool.view_type::begin();
    1095  }
    1096 
    1112  const_iterator_type cend() const ENTT_NOEXCEPT {
    1113  return pool.view_type::cend();
    1114  }
    1115 
    1131  inline const_iterator_type end() const ENTT_NOEXCEPT {
    1132  return cend();
    1133  }
    1134 
    1150  iterator_type end() ENTT_NOEXCEPT {
    1151  return pool.view_type::end();
    1152  }
    1153 
    1159  const entity_type & operator[](const size_type pos) const ENTT_NOEXCEPT {
    1160  return pool.view_type::operator[](pos);
    1161  }
    1162 
    1168  bool contains(const entity_type entity) const ENTT_NOEXCEPT {
    1169  return pool.has(entity) && (pool.data()[pool.view_type::get(entity)] == entity);
    1170  }
    1171 
    1187  const Component & get(const entity_type entity) const ENTT_NOEXCEPT {
    1188  assert(contains(entity));
    1189  return pool.get(entity);
    1190  }
    1191 
    1207  inline Component & get(const entity_type entity) ENTT_NOEXCEPT {
    1208  return const_cast<Component &>(const_cast<const View *>(this)->get(entity));
    1209  }
    1210 
    1226  template<typename Func>
    1227  void each(Func func) const {
    1228  std::for_each(pool.view_type::cbegin(), pool.view_type::cend(), [&func, raw = pool.cbegin()](const auto entity) mutable {
    1229  func(entity, *(raw++));
    1230  });
    1231  }
    1232 
    1248  template<typename Func>
    1249  inline void each(Func func) {
    1250  const_cast<const View *>(this)->each([&func](const entity_type entity, const Component &component) {
    1251  func(entity, const_cast<Component &>(component));
    1252  });
    1253  }
    1254 
    1255 private:
    1256  pool_type &pool;
    1257 };
    1258 
    1259 
    1299 template<typename Entity, typename Component>
    1300 class RawView final {
    1302  friend class Registry<Entity>;
    1303 
    1304  using pool_type = SparseSet<Entity, Component>;
    1305 
    1306  RawView(pool_type &pool) ENTT_NOEXCEPT
    1307  : pool{pool}
    1308  {}
    1309 
    1310 public:
    1312  using raw_type = typename pool_type::object_type;
    1314  using entity_type = typename pool_type::entity_type;
    1316  using size_type = typename pool_type::size_type;
    1318  using iterator_type = typename pool_type::iterator_type;
    1320  using const_iterator_type = typename pool_type::const_iterator_type;
    1321 
    1326  size_type size() const ENTT_NOEXCEPT {
    1327  return pool.size();
    1328  }
    1329 
    1334  bool empty() const ENTT_NOEXCEPT {
    1335  return pool.empty();
    1336  }
    1337 
    1350  const raw_type * raw() const ENTT_NOEXCEPT {
    1351  return pool.raw();
    1352  }
    1353 
    1366  inline raw_type * raw() ENTT_NOEXCEPT {
    1367  return const_cast<raw_type *>(const_cast<const RawView *>(this)->raw());
    1368  }
    1369 
    1382  const entity_type * data() const ENTT_NOEXCEPT {
    1383  return pool.data();
    1384  }
    1385 
    1398  const_iterator_type cbegin() const ENTT_NOEXCEPT {
    1399  return pool.cbegin();
    1400  }
    1401 
    1414  inline const_iterator_type begin() const ENTT_NOEXCEPT {
    1415  return cbegin();
    1416  }
    1417 
    1430  iterator_type begin() ENTT_NOEXCEPT {
    1431  return pool.begin();
    1432  }
    1433 
    1449  const_iterator_type cend() const ENTT_NOEXCEPT {
    1450  return pool.cend();
    1451  }
    1452 
    1468  inline const_iterator_type end() const ENTT_NOEXCEPT {
    1469  return cend();
    1470  }
    1471 
    1487  iterator_type end() ENTT_NOEXCEPT {
    1488  return pool.end();
    1489  }
    1490 
    1496  const raw_type & operator[](const size_type pos) const ENTT_NOEXCEPT {
    1497  return pool[pos];
    1498  }
    1499 
    1505  inline raw_type & operator[](const size_type pos) ENTT_NOEXCEPT {
    1506  return const_cast<raw_type &>(const_cast<const RawView *>(this)->operator[](pos));
    1507  }
    1508 
    1523  template<typename Func>
    1524  void each(Func func) const {
    1525  std::for_each(pool.cbegin(), pool.cend(), func);
    1526  }
    1527 
    1542  template<typename Func>
    1543  void each(Func func) {
    1544  std::for_each(pool.begin(), pool.end(), func);
    1545  }
    1546 
    1547 private:
    1548  pool_type &pool;
    1549 };
    1550 
    1551 
    1594 template<typename Entity>
    1595 class RuntimeView {
    1597  friend class Registry<Entity>;
    1598 
    1599  using view_type = SparseSet<Entity>;
    1600  using underlying_iterator_type = typename view_type::const_iterator_type;
    1601  using pattern_type = std::vector<const view_type *>;
    1602  using extent_type = typename view_type::size_type;
    1603  using traits_type = entt_traits<Entity>;
    1604 
    1605  class Iterator {
    1606  friend class RuntimeView<Entity>;
    1607 
    1608  Iterator(underlying_iterator_type begin, underlying_iterator_type end, const view_type * const *first, const view_type * const *last, extent_type extent) ENTT_NOEXCEPT
    1609  : begin{begin},
    1610  end{end},
    1611  first{first},
    1612  last{last},
    1613  extent{extent}
    1614  {
    1615  if(begin != end && !valid()) {
    1616  ++(*this);
    1617  }
    1618  }
    1619 
    1620  bool valid() const ENTT_NOEXCEPT {
    1621  const auto entity = *begin;
    1622  const auto sz = size_type(entity & traits_type::entity_mask);
    1623 
    1624  return sz < extent && std::all_of(first, last, [entity](const auto *view) {
    1625  return view->fast(entity);
    1626  });
    1627  }
    1628 
    1629  public:
    1630  using difference_type = typename underlying_iterator_type::difference_type;
    1631  using value_type = typename underlying_iterator_type::value_type;
    1632  using pointer = typename underlying_iterator_type::pointer;
    1633  using reference = typename underlying_iterator_type::reference;
    1634  using iterator_category = std::forward_iterator_tag;
    1635 
    1636  Iterator() ENTT_NOEXCEPT = default;
    1637 
    1638  Iterator(const Iterator &) ENTT_NOEXCEPT = default;
    1639  Iterator & operator=(const Iterator &) ENTT_NOEXCEPT = default;
    1640 
    1641  Iterator & operator++() ENTT_NOEXCEPT {
    1642  return (++begin != end && !valid()) ? ++(*this) : *this;
    1643  }
    1644 
    1645  Iterator operator++(int) ENTT_NOEXCEPT {
    1646  Iterator orig = *this;
    1647  return ++(*this), orig;
    1648  }
    1649 
    1650  bool operator==(const Iterator &other) const ENTT_NOEXCEPT {
    1651  return other.begin == begin;
    1652  }
    1653 
    1654  inline bool operator!=(const Iterator &other) const ENTT_NOEXCEPT {
    1655  return !(*this == other);
    1656  }
    1657 
    1658  pointer operator->() const ENTT_NOEXCEPT {
    1659  return begin.operator->();
    1660  }
    1661 
    1662  inline reference operator*() const ENTT_NOEXCEPT {
    1663  return *operator->();
    1664  }
    1665 
    1666  private:
    1667  underlying_iterator_type begin;
    1668  underlying_iterator_type end;
    1669  const view_type * const *first;
    1670  const view_type * const *last;
    1671  extent_type extent;
    1672  };
    1673 
    1674  RuntimeView(pattern_type others) ENTT_NOEXCEPT
    1675  : pools{std::move(others)}
    1676  {
    1677  const auto it = std::min_element(pools.begin(), pools.end(), [](const auto *lhs, const auto *rhs) {
    1678  return (!lhs && rhs) || (lhs && rhs && lhs->size() < rhs->size());
    1679  });
    1680 
    1681  // brings the best candidate (if any) on front of the vector
    1682  std::rotate(pools.begin(), it, pools.end());
    1683  }
    1684 
    1685  extent_type min() const ENTT_NOEXCEPT {
    1686  extent_type extent{};
    1687 
    1688  if(valid()) {
    1689  const auto it = std::min_element(pools.cbegin(), pools.cend(), [](const auto *lhs, const auto *rhs) {
    1690  return lhs->extent() < rhs->extent();
    1691  });
    1692 
    1693  extent = (*it)->extent();
    1694  }
    1695 
    1696  return extent;
    1697  }
    1698 
    1699  inline bool valid() const ENTT_NOEXCEPT {
    1700  return !pools.empty() && pools.front();
    1701  }
    1702 
    1703 public:
    1705  using entity_type = typename view_type::entity_type;
    1707  using size_type = typename view_type::size_type;
    1709  using iterator_type = Iterator;
    1711  using const_iterator_type = Iterator;
    1712 
    1717  size_type size() const ENTT_NOEXCEPT {
    1718  return valid() ? pools.front()->size() : size_type{};
    1719  }
    1720 
    1725  bool empty() const ENTT_NOEXCEPT {
    1726  return !valid() || pools.front()->empty();
    1727  }
    1728 
    1743  const_iterator_type cbegin() const ENTT_NOEXCEPT {
    1744  const_iterator_type it{};
    1745 
    1746  if(valid()) {
    1747  const auto &pool = *pools.front();
    1748  const auto * const *data = pools.data();
    1749  it = { pool.cbegin(), pool.cend(), data + 1, data + pools.size(), min() };
    1750  }
    1751 
    1752  return it;
    1753  }
    1754 
    1769  inline const_iterator_type begin() const ENTT_NOEXCEPT {
    1770  return cbegin();
    1771  }
    1772 
    1787  inline iterator_type begin() ENTT_NOEXCEPT {
    1788  return cbegin();
    1789  }
    1790 
    1806  const_iterator_type cend() const ENTT_NOEXCEPT {
    1807  const_iterator_type it{};
    1808 
    1809  if(valid()) {
    1810  const auto &pool = *pools.front();
    1811  it = { pool.cend(), pool.cend(), nullptr, nullptr, min() };
    1812  }
    1813 
    1814  return it;
    1815  }
    1816 
    1832  inline const_iterator_type end() const ENTT_NOEXCEPT {
    1833  return cend();
    1834  }
    1835 
    1851  inline iterator_type end() ENTT_NOEXCEPT {
    1852  return cend();
    1853  }
    1854 
    1860  bool contains(const entity_type entity) const ENTT_NOEXCEPT {
    1861  return valid() && std::all_of(pools.cbegin(), pools.cend(), [entity](const auto *view) {
    1862  return view->has(entity) && view->data()[view->get(entity)] == entity;
    1863  });
    1864  }
    1865 
    1881  template<typename Func>
    1882  void each(Func func) const {
    1883  std::for_each(cbegin(), cend(), func);
    1884  }
    1885 
    1886 private:
    1887  pattern_type pools;
    1888 };
    1889 
    1890 
    1891 }
    1892 
    1893 
    1894 #endif // ENTT_ENTITY_VIEW_HPP
    entt::RawView::const_iterator_type
    typename pool_type::const_iterator_type const_iterator_type
    Constant input iterator type.
    Definition: view.hpp:1320
    -
    entt::View< Entity, Component >::size_type
    typename pool_type::size_type size_type
    Unsigned integer type.
    Definition: view.hpp:973
    -
    entt::RawView::empty
    bool empty() const ENTT_NOEXCEPT
    Checks whether the view is empty.
    Definition: view.hpp:1334
    +
    1 #ifndef ENTT_ENTITY_VIEW_HPP
    2 #define ENTT_ENTITY_VIEW_HPP
    3 
    4 
    5 #include <iterator>
    6 #include <cassert>
    7 #include <array>
    8 #include <tuple>
    9 #include <vector>
    10 #include <utility>
    11 #include <algorithm>
    12 #include <type_traits>
    13 #include "../config/config.h"
    14 #include "entt_traits.hpp"
    15 #include "sparse_set.hpp"
    16 
    17 
    18 namespace entt {
    19 
    20 
    24 template<typename>
    25 class Registry;
    26 
    27 
    70 template<typename Entity, typename... Component>
    71 class PersistentView final {
    72  static_assert(sizeof...(Component) > 1, "!");
    73 
    75  friend class Registry<Entity>;
    76 
    77  template<typename Comp>
    78  using pool_type = SparseSet<Entity, Comp>;
    79 
    80  using view_type = SparseSet<Entity>;
    81  using pattern_type = std::tuple<pool_type<Component> &...>;
    82 
    83  PersistentView(view_type &view, pool_type<Component> &... pools) ENTT_NOEXCEPT
    84  : view{view}, pools{pools...}
    85  {}
    86 
    87 public:
    89  using entity_type = typename view_type::entity_type;
    91  using size_type = typename view_type::size_type;
    93  using iterator_type = typename view_type::iterator_type;
    95  using const_iterator_type = typename view_type::const_iterator_type;
    96 
    101  size_type size() const ENTT_NOEXCEPT {
    102  return view.size();
    103  }
    104 
    109  bool empty() const ENTT_NOEXCEPT {
    110  return view.empty();
    111  }
    112 
    125  const entity_type * data() const ENTT_NOEXCEPT {
    126  return view.data();
    127  }
    128 
    143  const_iterator_type cbegin() const ENTT_NOEXCEPT {
    144  return view.cbegin();
    145  }
    146 
    161  inline const_iterator_type begin() const ENTT_NOEXCEPT {
    162  return cbegin();
    163  }
    164 
    179  iterator_type begin() ENTT_NOEXCEPT {
    180  return view.begin();
    181  }
    182 
    198  const_iterator_type cend() const ENTT_NOEXCEPT {
    199  return view.cend();
    200  }
    201 
    217  inline const_iterator_type end() const ENTT_NOEXCEPT {
    218  return cend();
    219  }
    220 
    236  iterator_type end() ENTT_NOEXCEPT {
    237  return view.end();
    238  }
    239 
    245  const entity_type & operator[](const size_type pos) const ENTT_NOEXCEPT {
    246  return view[pos];
    247  }
    248 
    254  bool contains(const entity_type entity) const ENTT_NOEXCEPT {
    255  return view.has(entity) && (view.data()[view.get(entity)] == entity);
    256  }
    257 
    275  template<typename Comp>
    276  const Comp & get(const entity_type entity) const ENTT_NOEXCEPT {
    277  assert(contains(entity));
    278  return std::get<pool_type<Comp> &>(pools).get(entity);
    279  }
    280 
    298  template<typename Comp>
    299  inline Comp & get(const entity_type entity) ENTT_NOEXCEPT {
    300  return const_cast<Comp &>(const_cast<const PersistentView *>(this)->get<Comp>(entity));
    301  }
    302 
    320  template<typename... Comp>
    321  inline std::enable_if_t<(sizeof...(Comp) > 1), std::tuple<const Comp &...>>
    322  get(const entity_type entity) const ENTT_NOEXCEPT {
    323  assert(contains(entity));
    324  return std::tuple<const Comp &...>{get<Comp>(entity)...};
    325  }
    326 
    344  template<typename... Comp>
    345  inline std::enable_if_t<(sizeof...(Comp) > 1), std::tuple<Comp &...>>
    346  get(const entity_type entity) ENTT_NOEXCEPT {
    347  assert(contains(entity));
    348  return std::tuple<Comp &...>{get<Comp>(entity)...};
    349  }
    350 
    367  template<typename Func>
    368  void each(Func func) const {
    369  std::for_each(view.cbegin(), view.cend(), [&func, this](const auto entity) {
    370  func(entity, std::get<pool_type<Component> &>(pools).get(entity)...);
    371  });
    372  }
    373 
    390  template<typename Func>
    391  inline void each(Func func) {
    392  const_cast<const PersistentView *>(this)->each([&func](const entity_type entity, const Component &... component) {
    393  func(entity, const_cast<Component &>(component)...);
    394  });
    395  }
    396 
    413  template<typename Comp>
    414  void sort() {
    415  view.respect(std::get<pool_type<Comp> &>(pools));
    416  }
    417 
    418 private:
    419  view_type &view;
    420  const pattern_type pools;
    421 };
    422 
    423 
    465 template<typename Entity, typename... Component>
    466 class View final {
    467  static_assert(sizeof...(Component) > 1, "!");
    468 
    470  friend class Registry<Entity>;
    471 
    472  template<typename Comp>
    473  using pool_type = SparseSet<Entity, Comp>;
    474 
    475  template<typename Comp>
    476  using component_iterator_type = typename pool_type<Comp>::const_iterator_type;
    477 
    478  using view_type = SparseSet<Entity>;
    479  using underlying_iterator_type = typename view_type::const_iterator_type;
    480  using unchecked_type = std::array<const view_type *, (sizeof...(Component) - 1)>;
    481  using pattern_type = std::tuple<pool_type<Component> &...>;
    482  using traits_type = entt_traits<Entity>;
    483 
    484  class Iterator {
    485  friend class View<Entity, Component...>;
    486 
    487  using extent_type = typename view_type::size_type;
    488 
    489  Iterator(unchecked_type unchecked, underlying_iterator_type begin, underlying_iterator_type end) ENTT_NOEXCEPT
    490  : unchecked{unchecked},
    491  begin{begin},
    492  end{end},
    493  extent{min(std::make_index_sequence<unchecked.size()>{})}
    494  {
    495  if(begin != end && !valid()) {
    496  ++(*this);
    497  }
    498  }
    499 
    500  template<std::size_t... Indexes>
    501  extent_type min(std::index_sequence<Indexes...>) const ENTT_NOEXCEPT {
    502  return std::min({ std::get<Indexes>(unchecked)->extent()... });
    503  }
    504 
    505  bool valid() const ENTT_NOEXCEPT {
    506  const auto entity = *begin;
    507  const auto sz = size_type(entity & traits_type::entity_mask);
    508 
    509  return sz < extent && std::all_of(unchecked.cbegin(), unchecked.cend(), [entity](const view_type *view) {
    510  return view->fast(entity);
    511  });
    512  }
    513 
    514  public:
    515  using difference_type = typename underlying_iterator_type::difference_type;
    516  using value_type = typename underlying_iterator_type::value_type;
    517  using pointer = typename underlying_iterator_type::pointer;
    518  using reference = typename underlying_iterator_type::reference;
    519  using iterator_category = std::forward_iterator_tag;
    520 
    521  Iterator() ENTT_NOEXCEPT = default;
    522 
    523  Iterator(const Iterator &) ENTT_NOEXCEPT = default;
    524  Iterator & operator=(const Iterator &) ENTT_NOEXCEPT = default;
    525 
    526  Iterator & operator++() ENTT_NOEXCEPT {
    527  return (++begin != end && !valid()) ? ++(*this) : *this;
    528  }
    529 
    530  Iterator operator++(int) ENTT_NOEXCEPT {
    531  Iterator orig = *this;
    532  return ++(*this), orig;
    533  }
    534 
    535  bool operator==(const Iterator &other) const ENTT_NOEXCEPT {
    536  return other.begin == begin;
    537  }
    538 
    539  inline bool operator!=(const Iterator &other) const ENTT_NOEXCEPT {
    540  return !(*this == other);
    541  }
    542 
    543  pointer operator->() const ENTT_NOEXCEPT {
    544  return begin.operator->();
    545  }
    546 
    547  inline reference operator*() const ENTT_NOEXCEPT {
    548  return *operator->();
    549  }
    550 
    551  private:
    552  unchecked_type unchecked;
    553  underlying_iterator_type begin;
    554  underlying_iterator_type end;
    555  extent_type extent;
    556  };
    557 
    558  View(pool_type<Component> &... pools) ENTT_NOEXCEPT
    559  : pools{pools...}
    560  {}
    561 
    562  template<typename Comp>
    563  const pool_type<Comp> & pool() const ENTT_NOEXCEPT {
    564  return std::get<pool_type<Comp> &>(pools);
    565  }
    566 
    567  const view_type * candidate() const ENTT_NOEXCEPT {
    568  return std::min({ static_cast<const view_type *>(&pool<Component>())... }, [](const auto *lhs, const auto *rhs) {
    569  return lhs->size() < rhs->size();
    570  });
    571  }
    572 
    573  unchecked_type unchecked(const view_type *view) const ENTT_NOEXCEPT {
    574  unchecked_type other{};
    575  std::size_t pos{};
    576  using accumulator_type = const view_type *[];
    577  accumulator_type accumulator = { (&pool<Component>() == view ? view : other[pos++] = &pool<Component>())... };
    578  (void)accumulator;
    579  return other;
    580  }
    581 
    582  template<typename Comp, typename Other>
    583  inline std::enable_if_t<std::is_same<Comp, Other>::value, const Other &>
    584  get(const component_iterator_type<Comp> &it, const Entity) const ENTT_NOEXCEPT { return *it; }
    585 
    586  template<typename Comp, typename Other>
    587  inline std::enable_if_t<!std::is_same<Comp, Other>::value, const Other &>
    588  get(const component_iterator_type<Comp> &, const Entity entity) const ENTT_NOEXCEPT { return pool<Other>().get(entity); }
    589 
    590  template<typename Comp, typename Func, std::size_t... Indexes>
    591  void each(const pool_type<Comp> &cpool, Func func, std::index_sequence<Indexes...>) const {
    592  const auto other = unchecked(&cpool);
    593  std::array<underlying_iterator_type, sizeof...(Indexes)> data{{std::get<Indexes>(other)->cbegin()...}};
    594  const auto extent = std::min({ pool<Component>().extent()... });
    595  auto raw = std::make_tuple(pool<Component>().cbegin()...);
    596  const auto end = cpool.view_type::cend();
    597  auto begin = cpool.view_type::cbegin();
    598 
    599  // we can directly use the raw iterators if pools are ordered
    600  while(begin != end && std::min({ (*(std::get<Indexes>(data)++) == *begin)... })) {
    601  func(*(begin++), *(std::get<component_iterator_type<Component>>(raw)++)...);
    602  }
    603 
    604  // fallback to visit what remains using indirections
    605  while(begin != end) {
    606  const auto entity = *(begin++);
    607  const auto it = std::get<component_iterator_type<Comp>>(raw)++;
    608  const auto sz = size_type(entity & traits_type::entity_mask);
    609 
    610  if(sz < extent && std::all_of(other.cbegin(), other.cend(), [entity](const view_type *view) { return view->fast(entity); })) {
    611  // avoided at least the indirection due to the sparse set for the pivot type (see get for more details)
    612  func(entity, get<Comp, Component>(it, entity)...);
    613  }
    614  }
    615  }
    616 
    617 public:
    619  using entity_type = typename view_type::entity_type;
    621  using size_type = typename view_type::size_type;
    623  using iterator_type = Iterator;
    625  using const_iterator_type = Iterator;
    626 
    631  size_type size() const ENTT_NOEXCEPT {
    632  return std::min({ pool<Component>().size()... });
    633  }
    634 
    639  bool empty() const ENTT_NOEXCEPT {
    640  return std::max({ pool<Component>().empty()... });
    641  }
    642 
    657  const_iterator_type cbegin() const ENTT_NOEXCEPT {
    658  const auto *view = candidate();
    659  return const_iterator_type{unchecked(view), view->cbegin(), view->cend()};
    660  }
    661 
    676  inline const_iterator_type begin() const ENTT_NOEXCEPT {
    677  return cbegin();
    678  }
    679 
    694  inline iterator_type begin() ENTT_NOEXCEPT {
    695  return cbegin();
    696  }
    697 
    713  const_iterator_type cend() const ENTT_NOEXCEPT {
    714  const auto *view = candidate();
    715  return const_iterator_type{unchecked(view), view->cend(), view->cend()};
    716  }
    717 
    733  inline const_iterator_type end() const ENTT_NOEXCEPT {
    734  return cend();
    735  }
    736 
    752  inline iterator_type end() ENTT_NOEXCEPT {
    753  return cend();
    754  }
    755 
    761  bool contains(const entity_type entity) const ENTT_NOEXCEPT {
    762  const auto sz = size_type(entity & traits_type::entity_mask);
    763  const auto extent = std::min({ pool<Component>().extent()... });
    764  return sz < extent && std::min({ (pool<Component>().has(entity) && (pool<Component>().data()[pool<Component>().view_type::get(entity)] == entity))... });
    765  }
    766 
    784  template<typename Comp>
    785  const Comp & get(const entity_type entity) const ENTT_NOEXCEPT {
    786  assert(contains(entity));
    787  return pool<Comp>().get(entity);
    788  }
    789 
    807  template<typename Comp>
    808  inline Comp & get(const entity_type entity) ENTT_NOEXCEPT {
    809  return const_cast<Comp &>(const_cast<const View *>(this)->get<Comp>(entity));
    810  }
    811 
    829  template<typename... Comp>
    830  inline std::enable_if_t<(sizeof...(Comp) > 1), std::tuple<const Comp &...>>
    831  get(const entity_type entity) const ENTT_NOEXCEPT {
    832  assert(contains(entity));
    833  return std::tuple<const Comp &...>{get<Comp>(entity)...};
    834  }
    835 
    853  template<typename... Comp>
    854  inline std::enable_if_t<(sizeof...(Comp) > 1), std::tuple<Comp &...>>
    855  get(const entity_type entity) ENTT_NOEXCEPT {
    856  assert(contains(entity));
    857  return std::tuple<Comp &...>{get<Comp>(entity)...};
    858  }
    859 
    876  template<typename Func>
    877  void each(Func func) const {
    878  const auto *view = candidate();
    879  using accumulator_type = int[];
    880  accumulator_type accumulator = { (&pool<Component>() == view ? (each(pool<Component>(), std::move(func), std::make_index_sequence<sizeof...(Component)-1>{}), 0) : 0)... };
    881  (void)accumulator;
    882  }
    883 
    900  template<typename Func>
    901  inline void each(Func func) {
    902  const_cast<const View *>(this)->each([&func](const entity_type entity, const Component &... component) {
    903  func(entity, const_cast<Component &>(component)...);
    904  });
    905  }
    906 
    907 private:
    908  const pattern_type pools;
    909 };
    910 
    911 
    950 template<typename Entity, typename Component>
    951 class View<Entity, Component> final {
    953  friend class Registry<Entity>;
    954 
    955  using view_type = SparseSet<Entity>;
    956  using pool_type = SparseSet<Entity, Component>;
    957 
    958  View(pool_type &pool) ENTT_NOEXCEPT
    959  : pool{pool}
    960  {}
    961 
    962 public:
    964  using raw_type = typename pool_type::object_type;
    966  using entity_type = typename pool_type::entity_type;
    968  using size_type = typename pool_type::size_type;
    970  using iterator_type = typename view_type::iterator_type;
    972  using const_iterator_type = typename view_type::const_iterator_type;
    973 
    978  size_type size() const ENTT_NOEXCEPT {
    979  return pool.size();
    980  }
    981 
    986  bool empty() const ENTT_NOEXCEPT {
    987  return pool.empty();
    988  }
    989 
    1002  const raw_type * raw() const ENTT_NOEXCEPT {
    1003  return pool.raw();
    1004  }
    1005 
    1018  inline raw_type * raw() ENTT_NOEXCEPT {
    1019  return const_cast<raw_type *>(const_cast<const View *>(this)->raw());
    1020  }
    1021 
    1034  const entity_type * data() const ENTT_NOEXCEPT {
    1035  return pool.data();
    1036  }
    1037 
    1052  const_iterator_type cbegin() const ENTT_NOEXCEPT {
    1053  return pool.view_type::cbegin();
    1054  }
    1055 
    1070  inline const_iterator_type begin() const ENTT_NOEXCEPT {
    1071  return cbegin();
    1072  }
    1073 
    1088  iterator_type begin() ENTT_NOEXCEPT {
    1089  return pool.view_type::begin();
    1090  }
    1091 
    1107  const_iterator_type cend() const ENTT_NOEXCEPT {
    1108  return pool.view_type::cend();
    1109  }
    1110 
    1126  inline const_iterator_type end() const ENTT_NOEXCEPT {
    1127  return cend();
    1128  }
    1129 
    1145  iterator_type end() ENTT_NOEXCEPT {
    1146  return pool.view_type::end();
    1147  }
    1148 
    1154  const entity_type & operator[](const size_type pos) const ENTT_NOEXCEPT {
    1155  return pool.view_type::operator[](pos);
    1156  }
    1157 
    1163  bool contains(const entity_type entity) const ENTT_NOEXCEPT {
    1164  return pool.has(entity) && (pool.data()[pool.view_type::get(entity)] == entity);
    1165  }
    1166 
    1182  const Component & get(const entity_type entity) const ENTT_NOEXCEPT {
    1183  assert(contains(entity));
    1184  return pool.get(entity);
    1185  }
    1186 
    1202  inline Component & get(const entity_type entity) ENTT_NOEXCEPT {
    1203  return const_cast<Component &>(const_cast<const View *>(this)->get(entity));
    1204  }
    1205 
    1221  template<typename Func>
    1222  void each(Func func) const {
    1223  std::for_each(pool.view_type::cbegin(), pool.view_type::cend(), [&func, raw = pool.cbegin()](const auto entity) mutable {
    1224  func(entity, *(raw++));
    1225  });
    1226  }
    1227 
    1243  template<typename Func>
    1244  inline void each(Func func) {
    1245  const_cast<const View *>(this)->each([&func](const entity_type entity, const Component &component) {
    1246  func(entity, const_cast<Component &>(component));
    1247  });
    1248  }
    1249 
    1250 private:
    1251  pool_type &pool;
    1252 };
    1253 
    1254 
    1294 template<typename Entity, typename Component>
    1295 class RawView final {
    1297  friend class Registry<Entity>;
    1298 
    1299  using pool_type = SparseSet<Entity, Component>;
    1300 
    1301  RawView(pool_type &pool) ENTT_NOEXCEPT
    1302  : pool{pool}
    1303  {}
    1304 
    1305 public:
    1307  using raw_type = typename pool_type::object_type;
    1309  using entity_type = typename pool_type::entity_type;
    1311  using size_type = typename pool_type::size_type;
    1313  using iterator_type = typename pool_type::iterator_type;
    1315  using const_iterator_type = typename pool_type::const_iterator_type;
    1316 
    1321  size_type size() const ENTT_NOEXCEPT {
    1322  return pool.size();
    1323  }
    1324 
    1329  bool empty() const ENTT_NOEXCEPT {
    1330  return pool.empty();
    1331  }
    1332 
    1345  const raw_type * raw() const ENTT_NOEXCEPT {
    1346  return pool.raw();
    1347  }
    1348 
    1361  inline raw_type * raw() ENTT_NOEXCEPT {
    1362  return const_cast<raw_type *>(const_cast<const RawView *>(this)->raw());
    1363  }
    1364 
    1377  const entity_type * data() const ENTT_NOEXCEPT {
    1378  return pool.data();
    1379  }
    1380 
    1393  const_iterator_type cbegin() const ENTT_NOEXCEPT {
    1394  return pool.cbegin();
    1395  }
    1396 
    1409  inline const_iterator_type begin() const ENTT_NOEXCEPT {
    1410  return cbegin();
    1411  }
    1412 
    1425  iterator_type begin() ENTT_NOEXCEPT {
    1426  return pool.begin();
    1427  }
    1428 
    1444  const_iterator_type cend() const ENTT_NOEXCEPT {
    1445  return pool.cend();
    1446  }
    1447 
    1463  inline const_iterator_type end() const ENTT_NOEXCEPT {
    1464  return cend();
    1465  }
    1466 
    1482  iterator_type end() ENTT_NOEXCEPT {
    1483  return pool.end();
    1484  }
    1485 
    1491  const raw_type & operator[](const size_type pos) const ENTT_NOEXCEPT {
    1492  return pool[pos];
    1493  }
    1494 
    1500  inline raw_type & operator[](const size_type pos) ENTT_NOEXCEPT {
    1501  return const_cast<raw_type &>(const_cast<const RawView *>(this)->operator[](pos));
    1502  }
    1503 
    1518  template<typename Func>
    1519  void each(Func func) const {
    1520  std::for_each(pool.cbegin(), pool.cend(), func);
    1521  }
    1522 
    1537  template<typename Func>
    1538  void each(Func func) {
    1539  std::for_each(pool.begin(), pool.end(), func);
    1540  }
    1541 
    1542 private:
    1543  pool_type &pool;
    1544 };
    1545 
    1546 
    1589 template<typename Entity>
    1590 class RuntimeView {
    1592  friend class Registry<Entity>;
    1593 
    1594  using view_type = SparseSet<Entity>;
    1595  using underlying_iterator_type = typename view_type::const_iterator_type;
    1596  using pattern_type = std::vector<const view_type *>;
    1597  using extent_type = typename view_type::size_type;
    1598  using traits_type = entt_traits<Entity>;
    1599 
    1600  class Iterator {
    1601  friend class RuntimeView<Entity>;
    1602 
    1603  Iterator(underlying_iterator_type begin, underlying_iterator_type end, const view_type * const *first, const view_type * const *last, extent_type extent) ENTT_NOEXCEPT
    1604  : begin{begin},
    1605  end{end},
    1606  first{first},
    1607  last{last},
    1608  extent{extent}
    1609  {
    1610  if(begin != end && !valid()) {
    1611  ++(*this);
    1612  }
    1613  }
    1614 
    1615  bool valid() const ENTT_NOEXCEPT {
    1616  const auto entity = *begin;
    1617  const auto sz = size_type(entity & traits_type::entity_mask);
    1618 
    1619  return sz < extent && std::all_of(first, last, [entity](const auto *view) {
    1620  return view->fast(entity);
    1621  });
    1622  }
    1623 
    1624  public:
    1625  using difference_type = typename underlying_iterator_type::difference_type;
    1626  using value_type = typename underlying_iterator_type::value_type;
    1627  using pointer = typename underlying_iterator_type::pointer;
    1628  using reference = typename underlying_iterator_type::reference;
    1629  using iterator_category = std::forward_iterator_tag;
    1630 
    1631  Iterator() ENTT_NOEXCEPT = default;
    1632 
    1633  Iterator(const Iterator &) ENTT_NOEXCEPT = default;
    1634  Iterator & operator=(const Iterator &) ENTT_NOEXCEPT = default;
    1635 
    1636  Iterator & operator++() ENTT_NOEXCEPT {
    1637  return (++begin != end && !valid()) ? ++(*this) : *this;
    1638  }
    1639 
    1640  Iterator operator++(int) ENTT_NOEXCEPT {
    1641  Iterator orig = *this;
    1642  return ++(*this), orig;
    1643  }
    1644 
    1645  bool operator==(const Iterator &other) const ENTT_NOEXCEPT {
    1646  return other.begin == begin;
    1647  }
    1648 
    1649  inline bool operator!=(const Iterator &other) const ENTT_NOEXCEPT {
    1650  return !(*this == other);
    1651  }
    1652 
    1653  pointer operator->() const ENTT_NOEXCEPT {
    1654  return begin.operator->();
    1655  }
    1656 
    1657  inline reference operator*() const ENTT_NOEXCEPT {
    1658  return *operator->();
    1659  }
    1660 
    1661  private:
    1662  underlying_iterator_type begin;
    1663  underlying_iterator_type end;
    1664  const view_type * const *first;
    1665  const view_type * const *last;
    1666  extent_type extent;
    1667  };
    1668 
    1669  RuntimeView(pattern_type others) ENTT_NOEXCEPT
    1670  : pools{std::move(others)}
    1671  {
    1672  const auto it = std::min_element(pools.begin(), pools.end(), [](const auto *lhs, const auto *rhs) {
    1673  return (!lhs && rhs) || (lhs && rhs && lhs->size() < rhs->size());
    1674  });
    1675 
    1676  // brings the best candidate (if any) on front of the vector
    1677  std::rotate(pools.begin(), it, pools.end());
    1678  }
    1679 
    1680  extent_type min() const ENTT_NOEXCEPT {
    1681  extent_type extent{};
    1682 
    1683  if(valid()) {
    1684  const auto it = std::min_element(pools.cbegin(), pools.cend(), [](const auto *lhs, const auto *rhs) {
    1685  return lhs->extent() < rhs->extent();
    1686  });
    1687 
    1688  extent = (*it)->extent();
    1689  }
    1690 
    1691  return extent;
    1692  }
    1693 
    1694  inline bool valid() const ENTT_NOEXCEPT {
    1695  return !pools.empty() && pools.front();
    1696  }
    1697 
    1698 public:
    1700  using entity_type = typename view_type::entity_type;
    1702  using size_type = typename view_type::size_type;
    1704  using iterator_type = Iterator;
    1706  using const_iterator_type = Iterator;
    1707 
    1712  size_type size() const ENTT_NOEXCEPT {
    1713  return valid() ? pools.front()->size() : size_type{};
    1714  }
    1715 
    1720  bool empty() const ENTT_NOEXCEPT {
    1721  return !valid() || pools.front()->empty();
    1722  }
    1723 
    1738  const_iterator_type cbegin() const ENTT_NOEXCEPT {
    1739  const_iterator_type it{};
    1740 
    1741  if(valid()) {
    1742  const auto &pool = *pools.front();
    1743  const auto * const *data = pools.data();
    1744  it = { pool.cbegin(), pool.cend(), data + 1, data + pools.size(), min() };
    1745  }
    1746 
    1747  return it;
    1748  }
    1749 
    1764  inline const_iterator_type begin() const ENTT_NOEXCEPT {
    1765  return cbegin();
    1766  }
    1767 
    1782  inline iterator_type begin() ENTT_NOEXCEPT {
    1783  return cbegin();
    1784  }
    1785 
    1801  const_iterator_type cend() const ENTT_NOEXCEPT {
    1802  const_iterator_type it{};
    1803 
    1804  if(valid()) {
    1805  const auto &pool = *pools.front();
    1806  it = { pool.cend(), pool.cend(), nullptr, nullptr, min() };
    1807  }
    1808 
    1809  return it;
    1810  }
    1811 
    1827  inline const_iterator_type end() const ENTT_NOEXCEPT {
    1828  return cend();
    1829  }
    1830 
    1846  inline iterator_type end() ENTT_NOEXCEPT {
    1847  return cend();
    1848  }
    1849 
    1855  bool contains(const entity_type entity) const ENTT_NOEXCEPT {
    1856  return valid() && std::all_of(pools.cbegin(), pools.cend(), [entity](const auto *view) {
    1857  return view->has(entity) && view->data()[view->get(entity)] == entity;
    1858  });
    1859  }
    1860 
    1876  template<typename Func>
    1877  void each(Func func) const {
    1878  std::for_each(cbegin(), cend(), func);
    1879  }
    1880 
    1881 private:
    1882  pattern_type pools;
    1883 };
    1884 
    1885 
    1886 }
    1887 
    1888 
    1889 #endif // ENTT_ENTITY_VIEW_HPP
    entt::RawView::const_iterator_type
    typename pool_type::const_iterator_type const_iterator_type
    Constant input iterator type.
    Definition: view.hpp:1315
    +
    entt::View< Entity, Component >::size_type
    typename pool_type::size_type size_type
    Unsigned integer type.
    Definition: view.hpp:968
    +
    entt::RawView::empty
    bool empty() const ENTT_NOEXCEPT
    Checks whether the view is empty.
    Definition: view.hpp:1329
    entt::operator!=
    constexpr bool operator!=(const HashedString &lhs, const HashedString &rhs) ENTT_NOEXCEPT
    Compares two hashed strings.
    Definition: hashed_string.hpp:103
    -
    entt::View::cend
    const_iterator_type cend() const ENTT_NOEXCEPT
    Returns an iterator that is past the last entity that has the given components.
    Definition: view.hpp:718
    +
    entt::View::cend
    const_iterator_type cend() const ENTT_NOEXCEPT
    Returns an iterator that is past the last entity that has the given components.
    Definition: view.hpp:713
    entt::PersistentView::const_iterator_type
    typename view_type::const_iterator_type const_iterator_type
    Constant input iterator type.
    Definition: view.hpp:95
    entt::PersistentView::operator[]
    const entity_type & operator[](const size_type pos) const ENTT_NOEXCEPT
    Returns a reference to the element at the given position.
    Definition: view.hpp:245
    entt::PersistentView::entity_type
    typename view_type::entity_type entity_type
    Underlying entity identifier.
    Definition: view.hpp:89
    -
    entt::RuntimeView::empty
    bool empty() const ENTT_NOEXCEPT
    Checks if the view is definitely empty.
    Definition: view.hpp:1725
    -
    entt::RawView::begin
    iterator_type begin() ENTT_NOEXCEPT
    Returns an iterator to the first instance of the given type.
    Definition: view.hpp:1430
    +
    entt::RuntimeView::empty
    bool empty() const ENTT_NOEXCEPT
    Checks if the view is definitely empty.
    Definition: view.hpp:1720
    +
    entt::RawView::begin
    iterator_type begin() ENTT_NOEXCEPT
    Returns an iterator to the first instance of the given type.
    Definition: view.hpp:1425
    entt::PersistentView::size
    size_type size() const ENTT_NOEXCEPT
    Returns the number of entities that have the given components.
    Definition: view.hpp:101
    -
    entt::RuntimeView::size
    size_type size() const ENTT_NOEXCEPT
    Estimates the number of entities that have the given components.
    Definition: view.hpp:1717
    -
    entt::RawView::operator[]
    raw_type & operator[](const size_type pos) ENTT_NOEXCEPT
    Returns a reference to the element at the given position.
    Definition: view.hpp:1505
    +
    entt::RuntimeView::size
    size_type size() const ENTT_NOEXCEPT
    Estimates the number of entities that have the given components.
    Definition: view.hpp:1712
    +
    entt::RawView::operator[]
    raw_type & operator[](const size_type pos) ENTT_NOEXCEPT
    Returns a reference to the element at the given position.
    Definition: view.hpp:1500
    entt::Registry
    Fast and reliable entity-component system.
    Definition: registry.hpp:40
    -
    entt::RuntimeView::begin
    const_iterator_type begin() const ENTT_NOEXCEPT
    Returns an iterator to the first entity that has the given components.
    Definition: view.hpp:1769
    -
    entt::View< Entity, Component >::end
    const_iterator_type end() const ENTT_NOEXCEPT
    Returns an iterator that is past the last entity that has the given component.
    Definition: view.hpp:1131
    +
    entt::RuntimeView::begin
    const_iterator_type begin() const ENTT_NOEXCEPT
    Returns an iterator to the first entity that has the given components.
    Definition: view.hpp:1764
    +
    entt::View< Entity, Component >::end
    const_iterator_type end() const ENTT_NOEXCEPT
    Returns an iterator that is past the last entity that has the given component.
    Definition: view.hpp:1126
    entt::SparseSet< Entity >::empty
    bool empty() const ENTT_NOEXCEPT
    Checks whether a sparse set is empty.
    Definition: sparse_set.hpp:244
    entt::PersistentView::end
    const_iterator_type end() const ENTT_NOEXCEPT
    Returns an iterator that is past the last entity that has the given components.
    Definition: view.hpp:217
    entt::PersistentView::each
    void each(Func func)
    Iterates entities and components and applies the given function object to them.
    Definition: view.hpp:391
    -
    entt::View::size_type
    typename view_type::size_type size_type
    Unsigned integer type.
    Definition: view.hpp:626
    -
    entt::RawView::raw
    raw_type * raw() ENTT_NOEXCEPT
    Direct access to the list of components.
    Definition: view.hpp:1366
    -
    entt::RawView::iterator_type
    typename pool_type::iterator_type iterator_type
    Input iterator type.
    Definition: view.hpp:1318
    -
    entt::RawView
    Raw view.
    Definition: view.hpp:1300
    -
    entt::RawView::each
    void each(Func func)
    Iterates components and applies the given function object to them.
    Definition: view.hpp:1543
    +
    entt::View::size_type
    typename view_type::size_type size_type
    Unsigned integer type.
    Definition: view.hpp:621
    +
    entt::RawView::raw
    raw_type * raw() ENTT_NOEXCEPT
    Direct access to the list of components.
    Definition: view.hpp:1361
    +
    entt::RawView::iterator_type
    typename pool_type::iterator_type iterator_type
    Input iterator type.
    Definition: view.hpp:1313
    +
    entt::RawView
    Raw view.
    Definition: view.hpp:1295
    +
    entt::RawView::each
    void each(Func func)
    Iterates components and applies the given function object to them.
    Definition: view.hpp:1538
    entt::PersistentView::empty
    bool empty() const ENTT_NOEXCEPT
    Checks whether the view is empty.
    Definition: view.hpp:109
    entt
    EnTT default namespace.
    Definition: algorithm.hpp:10
    -
    entt::RuntimeView::const_iterator_type
    Iterator const_iterator_type
    Constant input iterator type.
    Definition: view.hpp:1711
    -
    entt::View< Entity, Component >::contains
    bool contains(const entity_type entity) const ENTT_NOEXCEPT
    Checks if a view contains an entity.
    Definition: view.hpp:1168
    +
    entt::RuntimeView::const_iterator_type
    Iterator const_iterator_type
    Constant input iterator type.
    Definition: view.hpp:1706
    +
    entt::View< Entity, Component >::contains
    bool contains(const entity_type entity) const ENTT_NOEXCEPT
    Checks if a view contains an entity.
    Definition: view.hpp:1163
    entt::SparseSet< Entity >::has
    bool has(const entity_type entity) const ENTT_NOEXCEPT
    Checks if a sparse set contains an entity.
    Definition: sparse_set.hpp:381
    -
    entt::View< Entity, Component >::raw_type
    typename pool_type::object_type raw_type
    Type of component iterated by the view.
    Definition: view.hpp:969
    -
    entt::RawView::data
    const entity_type * data() const ENTT_NOEXCEPT
    Direct access to the list of entities.
    Definition: view.hpp:1382
    -
    entt::View::end
    const_iterator_type end() const ENTT_NOEXCEPT
    Returns an iterator that is past the last entity that has the given components.
    Definition: view.hpp:738
    -
    entt::View< Entity, Component >::const_iterator_type
    typename view_type::const_iterator_type const_iterator_type
    Constant input iterator type.
    Definition: view.hpp:977
    +
    entt::View< Entity, Component >::raw_type
    typename pool_type::object_type raw_type
    Type of component iterated by the view.
    Definition: view.hpp:964
    +
    entt::RawView::data
    const entity_type * data() const ENTT_NOEXCEPT
    Direct access to the list of entities.
    Definition: view.hpp:1377
    +
    entt::View::end
    const_iterator_type end() const ENTT_NOEXCEPT
    Returns an iterator that is past the last entity that has the given components.
    Definition: view.hpp:733
    +
    entt::View< Entity, Component >::const_iterator_type
    typename view_type::const_iterator_type const_iterator_type
    Constant input iterator type.
    Definition: view.hpp:972
    entt::SparseSet< Entity >::begin
    const_iterator_type begin() const ENTT_NOEXCEPT
    Returns an iterator to the beginning.
    Definition: sparse_set.hpp:296
    -
    entt::View::contains
    bool contains(const entity_type entity) const ENTT_NOEXCEPT
    Checks if a view contains an entity.
    Definition: view.hpp:766
    -
    entt::View< Entity, Component >::raw
    const raw_type * raw() const ENTT_NOEXCEPT
    Direct access to the list of components.
    Definition: view.hpp:1007
    +
    entt::View::contains
    bool contains(const entity_type entity) const ENTT_NOEXCEPT
    Checks if a view contains an entity.
    Definition: view.hpp:761
    +
    entt::View< Entity, Component >::raw
    const raw_type * raw() const ENTT_NOEXCEPT
    Direct access to the list of components.
    Definition: view.hpp:1002
    entt::PersistentView::end
    iterator_type end() ENTT_NOEXCEPT
    Returns an iterator that is past the last entity that has the given components.
    Definition: view.hpp:236
    entt::PersistentView::begin
    const_iterator_type begin() const ENTT_NOEXCEPT
    Returns an iterator to the first entity that has the given components.
    Definition: view.hpp:161
    -
    entt::View::const_iterator_type
    Iterator const_iterator_type
    Constant input iterator type.
    Definition: view.hpp:630
    -
    entt::View< Entity, Component >::begin
    iterator_type begin() ENTT_NOEXCEPT
    Returns an iterator to the first entity that has the given component.
    Definition: view.hpp:1093
    +
    entt::View::const_iterator_type
    Iterator const_iterator_type
    Constant input iterator type.
    Definition: view.hpp:625
    +
    entt::View< Entity, Component >::begin
    iterator_type begin() ENTT_NOEXCEPT
    Returns an iterator to the first entity that has the given component.
    Definition: view.hpp:1088
    entt::PersistentView::cend
    const_iterator_type cend() const ENTT_NOEXCEPT
    Returns an iterator that is past the last entity that has the given components.
    Definition: view.hpp:198
    entt::SparseSet
    Sparse set.
    Definition: sparse_set.hpp:29
    -
    entt::RawView::cbegin
    const_iterator_type cbegin() const ENTT_NOEXCEPT
    Returns an iterator to the first instance of the given type.
    Definition: view.hpp:1398
    -
    entt::View< Entity, Component >::each
    void each(Func func)
    Iterates entities and components and applies the given function object to them.
    Definition: view.hpp:1249
    -
    entt::RawView::each
    void each(Func func) const
    Iterates components and applies the given function object to them.
    Definition: view.hpp:1524
    +
    entt::RawView::cbegin
    const_iterator_type cbegin() const ENTT_NOEXCEPT
    Returns an iterator to the first instance of the given type.
    Definition: view.hpp:1393
    +
    entt::View< Entity, Component >::each
    void each(Func func)
    Iterates entities and components and applies the given function object to them.
    Definition: view.hpp:1244
    +
    entt::RawView::each
    void each(Func func) const
    Iterates components and applies the given function object to them.
    Definition: view.hpp:1519
    entt::SparseSet< Entity >::size_type
    std::size_t size_type
    Unsigned integer type.
    Definition: sparse_set.hpp:169
    -
    entt::View::empty
    bool empty() const ENTT_NOEXCEPT
    Checks if the view is definitely empty.
    Definition: view.hpp:644
    -
    entt::RuntimeView::iterator_type
    Iterator iterator_type
    Input iterator type.
    Definition: view.hpp:1709
    -
    entt::RawView::size
    size_type size() const ENTT_NOEXCEPT
    Returns the number of instances of the given type.
    Definition: view.hpp:1326
    -
    entt::RuntimeView::contains
    bool contains(const entity_type entity) const ENTT_NOEXCEPT
    Checks if a view contains an entity.
    Definition: view.hpp:1860
    -
    entt::View< Entity, Component >::data
    const entity_type * data() const ENTT_NOEXCEPT
    Direct access to the list of entities.
    Definition: view.hpp:1039
    -
    entt::RuntimeView::entity_type
    typename view_type::entity_type entity_type
    Underlying entity identifier.
    Definition: view.hpp:1705
    +
    entt::View::empty
    bool empty() const ENTT_NOEXCEPT
    Checks if the view is definitely empty.
    Definition: view.hpp:639
    +
    entt::RuntimeView::iterator_type
    Iterator iterator_type
    Input iterator type.
    Definition: view.hpp:1704
    +
    entt::RawView::size
    size_type size() const ENTT_NOEXCEPT
    Returns the number of instances of the given type.
    Definition: view.hpp:1321
    +
    entt::RuntimeView::contains
    bool contains(const entity_type entity) const ENTT_NOEXCEPT
    Checks if a view contains an entity.
    Definition: view.hpp:1855
    +
    entt::View< Entity, Component >::data
    const entity_type * data() const ENTT_NOEXCEPT
    Direct access to the list of entities.
    Definition: view.hpp:1034
    +
    entt::RuntimeView::entity_type
    typename view_type::entity_type entity_type
    Underlying entity identifier.
    Definition: view.hpp:1700
    entt::SparseSet< Entity >::entity_type
    Entity entity_type
    Underlying entity identifier.
    Definition: sparse_set.hpp:167
    entt::SparseSet< Entity >::iterator_type
    Iterator iterator_type
    Input iterator type.
    Definition: sparse_set.hpp:171
    -
    entt::View< Entity, Component >::entity_type
    typename pool_type::entity_type entity_type
    Underlying entity identifier.
    Definition: view.hpp:971
    +
    entt::View< Entity, Component >::entity_type
    typename pool_type::entity_type entity_type
    Underlying entity identifier.
    Definition: view.hpp:966
    entt::SparseSet< Entity >
    Basic sparse set implementation.
    Definition: sparse_set.hpp:60
    -
    entt::View::begin
    iterator_type begin() ENTT_NOEXCEPT
    Returns an iterator to the first entity that has the given components.
    Definition: view.hpp:699
    -
    entt::RawView::end
    const_iterator_type end() const ENTT_NOEXCEPT
    Returns an iterator that is past the last instance of the given type.
    Definition: view.hpp:1468
    -
    entt::View::end
    iterator_type end() ENTT_NOEXCEPT
    Returns an iterator that is past the last entity that has the given components.
    Definition: view.hpp:757
    -
    entt::RawView::cend
    const_iterator_type cend() const ENTT_NOEXCEPT
    Returns an iterator that is past the last instance of the given type.
    Definition: view.hpp:1449
    +
    entt::View::begin
    iterator_type begin() ENTT_NOEXCEPT
    Returns an iterator to the first entity that has the given components.
    Definition: view.hpp:694
    +
    entt::RawView::end
    const_iterator_type end() const ENTT_NOEXCEPT
    Returns an iterator that is past the last instance of the given type.
    Definition: view.hpp:1463
    +
    entt::View::end
    iterator_type end() ENTT_NOEXCEPT
    Returns an iterator that is past the last entity that has the given components.
    Definition: view.hpp:752
    +
    entt::RawView::cend
    const_iterator_type cend() const ENTT_NOEXCEPT
    Returns an iterator that is past the last instance of the given type.
    Definition: view.hpp:1444
    entt::SparseSet< Entity >::const_iterator_type
    Iterator const_iterator_type
    Constant input iterator type.
    Definition: sparse_set.hpp:173
    -
    entt::View< Entity, Component >::cbegin
    const_iterator_type cbegin() const ENTT_NOEXCEPT
    Returns an iterator to the first entity that has the given component.
    Definition: view.hpp:1057
    -
    entt::View< Entity, Component >::each
    void each(Func func) const
    Iterates entities and components and applies the given function object to them.
    Definition: view.hpp:1227
    -
    entt::RuntimeView::end
    iterator_type end() ENTT_NOEXCEPT
    Returns an iterator that is past the last entity that has the given components.
    Definition: view.hpp:1851
    -
    entt::View::begin
    const_iterator_type begin() const ENTT_NOEXCEPT
    Returns an iterator to the first entity that has the given components.
    Definition: view.hpp:681
    -
    entt::View::iterator_type
    Iterator iterator_type
    Input iterator type.
    Definition: view.hpp:628
    -
    entt::View< Entity, Component >::empty
    bool empty() const ENTT_NOEXCEPT
    Checks whether the view is empty.
    Definition: view.hpp:991
    -
    entt::RuntimeView::each
    void each(Func func) const
    Iterates entities and applies the given function object to them.
    Definition: view.hpp:1882
    +
    entt::View< Entity, Component >::cbegin
    const_iterator_type cbegin() const ENTT_NOEXCEPT
    Returns an iterator to the first entity that has the given component.
    Definition: view.hpp:1052
    +
    entt::View< Entity, Component >::each
    void each(Func func) const
    Iterates entities and components and applies the given function object to them.
    Definition: view.hpp:1222
    +
    entt::RuntimeView::end
    iterator_type end() ENTT_NOEXCEPT
    Returns an iterator that is past the last entity that has the given components.
    Definition: view.hpp:1846
    +
    entt::View::begin
    const_iterator_type begin() const ENTT_NOEXCEPT
    Returns an iterator to the first entity that has the given components.
    Definition: view.hpp:676
    +
    entt::View::iterator_type
    Iterator iterator_type
    Input iterator type.
    Definition: view.hpp:623
    +
    entt::View< Entity, Component >::empty
    bool empty() const ENTT_NOEXCEPT
    Checks whether the view is empty.
    Definition: view.hpp:986
    +
    entt::RuntimeView::each
    void each(Func func) const
    Iterates entities and applies the given function object to them.
    Definition: view.hpp:1877
    entt::SparseSet< Entity >::size
    size_type size() const ENTT_NOEXCEPT
    Returns the number of elements in a sparse set.
    Definition: sparse_set.hpp:236
    -
    entt::View< Entity, Component >::begin
    const_iterator_type begin() const ENTT_NOEXCEPT
    Returns an iterator to the first entity that has the given component.
    Definition: view.hpp:1075
    +
    entt::View< Entity, Component >::begin
    const_iterator_type begin() const ENTT_NOEXCEPT
    Returns an iterator to the first entity that has the given component.
    Definition: view.hpp:1070
    entt::PersistentView::iterator_type
    typename view_type::iterator_type iterator_type
    Input iterator type.
    Definition: view.hpp:93
    entt::PersistentView::sort
    void sort()
    Sort the shared pool of entities according to the given component.
    Definition: view.hpp:414
    -
    entt::View< Entity, Component >::raw
    raw_type * raw() ENTT_NOEXCEPT
    Direct access to the list of components.
    Definition: view.hpp:1023
    -
    entt::RuntimeView::cbegin
    const_iterator_type cbegin() const ENTT_NOEXCEPT
    Returns an iterator to the first entity that has the given components.
    Definition: view.hpp:1743
    -
    entt::RawView::begin
    const_iterator_type begin() const ENTT_NOEXCEPT
    Returns an iterator to the first instance of the given type.
    Definition: view.hpp:1414
    -
    entt::RawView::raw_type
    typename pool_type::object_type raw_type
    Type of component iterated by the view.
    Definition: view.hpp:1312
    -
    entt::View< Entity, Component >::iterator_type
    typename view_type::iterator_type iterator_type
    Input iterator type.
    Definition: view.hpp:975
    -
    entt::View< Entity, Component >::size
    size_type size() const ENTT_NOEXCEPT
    Returns the number of entities that have the given component.
    Definition: view.hpp:983
    +
    entt::View< Entity, Component >::raw
    raw_type * raw() ENTT_NOEXCEPT
    Direct access to the list of components.
    Definition: view.hpp:1018
    +
    entt::RuntimeView::cbegin
    const_iterator_type cbegin() const ENTT_NOEXCEPT
    Returns an iterator to the first entity that has the given components.
    Definition: view.hpp:1738
    +
    entt::RawView::begin
    const_iterator_type begin() const ENTT_NOEXCEPT
    Returns an iterator to the first instance of the given type.
    Definition: view.hpp:1409
    +
    entt::RawView::raw_type
    typename pool_type::object_type raw_type
    Type of component iterated by the view.
    Definition: view.hpp:1307
    +
    entt::View< Entity, Component >::iterator_type
    typename view_type::iterator_type iterator_type
    Input iterator type.
    Definition: view.hpp:970
    +
    entt::View< Entity, Component >::size
    size_type size() const ENTT_NOEXCEPT
    Returns the number of entities that have the given component.
    Definition: view.hpp:978
    entt::SparseSet< Entity >::cend
    const_iterator_type cend() const ENTT_NOEXCEPT
    Returns an iterator to the end.
    Definition: sparse_set.hpp:329
    entt::View
    Multi component view.
    Definition: view.hpp:466
    -
    entt::RuntimeView::end
    const_iterator_type end() const ENTT_NOEXCEPT
    Returns an iterator that is past the last entity that has the given components.
    Definition: view.hpp:1832
    +
    entt::RuntimeView::end
    const_iterator_type end() const ENTT_NOEXCEPT
    Returns an iterator that is past the last entity that has the given components.
    Definition: view.hpp:1827
    entt::PersistentView
    Persistent view.
    Definition: view.hpp:71
    entt::SparseSet< Entity >::get
    size_type get(const entity_type entity) const ENTT_NOEXCEPT
    Returns the position of an entity in a sparse set.
    Definition: sparse_set.hpp:423
    -
    entt::View< Entity, Component >::operator[]
    const entity_type & operator[](const size_type pos) const ENTT_NOEXCEPT
    Returns a reference to the element at the given position.
    Definition: view.hpp:1159
    -
    entt::RawView::operator[]
    const raw_type & operator[](const size_type pos) const ENTT_NOEXCEPT
    Returns a reference to the element at the given position.
    Definition: view.hpp:1496
    -
    entt::View::cbegin
    const_iterator_type cbegin() const ENTT_NOEXCEPT
    Returns an iterator to the first entity that has the given components.
    Definition: view.hpp:662
    -
    entt::RuntimeView::size_type
    typename view_type::size_type size_type
    Unsigned integer type.
    Definition: view.hpp:1707
    +
    entt::View< Entity, Component >::operator[]
    const entity_type & operator[](const size_type pos) const ENTT_NOEXCEPT
    Returns a reference to the element at the given position.
    Definition: view.hpp:1154
    +
    entt::RawView::operator[]
    const raw_type & operator[](const size_type pos) const ENTT_NOEXCEPT
    Returns a reference to the element at the given position.
    Definition: view.hpp:1491
    +
    entt::View::cbegin
    const_iterator_type cbegin() const ENTT_NOEXCEPT
    Returns an iterator to the first entity that has the given components.
    Definition: view.hpp:657
    +
    entt::RuntimeView::size_type
    typename view_type::size_type size_type
    Unsigned integer type.
    Definition: view.hpp:1702
    entt::PersistentView::cbegin
    const_iterator_type cbegin() const ENTT_NOEXCEPT
    Returns an iterator to the first entity that has the given components.
    Definition: view.hpp:143
    -
    entt::RuntimeView::begin
    iterator_type begin() ENTT_NOEXCEPT
    Returns an iterator to the first entity that has the given components.
    Definition: view.hpp:1787
    +
    entt::RuntimeView::begin
    iterator_type begin() ENTT_NOEXCEPT
    Returns an iterator to the first entity that has the given components.
    Definition: view.hpp:1782
    entt::SparseSet< Entity >::respect
    void respect(const SparseSet< Entity > &other) ENTT_NOEXCEPT
    Sort entities according to their order in another sparse set.
    Definition: sparse_set.hpp:517
    -
    entt::View< Entity, Component >::end
    iterator_type end() ENTT_NOEXCEPT
    Returns an iterator that is past the last entity that has the given component.
    Definition: view.hpp:1150
    -
    entt::View::each
    void each(Func func)
    Iterates entities and components and applies the given function object to them.
    Definition: view.hpp:906
    -
    entt::RawView::end
    iterator_type end() ENTT_NOEXCEPT
    Returns an iterator that is past the last instance of the given type.
    Definition: view.hpp:1487
    +
    entt::View< Entity, Component >::end
    iterator_type end() ENTT_NOEXCEPT
    Returns an iterator that is past the last entity that has the given component.
    Definition: view.hpp:1145
    +
    entt::View::each
    void each(Func func)
    Iterates entities and components and applies the given function object to them.
    Definition: view.hpp:901
    +
    entt::RawView::end
    iterator_type end() ENTT_NOEXCEPT
    Returns an iterator that is past the last instance of the given type.
    Definition: view.hpp:1482
    entt::SparseSet< Entity >::data
    const entity_type * data() const ENTT_NOEXCEPT
    Direct access to the internal packed array.
    Definition: sparse_set.hpp:263
    entt::SparseSet< Entity >::cbegin
    const_iterator_type cbegin() const ENTT_NOEXCEPT
    Returns an iterator to the beginning.
    Definition: sparse_set.hpp:279
    -
    entt::View< Entity, Component >::cend
    const_iterator_type cend() const ENTT_NOEXCEPT
    Returns an iterator that is past the last entity that has the given component.
    Definition: view.hpp:1112
    +
    entt::View< Entity, Component >::cend
    const_iterator_type cend() const ENTT_NOEXCEPT
    Returns an iterator that is past the last entity that has the given component.
    Definition: view.hpp:1107
    entt::SparseSet< Entity >::end
    const_iterator_type end() const ENTT_NOEXCEPT
    Returns an iterator to the end.
    Definition: sparse_set.hpp:346
    entt::PersistentView::begin
    iterator_type begin() ENTT_NOEXCEPT
    Returns an iterator to the first entity that has the given components.
    Definition: view.hpp:179
    -
    entt::View::each
    void each(Func func) const
    Iterates entities and components and applies the given function object to them.
    Definition: view.hpp:882
    -
    entt::RawView::size_type
    typename pool_type::size_type size_type
    Unsigned integer type.
    Definition: view.hpp:1316
    -
    entt::RuntimeView::cend
    const_iterator_type cend() const ENTT_NOEXCEPT
    Returns an iterator that is past the last entity that has the given components.
    Definition: view.hpp:1806
    +
    entt::View::each
    void each(Func func) const
    Iterates entities and components and applies the given function object to them.
    Definition: view.hpp:877
    +
    entt::RawView::size_type
    typename pool_type::size_type size_type
    Unsigned integer type.
    Definition: view.hpp:1311
    +
    entt::RuntimeView::cend
    const_iterator_type cend() const ENTT_NOEXCEPT
    Returns an iterator that is past the last entity that has the given components.
    Definition: view.hpp:1801
    entt::PersistentView::data
    const entity_type * data() const ENTT_NOEXCEPT
    Direct access to the list of entities.
    Definition: view.hpp:125
    -
    entt::RawView::entity_type
    typename pool_type::entity_type entity_type
    Underlying entity identifier.
    Definition: view.hpp:1314
    -
    entt::View::entity_type
    typename view_type::entity_type entity_type
    Underlying entity identifier.
    Definition: view.hpp:624
    +
    entt::RawView::entity_type
    typename pool_type::entity_type entity_type
    Underlying entity identifier.
    Definition: view.hpp:1309
    +
    entt::View::entity_type
    typename view_type::entity_type entity_type
    Underlying entity identifier.
    Definition: view.hpp:619
    entt::PersistentView::each
    void each(Func func) const
    Iterates entities and components and applies the given function object to them.
    Definition: view.hpp:368
    -
    entt::RuntimeView
    Runtime view.
    Definition: view.hpp:1595
    +
    entt::RuntimeView
    Runtime view.
    Definition: view.hpp:1590
    entt::entt_traits
    Entity traits.
    Definition: entt_traits.hpp:18
    -
    entt::RawView::raw
    const raw_type * raw() const ENTT_NOEXCEPT
    Direct access to the list of components.
    Definition: view.hpp:1350
    +
    entt::RawView::raw
    const raw_type * raw() const ENTT_NOEXCEPT
    Direct access to the list of components.
    Definition: view.hpp:1345
    entt::PersistentView::size_type
    typename view_type::size_type size_type
    Unsigned integer type.
    Definition: view.hpp:91
    -
    entt::View::size
    size_type size() const ENTT_NOEXCEPT
    Estimates the number of entities that have the given components.
    Definition: view.hpp:636
    +
    entt::View::size
    size_type size() const ENTT_NOEXCEPT
    Estimates the number of entities that have the given components.
    Definition: view.hpp:631
    entt::PersistentView::contains
    bool contains(const entity_type entity) const ENTT_NOEXCEPT
    Checks if a view contains an entity.
    Definition: view.hpp:254
    ItType of random access iterator.
    -
    entt -  2.7.1 +
    EnTT +  2.7.2
    -
    entt -  2.7.1 +
    EnTT +  2.7.2
    -
    entt -  2.7.1 +
    EnTT +  2.7.2
    -
    entt -  2.7.1 +
    EnTT +  2.7.2
    -
    entt -  2.7.1 +
    EnTT +  2.7.2
    -
    entt -  2.7.1 +
    EnTT +  2.7.2
    -
    entt -  2.7.1 +
    EnTT +  2.7.2
    -
    entt -  2.7.1 +
    EnTT +  2.7.2
    -
    entt -  2.7.1 +
    EnTT +  2.7.2
    -
    entt -  2.7.1 +
    EnTT +  2.7.2
    -
    entt -  2.7.1 +
    EnTT +  2.7.2
    -
    entt -  2.7.1 +
    EnTT +  2.7.2
    -
    entt -  2.7.1 +
    EnTT +  2.7.2