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

Definition at line 63 of file delegate.hpp.

+

Definition at line 70 of file delegate.hpp.

@@ -200,7 +203,39 @@ template<typename Class , Ret(Class::*)(Args...) Member> -

Definition at line 79 of file delegate.hpp.

+

Definition at line 86 of file delegate.hpp.

+ + + + +

◆ empty()

+ +
+
+
+template<typename Ret , typename... Args>
+ + + + + +
+ + + + + + + +
bool entt::Delegate< Ret(Args...)>::empty () const
+ 		+inline
+
+ +

Checks whether a delegate actually stores a listener.

+
Returns
True if the delegate is empty, false otherwise.
+ +

Definition at line 60 of file delegate.hpp.

@@ -239,7 +274,7 @@ template<typename Ret , typename... Args>
Returns
The value returned by the underlying function.
-

Definition at line 97 of file delegate.hpp.

+

Definition at line 104 of file delegate.hpp.

@@ -279,7 +314,7 @@ template<typename Ret , typename... Args>
Returns
True if the two delegates are identical, false otherwise.
-

Definition at line 109 of file delegate.hpp.

+

Definition at line 116 of file delegate.hpp.

@@ -311,7 +346,7 @@ template<typename Ret , typename... Args>

Resets a delegate.

After a reset, a delegate can be safely invoked with no effect.

-

Definition at line 88 of file delegate.hpp.

+

Definition at line 95 of file delegate.hpp.

diff --git a/classentt_1_1Identifier-members.html b/classentt_1_1Identifier-members.html new file mode 100644 index 000000000..0e030fb0e --- /dev/null +++ b/classentt_1_1Identifier-members.html @@ -0,0 +1,83 @@ + + + + + + + +entt: Member List + + + + + + + + + +
+
+ + + + + + +
+
entt +  2.6.1 +
+
+
+ + + + + + + + +
+
+ + +
+ +
+ + +
+
+
+
entt::Identifier< Types > Member List
+
+
+ +

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

+ + + +
get() ENTT_NOEXCEPTentt::Identifier< Types >inlinestatic
identifier_type typedefentt::Identifier< Types >
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/classentt_1_1Identifier.html b/classentt_1_1Identifier.html new file mode 100644 index 000000000..37e575f83 --- /dev/null +++ b/classentt_1_1Identifier.html @@ -0,0 +1,161 @@ + + + + + + + +entt: entt::Identifier< Types > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
entt +  2.6.1 +
+
+
+ + + + + + + + +
+
+ + +
+ +
+ + +
+
+
+Public Types | +Static Public Member Functions | +List of all members
+
+
entt::Identifier< Types > Class Template Referencefinal
+
+
+ +

Types identifiers. + More...

+ +

#include <ident.hpp>

+ + + + + +

+Public Types

+using identifier_type = std::size_t
 Unsigned integer type.
 
+ + + + + +

+Static Public Member Functions

template<typename Type >
static constexpr identifier_type get () ENTT_NOEXCEPT
 Returns the identifier associated with a given type. More...
 
+

Detailed Description

+

template<typename... Types>
+class entt::Identifier< Types >

+ +

Types identifiers.

+

Variable template used to generate identifiers at compile-time for the given types. Use the get member function to know what's the identifier associated to the specific type.

+
Note
Identifiers are constant expression and can be used in any context where such an expression is required. As an example:
using ID = entt::Identifier<AType, AnotherType>;
switch(aTypeIdentifier) {
case ID::get<AType>():
// ...
break;
case ID::get<AnotherType>():
// ...
break;
default:
// ...
}
+
Template Parameters
+ + +
TypesList of types for which to generate identifiers.
+
+
+ +

Definition at line 71 of file ident.hpp.

+

Member Function Documentation

+ +

◆ get()

+ +
+
+
+template<typename... Types>
+
+template<typename Type >
+ + + + + +
+ + + + + + + +
static constexpr identifier_type entt::Identifier< Types >::get ()
+ 		+inlinestatic
+
+ +

Returns the identifier associated with a given type.

+
Template Parameters
+ + +
Typeof which to return the identifier.
+
+
+
Returns
The identifier associated with the given type.
+ +

Definition at line 95 of file ident.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/classentt_1_1PersistentView-members.html b/classentt_1_1PersistentView-members.html index 43496411d..10cf34daa 100644 --- a/classentt_1_1PersistentView-members.html +++ b/classentt_1_1PersistentView-members.html @@ -88,10 +88,11 @@ $(function() { get(const entity_type entity) const ENTT_NOEXCEPTentt::PersistentView< Entity, Component >inline get(const entity_type entity) ENTT_NOEXCEPTentt::PersistentView< Entity, Component >inline iterator_type typedefentt::PersistentView< Entity, Component > - Registry< Entity > classentt::PersistentView< Entity, Component >friend - size() const ENTT_NOEXCEPTentt::PersistentView< Entity, Component >inline - size_type typedefentt::PersistentView< Entity, Component > - sort()entt::PersistentView< Entity, Component >inline + operator[](const size_type pos) const ENTT_NOEXCEPTentt::PersistentView< Entity, Component >inline + Registry< Entity > classentt::PersistentView< Entity, Component >friend + size() const ENTT_NOEXCEPTentt::PersistentView< Entity, Component >inline + size_type typedefentt::PersistentView< Entity, Component > + sort()entt::PersistentView< Entity, Component >inline
diff --git a/classentt_1_1PersistentView.html b/classentt_1_1PersistentView.html index 359af1cd5..a8b32e4bc 100644 --- a/classentt_1_1PersistentView.html +++ b/classentt_1_1PersistentView.html @@ -80,14 +80,6 @@ $(function() { - - - - - - @@ -96,6 +88,14 @@ using  + + + + + +

Public Types

-using iterator_type = typename view_type::iterator_type
 Input iterator type.
 
-using const_iterator_type = typename view_type::const_iterator_type
 Constant input iterator type.
 
using entity_type = typename view_type::entity_type
 Underlying entity identifier.
size_type = typename view_type::size_type
 Unsigned integer type.
 
+using iterator_type = typename view_type::iterator_type
 Input iterator type.
 
+using const_iterator_type = typename view_type::const_iterator_type
 Constant input iterator type.
 
@@ -126,6 +126,9 @@ Public Member Functions + + + @@ -186,7 +189,9 @@ class entt::PersistentView< Entity, Component >
View<Entity, Component>
-RawView
+RawView +
+RuntimeView
Template Parameters

Public Member Functions

iterator_type end () ENTT_NOEXCEPT
 Returns an iterator that is past the last entity that has the given components. More...
 
const entity_type & operator[] (const size_type pos) const ENTT_NOEXCEPT
 Returns a reference to the element at the given position. More...
 
bool contains (const entity_type entity) const ENTT_NOEXCEPT
 Checks if a view contains an entity. More...
 
@@ -195,7 +200,7 @@ class entt::PersistentView< Entity, Component > -

Definition at line 68 of file view.hpp.

+

Definition at line 71 of file view.hpp.

Member Function Documentation

◆ begin() [1/2]

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

+

Definition at line 161 of file view.hpp.

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

+

Definition at line 179 of file view.hpp.

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

+

Definition at line 143 of file view.hpp.

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

+

Definition at line 198 of file view.hpp.

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

Definition at line 242 of file view.hpp.

+

Definition at line 254 of file view.hpp.

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

+

Definition at line 125 of file view.hpp.

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

Definition at line 356 of file view.hpp.

+

Definition at line 368 of file view.hpp.

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

Definition at line 379 of file view.hpp.

+

Definition at line 391 of file view.hpp.

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

Checks whether the view is empty.

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

Definition at line 106 of file view.hpp.

+

Definition at line 109 of file view.hpp.

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

+

Definition at line 217 of file view.hpp.

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

+

Definition at line 236 of file view.hpp.

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

Definition at line 264 of file view.hpp.

+

Definition at line 276 of file view.hpp.

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

Definition at line 287 of file view.hpp.

+

Definition at line 299 of file view.hpp.

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

Definition at line 310 of file view.hpp.

+

Definition at line 322 of file view.hpp.

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

Definition at line 334 of file view.hpp.

+

Definition at line 346 of file view.hpp.

+ + + + +

◆ operator[]()

+ +
+
+
+template<typename Entity , typename... Component>
+
EntityA valid entity type (see entt_traits for more details).
+ + + + +
+ + + + + + + + +
const entity_type& entt::PersistentView< Entity, Component >::operator[] (const size_type pos) const
+ 		+inline
+
+ +

Returns a reference to the element at the given position.

+
Parameters
+ + +
posPosition of the element to return.
+
+
+
Returns
A reference to the requested element.
+ +

Definition at line 245 of file view.hpp.

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

Returns the number of entities that have the given components.

Returns
Number of entities that have the given components.
-

Definition at line 98 of file view.hpp.

+

Definition at line 101 of file view.hpp.

@@ -871,7 +915,7 @@ template<typename Comp > -

Definition at line 402 of file view.hpp.

+

Definition at line 414 of file view.hpp.

diff --git a/classentt_1_1Prototype-members.html b/classentt_1_1Prototype-members.html index 675ba7c85..a2865944b 100644 --- a/classentt_1_1Prototype-members.html +++ b/classentt_1_1Prototype-members.html @@ -86,7 +86,11 @@ $(function() { operator()(const entity_type dst) const ENTT_NOEXCEPTentt::Prototype< Entity >inline operator()(registry_type &other) const ENTT_NOEXCEPTentt::Prototype< Entity >inline operator()() const ENTT_NOEXCEPTentt::Prototype< Entity >inline + operator=(const Prototype &)=deleteentt::Prototype< Entity > + operator=(Prototype &&other)entt::Prototype< Entity >inline Prototype(Registry< Entity > &registry)entt::Prototype< Entity >inline + Prototype(const Prototype &)=deleteentt::Prototype< Entity > + Prototype(Prototype &&other)entt::Prototype< Entity >inline registry_type typedefentt::Prototype< Entity > set(Args &&... args)entt::Prototype< Entity >inline size_type typedefentt::Prototype< Entity > diff --git a/classentt_1_1Prototype.html b/classentt_1_1Prototype.html index 05f69b991..73d9657f6 100644 --- a/classentt_1_1Prototype.html +++ b/classentt_1_1Prototype.html @@ -102,6 +102,19 @@ Public Member Functions  ~Prototype ()  Releases all its resources.
  + + Prototype (const Prototype &)=delete + Copying a prototype isn't allowed.
+  + Prototype (Prototype &&other) + Move constructor. More...
+  +Prototype & operator= (const Prototype &)=delete + Copying a prototype isn't allowed. More...
+  +Prototype & operator= (Prototype &&other) + Move assignment operator. More...
+  template<typename Component , typename... Args> Component & set (Args &&... args)  Assigns to or replaces the given component of a prototype. More...
@@ -180,7 +193,7 @@ class entt::Prototype< Entity >

Definition at line 39 of file prototype.hpp.

Constructor & Destructor Documentation

-

◆ Prototype()

+

◆ Prototype() [1/2]

@@ -213,7 +226,46 @@ template<typename Entity >
-

Definition at line 63 of file prototype.hpp.

+

Definition at line 69 of file prototype.hpp.

+ +
+ + +

◆ Prototype() [2/2]

+ +
+
+
+template<typename Entity >
+ + + + + +
+ + + + + + + + +
entt::Prototype< Entity >::Prototype (Prototype< Entity > && other)
+ 		+inline
+
+ +

Move constructor.

+

After prototype move construction, instances that have been moved from are placed in a valid but unspecified state. It's highly discouraged to continue using them.

+
Parameters
+ + +
otherThe instance to move from.
+
+
+ +

Definition at line 93 of file prototype.hpp.

@@ -267,7 +319,7 @@ template<typename Entity > -

Definition at line 310 of file prototype.hpp.

+

Definition at line 356 of file prototype.hpp.

@@ -309,7 +361,7 @@ template<typename Entity > -

Definition at line 334 of file prototype.hpp.

+

Definition at line 380 of file prototype.hpp.

@@ -363,7 +415,7 @@ template<typename Entity > -

Definition at line 259 of file prototype.hpp.

+

Definition at line 307 of file prototype.hpp.

@@ -406,7 +458,7 @@ template<typename Entity > -

Definition at line 285 of file prototype.hpp.

+

Definition at line 333 of file prototype.hpp.

@@ -447,7 +499,7 @@ template<typename Entity >
Returns
A valid entity identifier.
-

Definition at line 209 of file prototype.hpp.

+

Definition at line 259 of file prototype.hpp.

@@ -481,7 +533,7 @@ template<typename Entity >
const auto entity = registry.create();
prototype(entity);
Note
This overload directly uses the underlying registry as a working space. Therefore, the components of the prototype and of the entity will share the same registry.
Returns
A valid entity identifier.
-

Definition at line 232 of file prototype.hpp.

+

Definition at line 282 of file prototype.hpp.

@@ -523,7 +575,7 @@ template<typename Component >
Returns
A reference to the component owned by the prototype.
-

Definition at line 134 of file prototype.hpp.

+

Definition at line 184 of file prototype.hpp.

@@ -565,7 +617,7 @@ template<typename Component >
Returns
A reference to the component owned by the prototype.
-

Definition at line 151 of file prototype.hpp.

+

Definition at line 201 of file prototype.hpp.

@@ -607,7 +659,7 @@ template<typename... Component>
Returns
References to the components owned by the prototype.
-

Definition at line 169 of file prototype.hpp.

+

Definition at line 219 of file prototype.hpp.

@@ -649,7 +701,7 @@ template<typename... Component>
Returns
References to the components owned by the prototype.
-

Definition at line 187 of file prototype.hpp.

+

Definition at line 237 of file prototype.hpp.

@@ -689,7 +741,7 @@ template<typename... Component>
Returns
True if the prototype owns all the components, false otherwise.
-

Definition at line 117 of file prototype.hpp.

+

Definition at line 167 of file prototype.hpp.

@@ -743,7 +795,7 @@ template<typename Entity > -

Definition at line 361 of file prototype.hpp.

+

Definition at line 405 of file prototype.hpp.

@@ -786,7 +838,7 @@ template<typename Entity > -

Definition at line 385 of file prototype.hpp.

+

Definition at line 429 of file prototype.hpp.

@@ -827,7 +879,7 @@ template<typename Entity >
Returns
A valid entity identifier.
-

Definition at line 407 of file prototype.hpp.

+

Definition at line 451 of file prototype.hpp.

@@ -861,7 +913,78 @@ template<typename Entity >
const auto entity = registry.create();
prototype(entity);
Note
This overload directly uses the underlying registry as a working space. Therefore, the components of the prototype and of the entity will share the same registry.
Returns
A valid entity identifier.
-

Definition at line 428 of file prototype.hpp.

+

Definition at line 472 of file prototype.hpp.

+ + + + +

◆ operator=() [1/2]

+ +
+
+
+template<typename Entity >
+ + + + + +
+ + + + + + + + +
Prototype& entt::Prototype< Entity >::operator= (const Prototype< Entity > & )
+ 		+delete
+
+ +

Copying a prototype isn't allowed.

+
Returns
This Prototype.
+ +
+
+ +

◆ operator=() [2/2]

+ +
+
+
+template<typename Entity >
+ + + + + +
+ + + + + + + + +
Prototype& entt::Prototype< Entity >::operator= (Prototype< Entity > && other)
+ 		+inline
+
+ +

Move assignment operator.

+

After prototype move assignment, instances that have been moved from are placed in a valid but unspecified state. It's highly discouraged to continue using them.

+
Parameters
+ + +
otherThe instance to move from.
+
+
+
Returns
This Prototype.
+ +

Definition at line 114 of file prototype.hpp.

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

Definition at line 83 of file prototype.hpp.

+

Definition at line 133 of file prototype.hpp.

@@ -948,7 +1071,7 @@ template<typename Component > -

Definition at line 106 of file prototype.hpp.

+

Definition at line 156 of file prototype.hpp.

diff --git a/classentt_1_1RawView-members.html b/classentt_1_1RawView-members.html index c6bb329bc..b2e77ef96 100644 --- a/classentt_1_1RawView-members.html +++ b/classentt_1_1RawView-members.html @@ -83,6 +83,8 @@ $(function() { end() ENTT_NOEXCEPTentt::RawView< Entity, Component >inline entity_type typedefentt::RawView< Entity, Component > iterator_type typedefentt::RawView< Entity, Component > + operator[](const size_type pos) const ENTT_NOEXCEPTentt::RawView< Entity, Component >inline + operator[](const size_type pos) ENTT_NOEXCEPTentt::RawView< Entity, Component >inline raw() const ENTT_NOEXCEPTentt::RawView< Entity, Component >inline raw() ENTT_NOEXCEPTentt::RawView< Entity, Component >inline raw_type typedefentt::RawView< Entity, Component > diff --git a/classentt_1_1RawView.html b/classentt_1_1RawView.html index 90eb83c72..af347c481 100644 --- a/classentt_1_1RawView.html +++ b/classentt_1_1RawView.html @@ -80,14 +80,10 @@ $(function() { - - - - - - + + + @@ -96,10 +92,14 @@ using  - - - + + + + + +

Public Types

-using iterator_type = typename pool_type::iterator_type
 Input iterator type.
 
-using const_iterator_type = typename pool_type::const_iterator_type
 Constant input iterator type.
 
+using raw_type = typename pool_type::object_type
 Type of component iterated by the view.
 
using entity_type = typename pool_type::entity_type
 Underlying entity identifier.
size_type = typename pool_type::size_type
 Unsigned integer type.
 
-using raw_type = typename pool_type::object_type
 Type of component iterated by the view.
 
+using iterator_type = typename pool_type::iterator_type
 Input iterator type.
 
+using const_iterator_type = typename pool_type::const_iterator_type
 Constant input iterator type.
 
@@ -136,6 +136,12 @@ Public Member Functions + + + + + + @@ -172,7 +178,9 @@ class entt::RawView< Entity, Component >
View<Entity, Component>
-PersistentView
+PersistentView +
+RuntimeView
Template Parameters

Public Member Functions

iterator_type end () ENTT_NOEXCEPT
 Returns an iterator that is past the last instance of the given type. More...
 
const raw_type & operator[] (const size_type pos) const ENTT_NOEXCEPT
 Returns a reference to the element at the given position. More...
 
raw_type & operator[] (const size_type pos) ENTT_NOEXCEPT
 Returns a reference to the element at the given position. More...
 
template<typename Func >
void each (Func func) const
 Iterates components and applies the given function object to them. More...
@@ -181,7 +189,7 @@ class entt::RawView< Entity, Component > -

Definition at line 1276 of file view.hpp.

+

Definition at line 1300 of file view.hpp.

Member Function Documentation

◆ begin() [1/2]

@@ -213,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 1390 of file view.hpp.

+

Definition at line 1414 of file view.hpp.

@@ -247,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 1406 of file view.hpp.

+

Definition at line 1430 of file view.hpp.

@@ -281,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 1374 of file view.hpp.

+

Definition at line 1398 of file view.hpp.

@@ -315,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 1425 of file view.hpp.

+

Definition at line 1449 of file view.hpp.

@@ -349,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 1358 of file view.hpp.

+

Definition at line 1382 of file view.hpp.

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

Definition at line 1482 of file view.hpp.

+

Definition at line 1524 of file view.hpp.

@@ -430,9 +438,9 @@ template<typename Func >

Iterates components and applies the given function object to them.

-

The function object is provided with a const reference to each component of the view.
+

The function object is provided with a reference to each component of the view.
The signature of the function should be equivalent to the following:

-
void(const Component &);
Template Parameters
+
void(Component &);
Template Parameters
EntityA valid entity type (see entt_traits for more details).
FuncType of the function object to invoke.
@@ -445,7 +453,7 @@ template<typename Func > -

Definition at line 1501 of file view.hpp.

+

Definition at line 1543 of file view.hpp.

@@ -477,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 1310 of file view.hpp.

+

Definition at line 1334 of file view.hpp.

@@ -511,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 1444 of file view.hpp.

+

Definition at line 1468 of file view.hpp.

@@ -545,7 +553,85 @@ 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 1463 of file view.hpp.

+

Definition at line 1487 of file view.hpp.

+ + + + +

◆ operator[]() [1/2]

+ +
+
+
+template<typename Entity , typename Component >
+ + + + + +
+ + + + + + + + +
const raw_type& entt::RawView< Entity, Component >::operator[] (const size_type pos) const
+ 		+inline
+
+ +

Returns a reference to the element at the given position.

+
Parameters
+ + +
posPosition of the element to return.
+
+
+
Returns
A reference to the requested element.
+ +

Definition at line 1496 of file view.hpp.

+ +
+
+ +

◆ operator[]() [2/2]

+ +
+
+
+template<typename Entity , typename Component >
+ + + + + +
+ + + + + + + + +
raw_type& entt::RawView< Entity, Component >::operator[] (const size_type pos)
+ 		+inline
+
+ +

Returns a reference to the element at the given position.

+
Parameters
+ + +
posPosition of the element to return.
+
+
+
Returns
A reference to the requested element.
+ +

Definition at line 1505 of file view.hpp.

@@ -579,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 1326 of file view.hpp.

+

Definition at line 1350 of file view.hpp.

@@ -613,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 1342 of file view.hpp.

+

Definition at line 1366 of file view.hpp.

@@ -645,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 1302 of file view.hpp.

+

Definition at line 1326 of file view.hpp.

diff --git a/classentt_1_1Registry-members.html b/classentt_1_1Registry-members.html index cdf6df340..76de51a71 100644 --- a/classentt_1_1Registry-members.html +++ b/classentt_1_1Registry-members.html @@ -74,69 +74,73 @@ $(function() { 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 - 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_NOEXCEPTentt::Registry< Entity >inline - current(const entity_type entity) const ENTT_NOEXCEPTentt::Registry< Entity >inline - data() 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 - 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_type typedefentt::Registry< Entity > - fast(const entity_type entity) const ENTT_NOEXCEPTentt::Registry< Entity >inline - get() const ENTT_NOEXCEPTentt::Registry< Entity >inline - get() ENTT_NOEXCEPTentt::Registry< Entity >inline - get(const entity_type entity) const ENTT_NOEXCEPTentt::Registry< Entity >inline - get(const entity_type entity) ENTT_NOEXCEPTentt::Registry< Entity >inline - get(const entity_type entity) const ENTT_NOEXCEPTentt::Registry< Entity >inline - get(const entity_type entity) ENTT_NOEXCEPTentt::Registry< Entity >inline - has() const ENTT_NOEXCEPTentt::Registry< Entity >inline - has(tag_t, const entity_type entity) const ENTT_NOEXCEPTentt::Registry< Entity >inline - has(const entity_type entity) const ENTT_NOEXCEPTentt::Registry< Entity >inline - move(const entity_type entity)entt::Registry< Entity >inline - operator=(const Registry &)=deleteentt::Registry< Entity > - operator=(Registry &&)=defaultentt::Registry< Entity > - orphan(const entity_type entity) constentt::Registry< Entity >inline - orphans(Func func) constentt::Registry< Entity >inline - prepare()entt::Registry< Entity >inline - raw() const ENTT_NOEXCEPTentt::Registry< Entity >inline - raw() ENTT_NOEXCEPTentt::Registry< Entity >inline - Registry()=defaultentt::Registry< Entity > - Registry(const Registry &)=deleteentt::Registry< Entity > - Registry(Registry &&)=defaultentt::Registry< Entity > - remove()entt::Registry< Entity >inline - remove(const entity_type entity)entt::Registry< Entity >inline - replace(tag_t, Args &&... args)entt::Registry< Entity >inline - replace(const entity_type entity, Args &&... args)entt::Registry< Entity >inline - reserve(const size_type cap)entt::Registry< Entity >inline - reserve(const size_type cap)entt::Registry< Entity >inline - reset(const entity_type entity)entt::Registry< Entity >inline - reset()entt::Registry< Entity >inline - reset()entt::Registry< Entity >inline - restore()entt::Registry< Entity >inline - sink_type typedefentt::Registry< Entity > - size() const ENTT_NOEXCEPTentt::Registry< Entity >inline - size() const ENTT_NOEXCEPTentt::Registry< Entity >inline - size_type typedefentt::Registry< Entity > - snapshot() constentt::Registry< Entity >inline - sort(Compare compare, Sort sort=Sort{})entt::Registry< Entity >inline - sort()entt::Registry< Entity >inline - tag_type typedefentt::Registry< Entity > - type(tag_t) ENTT_NOEXCEPTentt::Registry< Entity >inlinestatic - type() ENTT_NOEXCEPTentt::Registry< Entity >inlinestatic - valid(const entity_type entity) const ENTT_NOEXCEPTentt::Registry< Entity >inline - version(const entity_type entity) const ENTT_NOEXCEPTentt::Registry< Entity >inline - version_type typedefentt::Registry< Entity > - view()entt::Registry< Entity >inline - view(persistent_t)entt::Registry< Entity >inline - view(raw_t)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_type typedefentt::Registry< Entity > + fast(const entity_type entity) const ENTT_NOEXCEPTentt::Registry< Entity >inline + get() const ENTT_NOEXCEPTentt::Registry< Entity >inline + get() ENTT_NOEXCEPTentt::Registry< Entity >inline + get(const entity_type entity) const ENTT_NOEXCEPTentt::Registry< Entity >inline + get(const entity_type entity) ENTT_NOEXCEPTentt::Registry< Entity >inline + get(const entity_type entity) const ENTT_NOEXCEPTentt::Registry< Entity >inline + get(const entity_type entity) ENTT_NOEXCEPTentt::Registry< Entity >inline + has() const ENTT_NOEXCEPTentt::Registry< Entity >inline + has(tag_t, const entity_type entity) const ENTT_NOEXCEPTentt::Registry< Entity >inline + has(const entity_type entity) const ENTT_NOEXCEPTentt::Registry< Entity >inline + move(const entity_type entity) ENTT_NOEXCEPTentt::Registry< Entity >inline + operator=(const Registry &)=deleteentt::Registry< Entity > + operator=(Registry &&)=defaultentt::Registry< Entity > + orphan(const entity_type entity) constentt::Registry< Entity >inline + orphans(Func func) constentt::Registry< Entity >inline + prepare()entt::Registry< Entity >inline + raw() const ENTT_NOEXCEPTentt::Registry< Entity >inline + raw() ENTT_NOEXCEPTentt::Registry< Entity >inline + Registry()=defaultentt::Registry< Entity > + Registry(const Registry &)=deleteentt::Registry< Entity > + Registry(Registry &&)=defaultentt::Registry< Entity > + remove()entt::Registry< Entity >inline + remove(const entity_type entity)entt::Registry< Entity >inline + replace(tag_t, Args &&... args)entt::Registry< Entity >inline + replace(const entity_type entity, Args &&... args)entt::Registry< Entity >inline + reserve(const size_type cap)entt::Registry< Entity >inline + reserve(const size_type cap)entt::Registry< Entity >inline + reset(const entity_type entity)entt::Registry< Entity >inline + reset()entt::Registry< Entity >inline + reset()entt::Registry< Entity >inline + restore() ENTT_NOEXCEPTentt::Registry< Entity >inline + sink_type typedefentt::Registry< Entity > + size() const ENTT_NOEXCEPTentt::Registry< Entity >inline + size() const ENTT_NOEXCEPTentt::Registry< Entity >inline + size_type typedefentt::Registry< Entity > + snapshot() const ENTT_NOEXCEPTentt::Registry< Entity >inline + sort(Compare compare, Sort sort=Sort{}, Args &&... args)entt::Registry< Entity >inline + sort()entt::Registry< Entity >inline + tag_type typedefentt::Registry< Entity > + type(tag_t) ENTT_NOEXCEPTentt::Registry< Entity >inlinestatic + type() ENTT_NOEXCEPTentt::Registry< Entity >inlinestatic + valid(const entity_type entity) const ENTT_NOEXCEPTentt::Registry< Entity >inline + version(const entity_type entity) const ENTT_NOEXCEPTentt::Registry< Entity >inline + version_type typedefentt::Registry< Entity > + view()entt::Registry< Entity >inline + view(persistent_t)entt::Registry< Entity >inline + view(raw_t)entt::Registry< Entity >inline + view(It first, It last)entt::Registry< Entity >inline
diff --git a/classentt_1_1Registry.html b/classentt_1_1Registry.html index 8d94b1e3c..652944114 100644 --- a/classentt_1_1Registry.html +++ b/classentt_1_1Registry.html @@ -135,17 +135,21 @@ Public Member Functions   template<typename Component > void reserve (const size_type cap) - Increases the capacity of the pool for a given component. More...
+ Increases the capacity of the pool for the given component. More...
  void reserve (const size_type cap)  Increases the capacity of a registry in terms of entities. More...
  +template<typename Component > +size_type capacity () const ENTT_NOEXCEPT + Returns the capacity of the pool for the given component. More...
+  size_type capacity () const ENTT_NOEXCEPT - Returns the number of entities ever created. More...
+ Returns the number of entities that a registry has currently allocated space for. More...
  template<typename Component > bool empty () const ENTT_NOEXCEPT - Checks whether the pool for the given component is empty. More...
+ Checks whether the pool of the given component is empty. More...
  bool empty () const ENTT_NOEXCEPT  Checks if there exists at least an entity still in use. More...
@@ -174,12 +178,20 @@ Public Member Functions version_type current (const entity_type entity) const ENTT_NOEXCEPT  Returns the actual version for an entity identifier. More...
  -entity_type create () ENTT_NOEXCEPT - Creates a new entity and returns it. More...
-  +entity_type create () + Creates a new entity and returns it. More...
+  +template<typename Tag > +void destroy (tag_t) + Destroys the entity that owns the given tag, if any. More...
+  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...
+  template<typename Tag , typename... Args> Tag & assign (tag_t, const entity_type entity, Args &&... args)  Attaches the given tag to an entity. More...
@@ -240,10 +252,10 @@ Public Member Functions 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) - Changes the owner of the given tag. More...
-  +template<typename Tag > +entity_type move (const entity_type entity) ENTT_NOEXCEPT + Changes the owner of the given tag. More...
+  template<typename Tag > entity_type attachee () const ENTT_NOEXCEPT  Gets the owner of the given tag, if any. More...
@@ -268,10 +280,10 @@ Public Member Functions sink_type destruction () ENTT_NOEXCEPT  Returns a sink object for the given component. More...
  -template<typename Component , typename Compare , typename Sort = StdSort> -void sort (Compare compare, Sort sort=Sort{}) - Sorts the pool of entities for the given component. More...
-  +template<typename Component , typename Compare , typename Sort = StdSort, typename... Args> +void sort (Compare compare, Sort sort=Sort{}, Args &&... args) + Sorts the pool of entities for the given component. More...
+  template<typename To , typename From > void sort ()  Sorts two pools of components in the same way. More...
@@ -322,12 +334,16 @@ Public Member Functions RawView< Entity, Component > view (raw_t)  Returns a raw view for the given component. More...
  -Snapshot< Entity > snapshot () const - Returns a temporary object to use to create snapshots. More...
-  -SnapshotLoader< Entity > restore () - Returns a temporary object to use to load snapshots. More...
-  +template<typename It > +RuntimeView< Entity > view (It first, It last) + Returns a runtime view for the given components. More...
+  +Snapshot< Entity > snapshot () const ENTT_NOEXCEPT + Returns a temporary object to use to create snapshots. More...
+  +SnapshotLoader< Entity > restore () ENTT_NOEXCEPT + Returns a temporary object to use to load snapshots. More...
+  @@ -355,7 +371,7 @@ class entt::Registry< Entity > -

Definition at line 39 of file registry.hpp.

+

Definition at line 40 of file registry.hpp.

Member Function Documentation

◆ accommodate()

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

Definition at line 858 of file registry.hpp.

+

Definition at line 911 of file registry.hpp.

@@ -478,14 +494,14 @@ template<typename Tag , typename... Args>
Parameters

Static Public Member Functions

- +
entityA valid entity identifier
entityA valid entity identifier.
argsParameters to use to initialize the tag.
Returns
A reference to the newly created tag.
-

Definition at line 490 of file registry.hpp.

+

Definition at line 543 of file registry.hpp.

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

Definition at line 521 of file registry.hpp.

+

Definition at line 574 of file registry.hpp.

@@ -589,12 +605,52 @@ template<typename Tag >
Returns
A valid entity identifier.
-

Definition at line 826 of file registry.hpp.

+

Definition at line 879 of file registry.hpp.

+ + + + +

◆ capacity() [1/2]

+ +
+
+
+template<typename Entity>
+
+template<typename Component >
+ + + + + +
+ + + + + + + +
size_type entt::Registry< Entity >::capacity () const
+ 		+inline
+
+ +

Returns the capacity of the pool for the given component.

+
Template Parameters
+ + +
ComponentType of component in which one is interested.
+
+
+
Returns
Capacity of the pool of the given component.
+ +

Definition at line 231 of file registry.hpp.

-

◆ capacity()

+

◆ capacity() [2/2]

@@ -618,10 +674,10 @@ template<typename Entity>
-

Returns the number of entities ever created.

-
Returns
Number of entities ever created.
+

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

+
Returns
Capacity of the registry.
-

Definition at line 228 of file registry.hpp.

+

Definition at line 240 of file registry.hpp.

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

Definition at line 891 of file registry.hpp.

+

Definition at line 944 of file registry.hpp.

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

Definition at line 920 of file registry.hpp.

+

Definition at line 973 of file registry.hpp.

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

Definition at line 1340 of file registry.hpp.

+

Definition at line 1397 of file registry.hpp.

- -

◆ create()

+ +

◆ create()

@@ -788,10 +844,10 @@ template<typename Entity>
  • Recycled ones with updated versions.

    • Users should not care about the type of the returned entity identifier. In case entity identifers are stored around, the valid member function can be used to know if they are still valid or the entity has been destroyed and potentially recycled.

    -

    The returned entity has no components assigned.

    +

    The returned entity has no components nor tags assigned.

    Returns
    A valid entity identifier.
    -

    Definition at line 390 of file registry.hpp.

    +

    Definition at line 402 of file registry.hpp.

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

    Definition at line 367 of file registry.hpp.

    +

    Definition at line 379 of file registry.hpp.

    @@ -875,12 +931,54 @@ template<typename Component >
    Returns
    A pointer to the array of entities.
    -

    Definition at line 304 of file registry.hpp.

    +

    Definition at line 316 of file registry.hpp.

    + + + + +

    ◆ destroy() [1/3]

    + +
    +
    +
    +template<typename Entity>
    +
    +template<typename Tag >
    + + + + + +
    + + + + + + + + +
    void entt::Registry< Entity >::destroy (tag_t )
    +     		+inline
    +
    + +

    Destroys the entity that owns the given tag, if any.

    +

    Convenient shortcut to destroy an entity by means of a tag type.
    + Syntactic sugar for the following snippet:

    +
    if(registry.has<Tag>()) {
    registry.destroy(registry.attachee<Tag>());
    }
    Template Parameters
    + + +
    TagType of tag to use to search for the entity.
    +
    +
    + +

    Definition at line 438 of file registry.hpp.

    -

    ◆ destroy()

    +

    ◆ destroy() [2/3]

    @@ -913,12 +1011,55 @@ 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.
    Parameters
    - +
    entityA valid entity identifier
    entityA valid entity identifier.
    -

    Definition at line 433 of file registry.hpp.

    +

    Definition at line 464 of file registry.hpp.

    + +
    +
    + +

    ◆ destroy() [3/3]

    + +
    +
    +
    +template<typename Entity>
    +
    +template<typename... Component, typename... Type>
    + + + + + +
    + + + + + + + + +
    void entt::Registry< Entity >::destroy (Type... )
    +     		+inline
    +
    + +

    Destroys the entities that own he 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
    + + + +
    ComponentTypes of components to use to search for the entities.
    TypeType of view to use or empty to use a standard view.
    +
    +
    + +

    Definition at line 515 of file registry.hpp.

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

    Definition at line 949 of file registry.hpp.

    +

    Definition at line 1002 of file registry.hpp.

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

    Definition at line 978 of file registry.hpp.

    +

    Definition at line 1031 of file registry.hpp.

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

    Definition at line 1316 of file registry.hpp.

    +

    Definition at line 1373 of file registry.hpp.

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

    Definition at line 1148 of file registry.hpp.

    +

    Definition at line 1204 of file registry.hpp.

    @@ -1133,16 +1274,16 @@ template<typename Component >
    -

    Checks whether the pool for the given component is empty.

    +

    Checks whether the pool of the given component is empty.

    Template Parameters
    ComponentType of component in which one is interested.
    -
    Returns
    True if the pool for the given component is empty, false otherwise.
    +
    Returns
    True if the pool of the given component is empty, false otherwise.
    -

    Definition at line 239 of file registry.hpp.

    +

    Definition at line 251 of file registry.hpp.

    @@ -1174,7 +1315,7 @@ 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 247 of file registry.hpp.

    +

    Definition at line 259 of file registry.hpp.

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

    Definition at line 335 of file registry.hpp.

    +

    Definition at line 347 of file registry.hpp.

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

    Definition at line 637 of file registry.hpp.

    +

    Definition at line 690 of file registry.hpp.

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

    Definition at line 655 of file registry.hpp.

    +

    Definition at line 708 of file registry.hpp.

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

    Definition at line 674 of file registry.hpp.

    +

    Definition at line 727 of file registry.hpp.

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

    Definition at line 695 of file registry.hpp.

    +

    Definition at line 748 of file registry.hpp.

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

    Definition at line 715 of file registry.hpp.

    +

    Definition at line 768 of file registry.hpp.

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

    Definition at line 735 of file registry.hpp.

    +

    Definition at line 788 of file registry.hpp.

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

    Definition at line 571 of file registry.hpp.

    +

    Definition at line 624 of file registry.hpp.

    @@ -1595,7 +1736,7 @@ template<typename Tag >
    Returns
    True if the entity owns the tag, false otherwise.
    -

    Definition at line 598 of file registry.hpp.

    +

    Definition at line 651 of file registry.hpp.

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

    Definition at line 615 of file registry.hpp.

    +

    Definition at line 668 of file registry.hpp.

    - -

    ◆ move()

    + +

    ◆ move()

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

    Definition at line 804 of file registry.hpp.

    +

    Definition at line 857 of file registry.hpp.

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

    Definition at line 1175 of file registry.hpp.

    +

    Definition at line 1231 of file registry.hpp.

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

    Definition at line 1209 of file registry.hpp.

    +

    Definition at line 1265 of file registry.hpp.

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

    Definition at line 1272 of file registry.hpp.

    +

    Definition at line 1329 of file registry.hpp.

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

    Definition at line 266 of file registry.hpp.

    +

    Definition at line 278 of file registry.hpp.

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

    Definition at line 285 of file registry.hpp.

    +

    Definition at line 297 of file registry.hpp.

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

    Definition at line 534 of file registry.hpp.

    +

    Definition at line 587 of file registry.hpp.

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

    Definition at line 557 of file registry.hpp.

    +

    Definition at line 610 of file registry.hpp.

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

    Definition at line 758 of file registry.hpp.

    +

    Definition at line 811 of file registry.hpp.

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

    Definition at line 783 of file registry.hpp.

    +

    Definition at line 836 of file registry.hpp.

    @@ -2213,7 +2354,7 @@ template<typename Component >
    -

    Increases the capacity of the pool for a given component.

    +

    Increases the capacity of the pool for the given component.

    If the new capacity is greater than the current capacity, new storage is allocated, otherwise the method does nothing.

    Template Parameters
    @@ -2228,7 +2369,7 @@ template<typename Component > -

    Definition at line 207 of file registry.hpp.

    +

    Definition at line 208 of file registry.hpp.

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

    Definition at line 220 of file registry.hpp.

    +

    Definition at line 221 of file registry.hpp.

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

    Definition at line 1080 of file registry.hpp.

    +

    Definition at line 1135 of file registry.hpp.

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

    Definition at line 1101 of file registry.hpp.

    +

    Definition at line 1156 of file registry.hpp.

    @@ -2388,12 +2529,12 @@ 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 1121 of file registry.hpp.

    +

    Definition at line 1176 of file registry.hpp.

    - -

    ◆ restore()

    + +

    ◆ restore()

    @@ -2423,7 +2564,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 1458 of file registry.hpp.

    +

    Definition at line 1555 of file registry.hpp.

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

    Definition at line 185 of file registry.hpp.

    +

    Definition at line 186 of file registry.hpp.

    @@ -2495,12 +2636,12 @@ template<typename Entity>

    Returns the number of entities still in use.

    Returns
    Number of entities still in use.
    -

    Definition at line 193 of file registry.hpp.

    +

    Definition at line 194 of file registry.hpp.

    - -

    ◆ snapshot()

    + +

    ◆ snapshot()

    @@ -2529,19 +2670,19 @@ 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 1429 of file registry.hpp.

    +

    Definition at line 1526 of file registry.hpp.

    - -

    ◆ sort() [1/2]

    + +

    ◆ sort() [1/2]

    template<typename Entity>
    -template<typename Component , typename Compare , typename Sort = StdSort>
    +template<typename Component , typename Compare , typename Sort = StdSort, typename... Args>
    - + + + + + + + @@ -2573,7 +2720,7 @@ template<typename Component , typename Compare , typename Sort = StdSort>

    Sorts the pool of entities for the given component.

    The order of the elements in a pool is highly affected by assignments of components to entities and deletions. Components are arranged to maximize the performance during iterations and users should not make any assumption on the order.
    - This function can be used to impose an order to the elements in the pool for the given component. The order is kept valid until a component of the given type is assigned or removed from an entity.

    + This function can be used to impose an order to the elements in the pool of the given component. The order is kept valid until a component of the given type is assigned or removed from an entity.

    The comparison function object must return true if the first element is less than the second one, false otherwise. The signature of the comparison function should be equivalent to the following:

    bool(const Component &, const Component &)

    Moreover, the comparison function object shall induce a strict weak ordering on the values.

    The sort function oject must offer a member function template operator() that accepts three arguments:

    @@ -2588,6 +2735,7 @@ template<typename Component , typename Compare , typename Sort = StdSort> +
    @@ -2556,7 +2697,13 @@ template<typename Component , typename Compare , typename Sort = StdSort> Sort sort = Sort{} sort = Sort{},
    Args &&... args 
    ComponentType of components to sort.
    CompareType of comparison function object.
    SortType of sort function object.
    ArgsTypes of arguments to forward to the sort function object.
    @@ -2595,11 +2743,12 @@ template<typename Component , typename Compare , typename Sort = StdSort> +
    compareA valid comparison function object.
    sortA valid sort function object.
    argsArguments to forward to the sort function object, if any.
    -

    Definition at line 1023 of file registry.hpp.

    +

    Definition at line 1078 of file registry.hpp.

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

    Definition at line 1059 of file registry.hpp.

    +

    Definition at line 1114 of file registry.hpp.

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

    Definition at line 158 of file registry.hpp.

    +

    Definition at line 159 of file registry.hpp.

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

    Definition at line 175 of file registry.hpp.

    +

    Definition at line 176 of file registry.hpp.

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

    Definition at line 313 of file registry.hpp.

    +

    Definition at line 325 of file registry.hpp.

    @@ -2811,12 +2960,12 @@ template<typename Entity>
    Returns
    Version stored along with the given entity identifier.
    -

    Definition at line 346 of file registry.hpp.

    +

    Definition at line 358 of file registry.hpp.

    -

    ◆ view() [1/3]

    +

    ◆ view() [1/4]

    @@ -2859,7 +3008,9 @@ template<typename... Component>
    PersistentView
    -RawView
    +RawView +
    +RuntimeView
    Template Parameters
    @@ -2868,12 +3019,12 @@ template<typename... Component>
    Returns
    A newly created standard view.
    -

    Definition at line 1251 of file registry.hpp.

    +

    Definition at line 1308 of file registry.hpp.

    -

    ◆ view() [2/3]

    +

    ◆ view() [2/4]

    @@ -2918,7 +3069,9 @@ template<typename... Component>
    PersistentView
    -RawView
    +RawView +
    +RuntimeView
    Template Parameters
    ComponentType of components used to construct the view.
    @@ -2927,12 +3080,12 @@ template<typename... Component>
    Returns
    A newly created persistent view.
    -

    Definition at line 1385 of file registry.hpp.

    +

    Definition at line 1443 of file registry.hpp.

    -

    ◆ view() [3/3]

    +

    ◆ view() [3/4]

    @@ -2970,7 +3123,9 @@ template<typename Component >
    PersistentView
    -RawView
    +RawView +
    +RuntimeView
    Template Parameters
    ComponentTypes of components used to construct the view.
    @@ -2979,7 +3134,79 @@ template<typename Component >
    Returns
    A newly created raw view.
    -

    Definition at line 1414 of file registry.hpp.

    +

    Definition at line 1473 of file registry.hpp.

    + + + + +

    ◆ view() [4/4]

    + +
    +
    +
    +template<typename Entity>
    +
    +template<typename It >
    +
    ComponentType of component used to construct the view.
    + + + + +
    + + + + + + + + + + + + + + + + + + +
    RuntimeView<Entity> entt::Registry< Entity >::view (It first,
    It last 
    )
    +     		+inline
    +
    + +

    Returns a runtime view for the given components.

    +

    This kind of views are created on the fly and share with the registry its internal data structures.
    + Users should throw away the view after use. Fortunately, creating and destroying a view is an incredibly cheap operation because they do not require any type of initialization.
    + As a rule of thumb, storing a view should never be an option.

    +

    Runtime views are well suited when users want to construct a view from some external inputs and don't know at compile-time what are the required components.
    + This is particularly well suited to plugin systems and mods in general.

    +
    See also
    View
    +
    +View<Entity, Component>
    +
    +PersistentView
    +
    +RawView
    +
    +RuntimeView
    +
    Template Parameters
    + + +
    ItType of forward iterator.
    +
    +
    +
    Parameters
    + + + +
    firstAn iterator to the first element of the range of components.
    lastAn iterator past the last element of the range of components.
    +
    +
    +
    Returns
    A newly created runtime view.
    + +

    Definition at line 1505 of file registry.hpp.

    diff --git a/classentt_1_1ResourceHandle.html b/classentt_1_1ResourceHandle.html index d587b9769..8c0370f07 100644 --- a/classentt_1_1ResourceHandle.html +++ b/classentt_1_1ResourceHandle.html @@ -103,7 +103,7 @@ Public Member Functions  Dereferences a handle to obtain the managed resource. More...
      const Resource * operator-> () const ENTT_NOEXCEPT - Gets a pointer to the managed resource from a handle . More...
    + Gets a pointer to the managed resource from a handle. More...
       operator bool () const @@ -259,7 +259,7 @@ template<typename Resource >
    -

    Gets a pointer to the managed resource from a handle .

    +

    Gets a pointer to the managed resource from a handle.

    Warning
    The behavior is undefined if the handle doesn't contain a resource.
    An assertion will abort the execution at runtime in debug mode if the handle is empty.
    Returns
    A pointer to the managed resource or nullptr if the handle contains no resource at all.
    diff --git a/classentt_1_1RuntimeView-members.html b/classentt_1_1RuntimeView-members.html new file mode 100644 index 000000000..9db5c8c62 --- /dev/null +++ b/classentt_1_1RuntimeView-members.html @@ -0,0 +1,96 @@ + + + + + + + +entt: Member List + + + + + + + + + +
    +
    + + + + + + +
    +
    entt +  2.6.1 +
    +
    +
    + + + + + + + + +
    +
    + + +
    + +
    + + +
    +
    +
    +
    entt::RuntimeView< Entity > Member List
    +
    +
    + +

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

    + + + + + + + + + + + + + + + + +
    begin() const ENTT_NOEXCEPTentt::RuntimeView< Entity >inline
    begin() ENTT_NOEXCEPTentt::RuntimeView< Entity >inline
    cbegin() const ENTT_NOEXCEPTentt::RuntimeView< Entity >inline
    cend() const ENTT_NOEXCEPTentt::RuntimeView< Entity >inline
    const_iterator_type typedefentt::RuntimeView< Entity >
    contains(const entity_type entity) const ENTT_NOEXCEPTentt::RuntimeView< Entity >inline
    each(Func func) constentt::RuntimeView< Entity >inline
    empty() const ENTT_NOEXCEPTentt::RuntimeView< Entity >inline
    end() const ENTT_NOEXCEPTentt::RuntimeView< Entity >inline
    end() ENTT_NOEXCEPTentt::RuntimeView< Entity >inline
    entity_type typedefentt::RuntimeView< Entity >
    iterator_type typedefentt::RuntimeView< Entity >
    Registry< Entity > classentt::RuntimeView< Entity >friend
    size() const ENTT_NOEXCEPTentt::RuntimeView< Entity >inline
    size_type typedefentt::RuntimeView< Entity >
    + +
    +Generated by   +doxygen + 1.8.13 +
    + + diff --git a/classentt_1_1RuntimeView.html b/classentt_1_1RuntimeView.html new file mode 100644 index 000000000..ee9bc3f43 --- /dev/null +++ b/classentt_1_1RuntimeView.html @@ -0,0 +1,540 @@ + + + + + + + +entt: entt::RuntimeView< Entity > Class Template Reference + + + + + + + + + +
    +
    + + + + + + +
    +
    entt +  2.6.1 +
    +
    +
    + + + + + + + + +
    +
    + + +
    + +
    + + +
    +
    +
    +Classes | +Public Types | +Public Member Functions | +Friends | +List of all members
    +
    +
    entt::RuntimeView< Entity > Class Template Reference
    +
    +
    + +

    Runtime view. + More...

    + +

    #include <view.hpp>

    + + + + + + + + + + + + + + +

    +Public Types

    +using entity_type = typename view_type::entity_type
     Underlying entity identifier.
     
    +using size_type = typename view_type::size_type
     Unsigned integer type.
     
    +using iterator_type = Iterator
     Input iterator type.
     
    +using const_iterator_type = Iterator
     Constant input iterator type.
     
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

    +Public Member Functions

    size_type size () const ENTT_NOEXCEPT
     Estimates the number of entities that have the given components. More...
     
    bool empty () const ENTT_NOEXCEPT
     Checks if the view is definitely empty. More...
     
    const_iterator_type cbegin () const ENTT_NOEXCEPT
     Returns an iterator to the first entity that has the given components. More...
     
    const_iterator_type begin () const ENTT_NOEXCEPT
     Returns an iterator to the first entity that has the given components. More...
     
    iterator_type begin () ENTT_NOEXCEPT
     Returns an iterator to the first entity that has the given components. More...
     
    const_iterator_type cend () const ENTT_NOEXCEPT
     Returns an iterator that is past the last entity that has the given components. More...
     
    const_iterator_type end () const ENTT_NOEXCEPT
     Returns an iterator that is past the last entity that has the given components. More...
     
    iterator_type end () ENTT_NOEXCEPT
     Returns an iterator that is past the last entity that has the given components. More...
     
    bool contains (const entity_type entity) const ENTT_NOEXCEPT
     Checks if a view contains an entity. More...
     
    template<typename Func >
    void each (Func func) const
     Iterates entities and applies the given function object to them. More...
     
    + + + + +

    +Friends

    +class Registry< Entity >
     A registry is allowed to create views.
     
    +

    Detailed Description

    +

    template<typename Entity>
    +class entt::RuntimeView< Entity >

    + +

    Runtime view.

    +

    Runtime views iterate over those entities that have at least all the given components in their bags. During initialization, a runtime view looks at the number of entities available for each component and picks up a reference to the smallest set of candidate entities in order to get a performance boost when iterate.
    + Order of elements during iterations are highly dependent on the order of the underlying data structures. See SparseSet and its specializations for more details.

    +

    Important

    +

    Iterators aren't invalidated if:

    +
      +
    • New instances of the given components are created and assigned to entities.
      • +
    • The entity currently pointed is modified (as an example, if one of the given components is removed from the entity to which the iterator points).
      • +
    +

    In all the other cases, modifying the pools of the given components in any way invalidates all the iterators and using them results in undefined behavior.

    +
    Note
    Views share references to the underlying data structures with the Registry that generated them. Therefore any change to the entities and to the components made by means of the registry are immediately reflected by views, unless a pool wasn't missing when the view was built (in this case, the view won't have a valid reference and won't be updated accordingly).
    +
    Warning
    Lifetime of a view must overcome the one of the registry that generated it. In any other case, attempting to use a view results in undefined behavior.
    +
    See also
    View
    +
    +View<Entity, Component>
    +
    +PersistentView
    +
    +RawView
    +
    Template Parameters
    + + +
    EntityA valid entity type (see entt_traits for more details).
    +
    +
    + +

    Definition at line 1595 of file view.hpp.

    +

    Member Function Documentation

    + +

    ◆ begin() [1/2]

    + +
    +
    +
    +template<typename Entity >
    + + + + + +
    + + + + + + + +
    const_iterator_type entt::RuntimeView< Entity >::begin () const
    +     		+inline
    +
    + +

    Returns an iterator to the first entity that has the given components.

    +

    The returned iterator points to the first entity that has the given components. If the view is empty, the returned iterator will be equal to end().

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

    + +
    +
    + +

    ◆ begin() [2/2]

    + +
    +
    +
    +template<typename Entity >
    + + + + + +
    + + + + + + + +
    iterator_type entt::RuntimeView< Entity >::begin ()
    +     		+inline
    +
    + +

    Returns an iterator to the first entity that has the given components.

    +

    The returned iterator points to the first entity that has the given components. If the view is empty, the returned iterator will be equal to end().

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

    + +
    +
    + +

    ◆ cbegin()

    + +
    +
    +
    +template<typename Entity >
    + + + + + +
    + + + + + + + +
    const_iterator_type entt::RuntimeView< Entity >::cbegin () const
    +     		+inline
    +
    + +

    Returns an iterator to the first entity that has the given components.

    +

    The returned iterator points to the first entity that has the given components. If the view is empty, the returned iterator will be equal to end().

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

    + +
    +
    + +

    ◆ cend()

    + +
    +
    +
    +template<typename Entity >
    + + + + + +
    + + + + + + + +
    const_iterator_type entt::RuntimeView< Entity >::cend () const
    +     		+inline
    +
    + +

    Returns an iterator that is past the last entity that has the given components.

    +

    The returned iterator points to the entity following the last entity that has the given components. Attempting to dereference the returned iterator results in undefined behavior.

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

    + +
    +
    + +

    ◆ contains()

    + +
    +
    +
    +template<typename Entity >
    + + + + + +
    + + + + + + + + +
    bool entt::RuntimeView< Entity >::contains (const entity_type entity) const
    +     		+inline
    +
    + +

    Checks if a view contains an entity.

    +
    Parameters
    + + +
    entityA valid entity identifier.
    +
    +
    +
    Returns
    True if the view contains the given entity, false otherwise.
    + +

    Definition at line 1860 of file view.hpp.

    + +
    +
    + +

    ◆ each()

    + +
    +
    +
    +template<typename Entity >
    +
    +template<typename Func >
    + + + + + +
    + + + + + + + + +
    void entt::RuntimeView< Entity >::each (Func func) const
    +     		+inline
    +
    + +

    Iterates entities and applies the given function object to them.

    +

    The function object is invoked for each entity. It is provided only with the entity itself. To get the components, users can use the registry with which the view was built.
    + The signature of the function should be equivalent to the following:

    +
    void(const entity_type);
    Template Parameters
    + + +
    FuncType of the function object to invoke.
    +
    +
    +
    Parameters
    + + +
    funcA valid function object.
    +
    +
    + +

    Definition at line 1882 of file view.hpp.

    + +
    +
    + +

    ◆ empty()

    + +
    +
    +
    +template<typename Entity >
    + + + + + +
    + + + + + + + +
    bool entt::RuntimeView< Entity >::empty () const
    +     		+inline
    +
    + +

    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.

    + +
    +
    + +

    ◆ end() [1/2]

    + +
    +
    +
    +template<typename Entity >
    + + + + + +
    + + + + + + + +
    const_iterator_type entt::RuntimeView< Entity >::end () const
    +     		+inline
    +
    + +

    Returns an iterator that is past the last entity that has the given components.

    +

    The returned iterator points to the entity following the last entity that has the given components. Attempting to dereference the returned iterator results in undefined behavior.

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

    + +
    +
    + +

    ◆ end() [2/2]

    + +
    +
    +
    +template<typename Entity >
    + + + + + +
    + + + + + + + +
    iterator_type entt::RuntimeView< Entity >::end ()
    +     		+inline
    +
    + +

    Returns an iterator that is past the last entity that has the given components.

    +

    The returned iterator points to the entity following the last entity that has the given components. Attempting to dereference the returned iterator results in undefined behavior.

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

    + +
    +
    + +

    ◆ size()

    + +
    +
    +
    +template<typename Entity >
    + + + + + +
    + + + + + + + +
    size_type entt::RuntimeView< Entity >::size () const
    +     		+inline
    +
    + +

    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.

    + +
    +
    +
    The documentation for this class was generated from the following file: +
    + +
    +Generated by   +doxygen + 1.8.13 +
    + + diff --git a/classentt_1_1Scheduler.html b/classentt_1_1Scheduler.html index 06d19f012..3a00b6e35 100644 --- a/classentt_1_1Scheduler.html +++ b/classentt_1_1Scheduler.html @@ -147,7 +147,7 @@ class entt::Scheduler< Delta > -

    Definition at line 45 of file scheduler.hpp.

    +

    Definition at line 44 of file scheduler.hpp.

    Member Function Documentation

    ◆ abort()

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

    Definition at line 301 of file scheduler.hpp.

    +

    Definition at line 291 of file scheduler.hpp.

    @@ -235,7 +235,7 @@ template<typename Proc , typename... Args>
    Returns
    An opaque object to use to concatenate processes.
    -

    Definition at line 198 of file scheduler.hpp.

    +

    Definition at line 188 of file scheduler.hpp.

    @@ -294,7 +294,7 @@ template<typename Func >
    Returns
    An opaque object to use to concatenate processes.
    -

    Definition at line 259 of file scheduler.hpp.

    +

    Definition at line 249 of file scheduler.hpp.

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

    Discards all scheduled processes.

    Processes aren't aborted. They are discarded along with their children and never executed again.

    -

    Definition at line 168 of file scheduler.hpp.

    +

    Definition at line 158 of file scheduler.hpp.

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

    Returns true if at least a process is currently scheduled.

    Returns
    True if there are scheduled processes, false otherwise.
    -

    Definition at line 158 of file scheduler.hpp.

    +

    Definition at line 148 of file scheduler.hpp.

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

    Number of processes currently scheduled.

    Returns
    Number of processes currently scheduled.
    -

    Definition at line 150 of file scheduler.hpp.

    +

    Definition at line 140 of file scheduler.hpp.

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

    Definition at line 275 of file scheduler.hpp.

    +

    Definition at line 265 of file scheduler.hpp.

    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 42c98f68a..82ffed61d 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 @@ -76,7 +76,7 @@ $(function() { instance_type typedefentt::SigH< Ret(Args...), Collector > operator==(const SigH &other) const ENTT_NOEXCEPTentt::SigH< Ret(Args...), Collector >inline publish(Args... args) constentt::SigH< Ret(Args...), Collector >inline - sink()entt::SigH< Ret(Args...), Collector >inline + sink() ENTT_NOEXCEPTentt::SigH< Ret(Args...), Collector >inline sink_type typedefentt::SigH< Ret(Args...), Collector > size() const ENTT_NOEXCEPTentt::SigH< Ret(Args...), Collector >inline size_type typedefentt::SigH< Ret(Args...), Collector > 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 29751c149..b6716f280 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 @@ -119,9 +119,9 @@ Public Member Functions bool empty () const ENTT_NOEXCEPT  Returns false if at least a listener is connected to the signal. More...
      -sink_type sink () - Returns a sink object for the given signal. More...
    -  +sink_type sink () ENTT_NOEXCEPT + Returns a sink object for the given signal. More...
    +  void publish (Args... args) const  Triggers a signal. More...
      @@ -344,8 +344,8 @@ template<typename Ret , typename... Args, typename Collector > - -

    ◆ sink()

    + +

    ◆ sink()

    diff --git a/classentt_1_1SparseSet.html b/classentt_1_1SparseSet.html index ddd3383af..206fa52ee 100644 --- a/classentt_1_1SparseSet.html +++ b/classentt_1_1SparseSet.html @@ -79,7 +79,7 @@ class entt::SparseSet<... >

    Sparse set.

    Primary template isn't defined on purpose. All the specializations give a compile-time error, but for a few reasonable cases.

    -

    Definition at line 28 of file sparse_set.hpp.

    +

    Definition at line 29 of file sparse_set.hpp.

    The documentation for this class was generated from the following file: 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 9cefe1b1e..3d945205b 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 @@ -72,28 +72,30 @@ $(function() { - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + @@ -101,11 +103,11 @@ $(function() { - + - +
    begin() const ENTT_NOEXCEPTentt::SparseSet< Entity, Type >inline
    begin() ENTT_NOEXCEPTentt::SparseSet< Entity, Type >inline
    cbegin() const ENTT_NOEXCEPTentt::SparseSet< Entity, Type >inline
    cend() const ENTT_NOEXCEPTentt::SparseSet< Entity, Type >inline
    const_iterator_type typedefentt::SparseSet< Entity, Type >
    construct(const entity_type entity, Args &&... args)entt::SparseSet< Entity, Type >inline
    construct(const entity_type entity, Args &&... args)entt::SparseSet< Entity, Type >inline
    entt::SparseSet< Entity >::construct(const entity_type entity)entt::SparseSet< Entity >inline
    data() const ENTT_NOEXCEPTentt::SparseSet< Entity >inline
    destroy(const entity_type entity) overrideentt::SparseSet< Entity, Type >inlinevirtual
    empty() const ENTT_NOEXCEPTentt::SparseSet< Entity >inline
    end() const ENTT_NOEXCEPTentt::SparseSet< Entity, Type >inline
    end() ENTT_NOEXCEPTentt::SparseSet< Entity, Type >inline
    entity_type typedefentt::SparseSet< Entity, Type >
    extent() const ENTT_NOEXCEPTentt::SparseSet< Entity >inline
    fast(const entity_type entity) const ENTT_NOEXCEPTentt::SparseSet< Entity >inline
    get(const entity_type entity) const ENTT_NOEXCEPTentt::SparseSet< Entity, Type >inline
    get(const entity_type entity) ENTT_NOEXCEPTentt::SparseSet< Entity, Type >inline
    has(const entity_type entity) const ENTT_NOEXCEPTentt::SparseSet< Entity >inline
    iterator_type typedefentt::SparseSet< Entity, Type >
    object_type typedefentt::SparseSet< Entity, Type >
    operator=(const SparseSet &)=deleteentt::SparseSet< Entity, Type >
    operator=(SparseSet &&)=defaultentt::SparseSet< Entity, Type >
    pos_type typedefentt::SparseSet< Entity, Type >
    capacity() const ENTT_NOEXCEPTentt::SparseSet< Entity >inline
    cbegin() const ENTT_NOEXCEPTentt::SparseSet< Entity, Type >inline
    cend() const ENTT_NOEXCEPTentt::SparseSet< Entity, Type >inline
    const_iterator_type typedefentt::SparseSet< Entity, Type >
    construct(const entity_type entity, Args &&... args)entt::SparseSet< Entity, Type >inline
    construct(const entity_type entity, Args &&... args)entt::SparseSet< Entity, Type >inline
    entt::SparseSet< Entity >::construct(const entity_type entity)entt::SparseSet< Entity >inline
    data() const ENTT_NOEXCEPTentt::SparseSet< Entity >inline
    destroy(const entity_type entity) overrideentt::SparseSet< Entity, Type >inlinevirtual
    empty() const ENTT_NOEXCEPTentt::SparseSet< Entity >inline
    end() const ENTT_NOEXCEPTentt::SparseSet< Entity, Type >inline
    end() ENTT_NOEXCEPTentt::SparseSet< Entity, Type >inline
    entity_type typedefentt::SparseSet< Entity, Type >
    extent() const ENTT_NOEXCEPTentt::SparseSet< Entity >inline
    fast(const entity_type entity) const ENTT_NOEXCEPTentt::SparseSet< Entity >inline
    get(const entity_type entity) const ENTT_NOEXCEPTentt::SparseSet< Entity, Type >inline
    get(const entity_type entity) ENTT_NOEXCEPTentt::SparseSet< Entity, Type >inline
    has(const entity_type entity) const ENTT_NOEXCEPTentt::SparseSet< Entity >inline
    iterator_type typedefentt::SparseSet< Entity, Type >
    object_type typedefentt::SparseSet< Entity, Type >
    operator=(const SparseSet &)=deleteentt::SparseSet< Entity, Type >
    operator=(SparseSet &&)=defaultentt::SparseSet< Entity, Type >
    operator[](const size_type pos) const ENTT_NOEXCEPTentt::SparseSet< Entity, Type >inline
    operator[](const size_type pos) ENTT_NOEXCEPTentt::SparseSet< Entity, Type >inline
    raw() const ENTT_NOEXCEPTentt::SparseSet< Entity, Type >inline
    raw() ENTT_NOEXCEPTentt::SparseSet< Entity, Type >inline
    reserve(const size_type cap)entt::SparseSet< Entity, Type >inline
    respect(const SparseSet< Entity > &other) ENTT_NOEXCEPTentt::SparseSet< Entity, Type >inline
    size() const ENTT_NOEXCEPTentt::SparseSet< Entity >inline
    size_type typedefentt::SparseSet< Entity, Type >
    sort(Compare compare, Sort sort=Sort{})entt::SparseSet< Entity, Type >inline
    sort(Compare compare, Sort sort=Sort{}, Args &&... args)entt::SparseSet< Entity, Type >inline
    SparseSet() ENTT_NOEXCEPT=defaultentt::SparseSet< Entity, Type >
    SparseSet(const SparseSet &)=deleteentt::SparseSet< Entity, Type >
    SparseSet(SparseSet &&)=defaultentt::SparseSet< Entity, Type >
    swap(const pos_type lhs, const pos_type rhs) ENTT_NOEXCEPTentt::SparseSet< Entity >inline
    swap(const size_type lhs, const size_type rhs) ENTT_NOEXCEPTentt::SparseSet< Entity >inline
    ~SparseSet() ENTT_NOEXCEPT=defaultentt::SparseSet< Entity >virtual
    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 9034d7353..7049f499d 100644 --- a/classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html +++ b/classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html @@ -104,10 +104,6 @@ using entity_type = typename underlying_type::entity_type  Underlying entity identifier.
      - -using pos_type = typename underlying_type::pos_type - Entity dependent position type.
    -  using size_type = typename underlying_type::size_type  Unsigned integer type.
    @@ -125,10 +121,6 @@ using entity_type = Entity  Underlying entity identifier.
      - -using pos_type = entity_type - Entity dependent position type.
    -  using size_type = std::size_t  Unsigned integer type.
    @@ -189,6 +181,12 @@ Public Member Functions iterator_type end () ENTT_NOEXCEPT  Returns an iterator to the end. More...
      +const object_type & operator[] (const size_type pos) const ENTT_NOEXCEPT + Returns a reference to the element at the given position. More...
    +  +object_type & operator[] (const size_type pos) ENTT_NOEXCEPT + Returns a reference to the element at the given position. More...
    +  const object_type & get (const entity_type entity) const ENTT_NOEXCEPT  Returns the object associated to an entity. More...
      @@ -206,10 +204,10 @@ Public Member Functions void destroy (const entity_type entity) override  Removes an entity from a sparse set and destroies its object. More...
      -template<typename Compare , typename Sort = StdSort> -void sort (Compare compare, Sort sort=Sort{}) - Sort components according to the given comparison function. More...
    -  +template<typename Compare , typename Sort = StdSort, typename... Args> +void sort (Compare compare, Sort sort=Sort{}, Args &&... args) + Sort components according to the given comparison function. More...
    +  void respect (const SparseSet< Entity > &other) ENTT_NOEXCEPT  Sort components according to the order of the entities in another sparse set. More...
      @@ -243,6 +241,9 @@ virtual void reserve (const size_type cap)  Increases the capacity of a sparse set. More...
      +size_type capacity () const ENTT_NOEXCEPT + Returns the number of elements that a sparse set has currently allocated space for. More...
    +  size_type extent () const ENTT_NOEXCEPT  Returns the extent of a sparse set. More...
      @@ -273,21 +274,24 @@ virtual iterator_type end () ENTT_NOEXCEPT  Returns an iterator to the end. More...
      +const entity_type & operator[] (const size_type pos) const ENTT_NOEXCEPT + Returns a reference to the element at the given position. More...
    +  bool has (const entity_type entity) const ENTT_NOEXCEPT  Checks if a sparse set contains an entity. More...
      bool fast (const entity_type entity) const ENTT_NOEXCEPT  Checks if a sparse set contains an entity (unsafe). More...
      -pos_type get (const entity_type entity) const ENTT_NOEXCEPT - Returns the position of an entity in a sparse set. More...
    -  +size_type get (const entity_type entity) const ENTT_NOEXCEPT + Returns the position of an entity in a sparse set. More...
    +  void construct (const entity_type entity)  Assigns an entity to a sparse set. More...
      -void swap (const pos_type lhs, const pos_type rhs) ENTT_NOEXCEPT - Swaps the position of two entities in the internal packed array. More...
    -  +void swap (const size_type lhs, const size_type rhs) ENTT_NOEXCEPT + Swaps the position of two entities in the internal packed array. More...
    +  void respect (const SparseSet< Entity > &other) ENTT_NOEXCEPT  Sort entities according to their order in another sparse set. More...
      @@ -310,7 +314,7 @@ Internal data structures arrange elements to maximize performance. Because of th -

    Definition at line 501 of file sparse_set.hpp.

    +

    Definition at line 573 of file sparse_set.hpp.

    Member Function Documentation

    ◆ begin() [1/2]

    @@ -342,7 +346,7 @@ template<typename Entity , typename Type >
    Note
    Input iterators stay true to the order imposed by a call to either sort or respect.
    Returns
    An iterator to the first instance of the given type.
    -

    Definition at line 661 of file sparse_set.hpp.

    +

    Definition at line 785 of file sparse_set.hpp.

    @@ -376,7 +380,7 @@ template<typename Entity , typename Type >
    Note
    Input iterators stay true to the order imposed by a call to either sort or respect.
    Returns
    An iterator to the first instance of the given type.
    -

    Definition at line 677 of file sparse_set.hpp.

    +

    Definition at line 801 of file sparse_set.hpp.

    @@ -410,7 +414,7 @@ template<typename Entity , typename Type >
    Note
    Input iterators stay true to the order imposed by a call to either sort or respect.
    Returns
    An iterator to the first instance of the given type.
    -

    Definition at line 645 of file sparse_set.hpp.

    +

    Definition at line 768 of file sparse_set.hpp.

    @@ -444,7 +448,7 @@ template<typename Entity , typename Type >
    Note
    Input iterators stay true to the order imposed by a call to either sort or respect.
    Returns
    An iterator to the element following the last instance of the given type.
    -

    Definition at line 695 of file sparse_set.hpp.

    +

    Definition at line 820 of file sparse_set.hpp.

    @@ -506,7 +510,7 @@ template<typename... Args>
    Returns
    The object associated to the entity.
    -

    Definition at line 789 of file sparse_set.hpp.

    +

    Definition at line 932 of file sparse_set.hpp.

    @@ -568,7 +572,7 @@ template<typename... Args>
    Returns
    The object associated to the entity.
    -

    Definition at line 817 of file sparse_set.hpp.

    +

    Definition at line 960 of file sparse_set.hpp.

    @@ -610,7 +614,7 @@ template<typename Entity , typename Type >

    Reimplemented from entt::SparseSet< Entity >.

    -

    Definition at line 834 of file sparse_set.hpp.

    +

    Definition at line 977 of file sparse_set.hpp.

    @@ -644,7 +648,7 @@ template<typename Entity , typename Type >
    Note
    Input iterators stay true to the order imposed by a call to either sort or respect.
    Returns
    An iterator to the element following the last instance of the given type.
    -

    Definition at line 713 of file sparse_set.hpp.

    +

    Definition at line 838 of file sparse_set.hpp.

    @@ -678,7 +682,7 @@ template<typename Entity , typename Type >
    Note
    Input iterators stay true to the order imposed by a call to either sort or respect.
    Returns
    An iterator to the element following the last instance of the given type.
    -

    Definition at line 731 of file sparse_set.hpp.

    +

    Definition at line 856 of file sparse_set.hpp.

    @@ -719,7 +723,7 @@ template<typename Entity , typename Type >
    Returns
    The object associated to the entity.
    -

    Definition at line 747 of file sparse_set.hpp.

    +

    Definition at line 890 of file sparse_set.hpp.

    @@ -760,7 +764,7 @@ template<typename Entity , typename Type >
    Returns
    The object associated to the entity.
    -

    Definition at line 763 of file sparse_set.hpp.

    +

    Definition at line 906 of file sparse_set.hpp.

    @@ -824,6 +828,84 @@ template<typename Entity , typename Type >

    Default move assignment operator.

    Returns
    This sparse set.
    + + + +

    ◆ operator[]() [1/2]

    + +
    +
    +
    +template<typename Entity , typename Type >
    + + + + + +
    + + + + + + + + +
    const object_type& entt::SparseSet< Entity, Type >::operator[] (const size_type pos) const
    +     		+inline
    +
    + +

    Returns a reference to the element at the given position.

    +
    Parameters
    + + +
    posPosition of the element to return.
    +
    +
    +
    Returns
    A reference to the requested element.
    + +

    Definition at line 865 of file sparse_set.hpp.

    + +
    +
    + +

    ◆ operator[]() [2/2]

    + +
    +
    +
    +template<typename Entity , typename Type >
    + + + + + +
    + + + + + + + + +
    object_type& entt::SparseSet< Entity, Type >::operator[] (const size_type pos)
    +     		+inline
    +
    + +

    Returns a reference to the element at the given position.

    +
    Parameters
    + + +
    posPosition of the element to return.
    +
    +
    +
    Returns
    A reference to the requested element.
    + +

    Definition at line 874 of file sparse_set.hpp.

    +
    @@ -856,7 +938,7 @@ template<typename Entity , typename Type >
    Note
    There are no guarantees on the order, even though either sort or respect has been previously invoked. Internal data structures arrange elements to maximize performance. Accessing them directly gives a performance boost but less guarantees. Use begin and end if you want to iterate the sparse set in the expected order.
    Returns
    A pointer to the array of objects.
    -

    Definition at line 610 of file sparse_set.hpp.

    +

    Definition at line 733 of file sparse_set.hpp.

    @@ -890,7 +972,7 @@ template<typename Entity , typename Type >
    Note
    There are no guarantees on the order, even though either sort or respect has been previously invoked. Internal data structures arrange elements to maximize performance. Accessing them directly gives a performance boost but less guarantees. Use begin and end if you want to iterate the sparse set in the expected order.
    Returns
    A pointer to the array of objects.
    -

    Definition at line 629 of file sparse_set.hpp.

    +

    Definition at line 752 of file sparse_set.hpp.

    @@ -929,7 +1011,7 @@ template<typename Entity , typename Type > -

    Definition at line 590 of file sparse_set.hpp.

    +

    Definition at line 713 of file sparse_set.hpp.

    @@ -971,19 +1053,19 @@ template<typename Entity , typename Type > -

    Definition at line 930 of file sparse_set.hpp.

    +

    Definition at line 1075 of file sparse_set.hpp.

    - -

    ◆ sort()

    + +

    ◆ sort()

    template<typename Entity , typename Type >
    -template<typename Compare , typename Sort = StdSort>
    +template<typename Compare , typename Sort = StdSort, typename... Args>
    - + + + + + + + @@ -1029,6 +1117,7 @@ template<typename Compare , typename Sort = StdSort>
    @@ -998,7 +1080,13 @@ template<typename Compare , typename Sort = StdSort> Sort sort = Sort{} sort = Sort{},
    Args &&... args 
    +
    CompareType of comparison function object.
    SortType of sort function object.
    ArgsTypes of arguments to forward to the sort function object.
    @@ -1036,11 +1125,12 @@ template<typename Compare , typename Sort = StdSort>
    +
    compareA valid comparison function object.
    sortA valid sort function object.
    argsArguments to forward to the sort function object, if any.
    -

    Definition at line 883 of file sparse_set.hpp.

    +

    Definition at line 1028 of file sparse_set.hpp.

    diff --git a/classentt_1_1SparseSet_3_01Entity_01_4-members.html b/classentt_1_1SparseSet_3_01Entity_01_4-members.html index 3c91f7475..ac8dd42b4 100644 --- a/classentt_1_1SparseSet_3_01Entity_01_4-members.html +++ b/classentt_1_1SparseSet_3_01Entity_01_4-members.html @@ -72,34 +72,35 @@ $(function() { - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    begin() const ENTT_NOEXCEPTentt::SparseSet< Entity >inline
    begin() ENTT_NOEXCEPTentt::SparseSet< Entity >inline
    cbegin() const ENTT_NOEXCEPTentt::SparseSet< Entity >inline
    cend() const ENTT_NOEXCEPTentt::SparseSet< Entity >inline
    const_iterator_type typedefentt::SparseSet< Entity >
    construct(const entity_type entity)entt::SparseSet< Entity >inline
    data() const ENTT_NOEXCEPTentt::SparseSet< Entity >inline
    destroy(const entity_type entity)entt::SparseSet< Entity >inlinevirtual
    empty() const ENTT_NOEXCEPTentt::SparseSet< Entity >inline
    end() const ENTT_NOEXCEPTentt::SparseSet< Entity >inline
    end() ENTT_NOEXCEPTentt::SparseSet< Entity >inline
    entity_type typedefentt::SparseSet< Entity >
    extent() const ENTT_NOEXCEPTentt::SparseSet< Entity >inline
    fast(const entity_type entity) const ENTT_NOEXCEPTentt::SparseSet< Entity >inline
    get(const entity_type entity) const ENTT_NOEXCEPTentt::SparseSet< Entity >inline
    has(const entity_type entity) const ENTT_NOEXCEPTentt::SparseSet< Entity >inline
    iterator_type typedefentt::SparseSet< Entity >
    operator=(const SparseSet &)=deleteentt::SparseSet< Entity >
    operator=(SparseSet &&)=defaultentt::SparseSet< Entity >
    pos_type typedefentt::SparseSet< Entity >
    reserve(const size_type cap)entt::SparseSet< Entity >inline
    reset()entt::SparseSet< Entity >inlinevirtual
    respect(const SparseSet< Entity > &other) ENTT_NOEXCEPTentt::SparseSet< Entity >inline
    size() const ENTT_NOEXCEPTentt::SparseSet< Entity >inline
    size_type typedefentt::SparseSet< Entity >
    SparseSet() ENTT_NOEXCEPT=defaultentt::SparseSet< Entity >
    SparseSet(const SparseSet &)=deleteentt::SparseSet< Entity >
    SparseSet(SparseSet &&)=defaultentt::SparseSet< Entity >
    swap(const pos_type lhs, const pos_type rhs) ENTT_NOEXCEPTentt::SparseSet< Entity >inline
    ~SparseSet() ENTT_NOEXCEPT=defaultentt::SparseSet< Entity >virtual
    capacity() const ENTT_NOEXCEPTentt::SparseSet< Entity >inline
    cbegin() const ENTT_NOEXCEPTentt::SparseSet< Entity >inline
    cend() const ENTT_NOEXCEPTentt::SparseSet< Entity >inline
    const_iterator_type typedefentt::SparseSet< Entity >
    construct(const entity_type entity)entt::SparseSet< Entity >inline
    data() const ENTT_NOEXCEPTentt::SparseSet< Entity >inline
    destroy(const entity_type entity)entt::SparseSet< Entity >inlinevirtual
    empty() const ENTT_NOEXCEPTentt::SparseSet< Entity >inline
    end() const ENTT_NOEXCEPTentt::SparseSet< Entity >inline
    end() ENTT_NOEXCEPTentt::SparseSet< Entity >inline
    entity_type typedefentt::SparseSet< Entity >
    extent() const ENTT_NOEXCEPTentt::SparseSet< Entity >inline
    fast(const entity_type entity) const ENTT_NOEXCEPTentt::SparseSet< Entity >inline
    get(const entity_type entity) const ENTT_NOEXCEPTentt::SparseSet< Entity >inline
    has(const entity_type entity) const ENTT_NOEXCEPTentt::SparseSet< Entity >inline
    iterator_type typedefentt::SparseSet< Entity >
    operator=(const SparseSet &)=deleteentt::SparseSet< Entity >
    operator=(SparseSet &&)=defaultentt::SparseSet< Entity >
    operator[](const size_type pos) const ENTT_NOEXCEPTentt::SparseSet< Entity >inline
    reserve(const size_type cap)entt::SparseSet< Entity >inline
    reset()entt::SparseSet< Entity >inlinevirtual
    respect(const SparseSet< Entity > &other) ENTT_NOEXCEPTentt::SparseSet< Entity >inline
    size() const ENTT_NOEXCEPTentt::SparseSet< Entity >inline
    size_type typedefentt::SparseSet< Entity >
    SparseSet() ENTT_NOEXCEPT=defaultentt::SparseSet< Entity >
    SparseSet(const SparseSet &)=deleteentt::SparseSet< Entity >
    SparseSet(SparseSet &&)=defaultentt::SparseSet< Entity >
    swap(const size_type lhs, const size_type rhs) ENTT_NOEXCEPTentt::SparseSet< Entity >inline
    ~SparseSet() ENTT_NOEXCEPT=defaultentt::SparseSet< Entity >virtual
    diff --git a/classentt_1_1SparseSet_3_01Entity_01_4.html b/classentt_1_1SparseSet_3_01Entity_01_4.html index 4398356a2..a09f61fae 100644 --- a/classentt_1_1SparseSet_3_01Entity_01_4.html +++ b/classentt_1_1SparseSet_3_01Entity_01_4.html @@ -92,10 +92,6 @@ Public Types using entity_type = Entity  Underlying entity identifier.
      - -using pos_type = entity_type - Entity dependent position type.
    -  using size_type = std::size_t  Unsigned integer type.
    @@ -136,6 +132,9 @@ virtual void reserve (const size_type cap)  Increases the capacity of a sparse set. More...
      +size_type capacity () const ENTT_NOEXCEPT + Returns the number of elements that a sparse set has currently allocated space for. More...
    +  size_type extent () const ENTT_NOEXCEPT  Returns the extent of a sparse set. More...
      @@ -166,24 +165,27 @@ virtual iterator_type end () ENTT_NOEXCEPT  Returns an iterator to the end. More...
      +const entity_type & operator[] (const size_type pos) const ENTT_NOEXCEPT + Returns a reference to the element at the given position. More...
    +  bool has (const entity_type entity) const ENTT_NOEXCEPT  Checks if a sparse set contains an entity. More...
      bool fast (const entity_type entity) const ENTT_NOEXCEPT  Checks if a sparse set contains an entity (unsafe). More...
      -pos_type get (const entity_type entity) const ENTT_NOEXCEPT - Returns the position of an entity in a sparse set. More...
    -  +size_type get (const entity_type entity) const ENTT_NOEXCEPT + Returns the position of an entity in a sparse set. More...
    +  void construct (const entity_type entity)  Assigns an entity to a sparse set. More...
      virtual void destroy (const entity_type entity)  Removes an entity from a sparse set. More...
      -void swap (const pos_type lhs, const pos_type rhs) ENTT_NOEXCEPT - Swaps the position of two entities in the internal packed array. More...
    -  +void swap (const size_type lhs, const size_type rhs) ENTT_NOEXCEPT + Swaps the position of two entities in the internal packed array. More...
    +  void respect (const SparseSet< Entity > &other) ENTT_NOEXCEPT  Sort entities according to their order in another sparse set. More...
      @@ -211,7 +213,7 @@ Internal data structures arrange elements to maximize performance. Because of th -

    Definition at line 59 of file sparse_set.hpp.

    +

    Definition at line 60 of file sparse_set.hpp.

    Member Function Documentation

    ◆ begin() [1/2]

    @@ -243,7 +245,7 @@ template<typename Entity >
    Note
    Input iterators stay true to the order imposed by a call to respect.
    Returns
    An iterator to the first entity of the internal packed array.
    -

    Definition at line 233 of file sparse_set.hpp.

    +

    Definition at line 296 of file sparse_set.hpp.

    @@ -277,7 +279,39 @@ template<typename Entity >
    Note
    Input iterators stay true to the order imposed by a call to respect.
    Returns
    An iterator to the first entity of the internal packed array.
    -

    Definition at line 249 of file sparse_set.hpp.

    +

    Definition at line 312 of file sparse_set.hpp.

    + + + + +

    ◆ capacity()

    + +
    +
    +
    +template<typename Entity >
    + + + + + +
    + + + + + + + +
    size_type entt::SparseSet< Entity >::capacity () const
    +     		+inline
    +
    + +

    Returns the number of elements that a sparse set has currently allocated space for.

    +
    Returns
    Capacity of the sparse set.
    + +

    Definition at line 208 of file sparse_set.hpp.

    @@ -311,7 +345,7 @@ template<typename Entity >
    Note
    Input iterators stay true to the order imposed by a call to respect.
    Returns
    An iterator to the first entity of the internal packed array.
    -

    Definition at line 217 of file sparse_set.hpp.

    +

    Definition at line 279 of file sparse_set.hpp.

    @@ -345,7 +379,7 @@ template<typename Entity >
    Note
    Input iterators stay true to the order imposed by a call to respect.
    Returns
    An iterator to the element following the last entity of the internal packed array.
    -

    Definition at line 266 of file sparse_set.hpp.

    +

    Definition at line 329 of file sparse_set.hpp.

    @@ -385,7 +419,7 @@ template<typename Entity > -

    Definition at line 367 of file sparse_set.hpp.

    +

    Definition at line 439 of file sparse_set.hpp.

    @@ -419,7 +453,7 @@ template<typename Entity >
    Note
    There are no guarantees on the order, even though respect has been previously invoked. Internal data structures arrange elements to maximize performance. Accessing them directly gives a performance boost but less guarantees. Use begin and end if you want to iterate the sparse set in the expected order.
    Returns
    A pointer to the internal packed array.
    -

    Definition at line 201 of file sparse_set.hpp.

    +

    Definition at line 263 of file sparse_set.hpp.

    @@ -461,7 +495,7 @@ template<typename Entity >

    Reimplemented in entt::SparseSet< Entity, Type >.

    -

    Definition at line 391 of file sparse_set.hpp.

    +

    Definition at line 463 of file sparse_set.hpp.

    @@ -493,7 +527,7 @@ template<typename Entity >

    Checks whether a sparse set is empty.

    Returns
    True if the sparse set is empty, false otherwise.
    -

    Definition at line 182 of file sparse_set.hpp.

    +

    Definition at line 244 of file sparse_set.hpp.

    @@ -527,7 +561,7 @@ template<typename Entity >
    Note
    Input iterators stay true to the order imposed by a call to respect.
    Returns
    An iterator to the element following the last entity of the internal packed array.
    -

    Definition at line 283 of file sparse_set.hpp.

    +

    Definition at line 346 of file sparse_set.hpp.

    @@ -561,7 +595,7 @@ template<typename Entity >
    Note
    Input iterators stay true to the order imposed by a call to respect.
    Returns
    An iterator to the element following the last entity of the internal packed array.
    -

    Definition at line 300 of file sparse_set.hpp.

    +

    Definition at line 363 of file sparse_set.hpp.

    @@ -594,7 +628,7 @@ template<typename Entity >

    The extent of a sparse set is also the size of the internal sparse array. There is no guarantee that the internal packed array has the same size. Usually the size of the internal sparse array is equal or greater than the one of the internal packed array.

    Returns
    Extent of the sparse set.
    -

    Definition at line 160 of file sparse_set.hpp.

    +

    Definition at line 222 of file sparse_set.hpp.

    @@ -637,12 +671,12 @@ template<typename Entity >
    Returns
    True if the sparse set contains the entity, false otherwise.
    -

    Definition at line 332 of file sparse_set.hpp.

    +

    Definition at line 404 of file sparse_set.hpp.

    - -

    ◆ get()

    + +

    ◆ get()

    @@ -653,7 +687,7 @@ template<typename Entity >
    - + @@ -678,7 +712,7 @@ template<typename Entity >
    Returns
    The position of the entity in the sparse set.
    -

    Definition at line 351 of file sparse_set.hpp.

    +

    Definition at line 423 of file sparse_set.hpp.

    @@ -717,7 +751,7 @@ template<typename Entity >
    Returns
    True if the sparse set contains the entity, false otherwise.
    -

    Definition at line 309 of file sparse_set.hpp.

    +

    Definition at line 381 of file sparse_set.hpp.

    @@ -781,6 +815,45 @@ template<typename Entity >

    Default move assignment operator.

    Returns
    This sparse set.
    + + + +

    ◆ operator[]()

    + +
    +
    +
    +template<typename Entity >
    +
    pos_type entt::SparseSet< Entity >::get size_type entt::SparseSet< Entity >::get ( const entity_type  entity)
    + + + + +
    + + + + + + + + +
    const entity_type& entt::SparseSet< Entity >::operator[] (const size_type pos) const
    +     		+inline
    +
    + +

    Returns a reference to the element at the given position.

    +
    Parameters
    + + +
    posPosition of the element to return.
    +
    +
    +
    Returns
    A reference to the requested element.
    + +

    Definition at line 372 of file sparse_set.hpp.

    +
    @@ -818,7 +891,7 @@ template<typename Entity > -

    Definition at line 146 of file sparse_set.hpp.

    +

    Definition at line 199 of file sparse_set.hpp.

    @@ -860,7 +933,7 @@ template<typename Entity > -

    Definition at line 445 of file sparse_set.hpp.

    +

    Definition at line 517 of file sparse_set.hpp.

    @@ -893,12 +966,12 @@ template<typename Entity >

    The number of elements is also the size of the internal packed array. There is no guarantee that the internal sparse array has the same size. Usually the size of the internal sparse array is equal or greater than the one of the internal packed array.

    Returns
    Number of elements.
    -

    Definition at line 174 of file sparse_set.hpp.

    +

    Definition at line 236 of file sparse_set.hpp.

    - -

    ◆ swap()

    + +

    ◆ swap()

    @@ -911,13 +984,13 @@ template<typename Entity >
    void entt::SparseSet< Entity >::swap ( - const pos_type  + const size_type  lhs, - const pos_type  + const size_type  rhs  @@ -945,7 +1018,7 @@ template<typename Entity >
    -

    Definition at line 417 of file sparse_set.hpp.

    +

    Definition at line 489 of file sparse_set.hpp.

    diff --git a/classentt_1_1View.html b/classentt_1_1View.html index 46e6b3ce6..4133103cc 100644 --- a/classentt_1_1View.html +++ b/classentt_1_1View.html @@ -81,14 +81,6 @@ $(function() { - - - - - - @@ -97,6 +89,14 @@ using  + + + + + +

    Public Types

    -using iterator_type = Iterator
     Input iterator type.
     
    -using const_iterator_type = Iterator
     Constant input iterator type.
     
    using entity_type = typename view_type::entity_type
     Underlying entity identifier.
    size_type = typename view_type::size_type
     Unsigned integer type.
     
    +using iterator_type = Iterator
     Input iterator type.
     
    +using const_iterator_type = Iterator
     Constant input iterator type.
     
    @@ -179,7 +179,9 @@ class entt::View< Entity, Component >
    PersistentView
    -RawView
    +RawView +
    +RuntimeView
    Template Parameters

    Public Member Functions

    @@ -188,7 +190,7 @@ class entt::View< Entity, Component > -

    Definition at line 453 of file view.hpp.

    +

    Definition at line 466 of file view.hpp.

    Member Function Documentation

    ◆ begin() [1/2]

    @@ -220,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 669 of file view.hpp.

    +

    Definition at line 681 of file view.hpp.

    @@ -254,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 687 of file view.hpp.

    +

    Definition at line 699 of file view.hpp.

    @@ -288,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 650 of file view.hpp.

    +

    Definition at line 662 of file view.hpp.

    @@ -322,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 706 of file view.hpp.

    +

    Definition at line 718 of file view.hpp.

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

    Definition at line 754 of file view.hpp.

    +

    Definition at line 766 of file view.hpp.

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

    Definition at line 869 of file view.hpp.

    +

    Definition at line 882 of file view.hpp.

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

    Definition at line 893 of file view.hpp.

    +

    Definition at line 906 of file view.hpp.

    @@ -489,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 632 of file view.hpp.

    +

    Definition at line 644 of file view.hpp.

    @@ -523,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 726 of file view.hpp.

    +

    Definition at line 738 of file view.hpp.

    @@ -557,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 745 of file view.hpp.

    +

    Definition at line 757 of file view.hpp.

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

    Definition at line 777 of file view.hpp.

    +

    Definition at line 790 of file view.hpp.

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

    Definition at line 800 of file view.hpp.

    +

    Definition at line 813 of file view.hpp.

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

    Definition at line 823 of file view.hpp.

    +

    Definition at line 836 of file view.hpp.

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

    Definition at line 847 of file view.hpp.

    +

    Definition at line 860 of file view.hpp.

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

    +

    Definition at line 636 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 cd81bc025..9521190b0 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 @@ -86,12 +86,13 @@ $(function() { - - - - - - + + + + + + +
    EntityA valid entity type (see entt_traits for more details).
    get(const entity_type entity) const ENTT_NOEXCEPTentt::View< Entity, Component >inline
    get(const entity_type entity) ENTT_NOEXCEPTentt::View< Entity, Component >inline
    iterator_type typedefentt::View< Entity, Component >
    raw() const ENTT_NOEXCEPTentt::View< Entity, Component >inline
    raw() ENTT_NOEXCEPTentt::View< Entity, Component >inline
    raw_type typedefentt::View< Entity, Component >
    Registry< Entity > classentt::View< Entity, Component >friend
    size() const ENTT_NOEXCEPTentt::View< Entity, Component >inline
    size_type typedefentt::View< Entity, Component >
    operator[](const size_type pos) const ENTT_NOEXCEPTentt::View< Entity, Component >inline
    raw() const ENTT_NOEXCEPTentt::View< Entity, Component >inline
    raw() ENTT_NOEXCEPTentt::View< Entity, Component >inline
    raw_type typedefentt::View< Entity, Component >
    Registry< Entity > classentt::View< Entity, Component >friend
    size() const ENTT_NOEXCEPTentt::View< Entity, Component >inline
    size_type typedefentt::View< Entity, Component >
    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 35b2ba036..6623209c2 100644 --- a/classentt_1_1View_3_01Entity_00_01Component_01_4.html +++ b/classentt_1_1View_3_01Entity_00_01Component_01_4.html @@ -80,14 +80,10 @@ $(function() { - - - - - - + + + @@ -96,10 +92,14 @@ using  - - - + + + + + +

    Public Types

    -using iterator_type = typename view_type::iterator_type
     Input iterator type.
     
    -using const_iterator_type = typename view_type::const_iterator_type
     Constant input iterator type.
     
    +using raw_type = typename pool_type::object_type
     Type of component iterated by the view.
     
    using entity_type = typename pool_type::entity_type
     Underlying entity identifier.
    size_type = typename pool_type::size_type
     Unsigned integer type.
     
    -using raw_type = typename pool_type::object_type
     Type of component iterated by the view.
     
    +using iterator_type = typename view_type::iterator_type
     Input iterator type.
     
    +using const_iterator_type = typename view_type::const_iterator_type
     Constant input iterator type.
     
    @@ -136,6 +136,9 @@ Public Member Functions + + + @@ -181,7 +184,9 @@ class entt::View< Entity, Component >
    PersistentView
    -RawView
    +RawView +
    +RuntimeView
    Template Parameters

    Public Member Functions

    iterator_type end () ENTT_NOEXCEPT
     Returns an iterator that is past the last entity that has the given component. More...
     
    const entity_type & operator[] (const size_type pos) const ENTT_NOEXCEPT
     Returns a reference to the element at the given position. More...
     
    bool contains (const entity_type entity) const ENTT_NOEXCEPT
     Checks if a view contains an entity. More...
     
    @@ -190,7 +195,7 @@ class entt::View< Entity, Component > -

    Definition at line 942 of file view.hpp.

    +

    Definition at line 956 of file view.hpp.

    Member Function Documentation

    ◆ begin() [1/2]

    @@ -222,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 1061 of file view.hpp.

    +

    Definition at line 1075 of file view.hpp.

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

    +

    Definition at line 1093 of file view.hpp.

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

    +

    Definition at line 1057 of file view.hpp.

    @@ -324,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 1098 of file view.hpp.

    +

    Definition at line 1112 of file view.hpp.

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

    Definition at line 1145 of file view.hpp.

    +

    Definition at line 1168 of file view.hpp.

    @@ -397,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 1025 of file view.hpp.

    +

    Definition at line 1039 of file view.hpp.

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

    Definition at line 1204 of file view.hpp.

    +

    Definition at line 1227 of file view.hpp.

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

    Definition at line 1226 of file view.hpp.

    +

    Definition at line 1249 of file view.hpp.

    @@ -525,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 977 of file view.hpp.

    +

    Definition at line 991 of file view.hpp.

    @@ -559,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 1117 of file view.hpp.

    +

    Definition at line 1131 of file view.hpp.

    @@ -593,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 1136 of file view.hpp.

    +

    Definition at line 1150 of file view.hpp.

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

    Definition at line 1164 of file view.hpp.

    +

    Definition at line 1187 of file view.hpp.

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

    Definition at line 1184 of file view.hpp.

    +

    Definition at line 1207 of file view.hpp.

    + + + + +

    ◆ operator[]()

    + +
    +
    +
    +template<typename Entity , typename Component >
    +
    EntityA valid entity type (see entt_traits for more details).
    + + + + +
    + + + + + + + + +
    const entity_type& entt::View< Entity, Component >::operator[] (const size_type pos) const
    +     		+inline
    +
    + +

    Returns a reference to the element at the given position.

    +
    Parameters
    + + +
    posPosition of the element to return.
    +
    +
    +
    Returns
    A reference to the requested element.
    + +

    Definition at line 1159 of file view.hpp.

    @@ -711,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 993 of file view.hpp.

    +

    Definition at line 1007 of file view.hpp.

    @@ -745,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 1009 of file view.hpp.

    +

    Definition at line 1023 of file view.hpp.

    @@ -777,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 969 of file view.hpp.

    +

    Definition at line 983 of file view.hpp.

    diff --git a/classes.html b/classes.html index 09deb0108..4d4b69a54 100644 --- a/classes.html +++ b/classes.html @@ -63,38 +63,41 @@ $(function() {
    Class Index
    -
    a | b | c | d | e | f | h | i | p | r | s | t | v
    +
    a | b | c | d | e | f | h | i | m | p | r | s | t | v
    - + - + - + + - - + - - + + - - - + + + + + +
      a  
    -    		Dispatcher (entt)   
      i  
    -    		Registry (entt)   SparseSet (entt)   
      e  
    +
      e  
    +    		InsertionSort (entt)   Registry (entt)   SparseSet (entt)   
      m  
    		ResourceCache (entt)   SparseSet< Entity > (entt)   
    Actor (entt)   InsertionSort (entt)   ResourceHandle (entt)   SparseSet< Entity, Type > (entt)   
    Actor (entt)   Emitter (entt)   ResourceHandle (entt)   SparseSet< Entity, Type > (entt)   
      b  
    -    		Emitter (entt)   
      p  
    -    		ResourceLoader (entt)   StdSort (entt)   
    entt_traits (entt)   
      s  
    -
      t  
    +    		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  
    break_t (entt)   entt_traits< std::uint16_t > (entt)   persistent_t (entt)   
      c  
    -    		entt_traits< std::uint32_t > (entt)   PersistentView (entt)   Scheduler (entt)   tag_t (entt)   
    entt_traits< std::uint64_t > (entt)   Process (entt)   ServiceLocator (entt)   
      v  
    +    		entt_traits< std::uint64_t > (entt)   persistent_t (entt)   tag_t (entt)   
      f  
    +    		PersistentView (entt)   Scheduler (entt)   
      v  
    Emitter::Connection (entt)   
      f  
    -    		ProcessAdaptor (entt)   SigH (entt)   
    ContinuousLoader (entt)   Prototype (entt)   SigH< Ret(Args...), Collector > (entt)   View (entt)   
    Emitter::Connection (entt)   Process (entt)   ServiceLocator (entt)   
    ContinuousLoader (entt)   Family (entt)   ProcessAdaptor (entt)   SigH (entt)   View (entt)   
      d  
    -    		Family (entt)   
      r  
    -    		Sink (entt)   View< Entity, Component > (entt)   
      h  
    -    		Sink< Ret(Args...)> (entt)   
    Delegate (entt)   raw_t (entt)   Snapshot (entt)   
    Delegate< Ret(Args...)> (entt)   HashedString (entt)   RawView (entt)   SnapshotLoader (entt)   
      h  
    +    		Prototype (entt)   SigH< Ret(Args...), Collector > (entt)   View< Entity, Component > (entt)   
      r  
    +    		Sink (entt)   
    Delegate (entt)   HashedString (entt)   Sink< Ret(Args...)> (entt)   
    Delegate< Ret(Args...)> (entt)   
      i  
    +    		raw_t (entt)   Snapshot (entt)   
    Dispatcher (entt)   RawView (entt)   SnapshotLoader (entt)   
    Identifier (entt)   
    -
    a | b | c | d | e | f | h | i | p | r | s | t | v
    +
    a | b | c | d | e | f | h | i | m | p | r | s | t | v
    diff --git a/config_8h_source.html b/config_8h_source.html index 030fac878..fe79c5c0a 100644 --- a/config_8h_source.html +++ b/config_8h_source.html @@ -67,7 +67,7 @@ $(function() {
    config.h
    -
    1 #ifndef ENTT_CONFIG_CONFIG_H
    2 #define ENTT_CONFIG_CONFIG_H
    3 
    4 
    5 #ifndef ENTT_NOEXCEPT
    6 #define ENTT_NOEXCEPT noexcept
    7 #endif
    8 
    9 
    10 #endif // ENTT_CONFIG_CONFIG_H
    +
    1 #ifndef ENTT_CONFIG_CONFIG_H
    2 #define ENTT_CONFIG_CONFIG_H
    3 
    4 
    5 #ifndef ENTT_NOEXCEPT
    6 #define ENTT_NOEXCEPT noexcept
    7 #endif // ENTT_NOEXCEPT
    8 
    9 
    10 #ifndef ENTT_HS_SUFFIX
    11 #define ENTT_HS_SUFFIX _hs
    12 #endif // ENTT_HS_SUFFIX
    13 
    14 
    15 
    16 #endif // ENTT_CONFIG_CONFIG_H
    Generated by   diff --git a/delegate_8hpp_source.html b/delegate_8hpp_source.html index 079f50636..5ce3f044d 100644 --- a/delegate_8hpp_source.html +++ b/delegate_8hpp_source.html @@ -67,15 +67,16 @@ $(function() {
    delegate.hpp
    -
    1 #ifndef ENTT_SIGNAL_DELEGATE_HPP
    2 #define ENTT_SIGNAL_DELEGATE_HPP
    3 
    4 
    5 #include <utility>
    6 #include "../config/config.h"
    7 
    8 
    9 namespace entt {
    10 
    11 
    18 template<typename>
    19 class Delegate;
    20 
    21 
    35 template<typename Ret, typename... Args>
    36 class Delegate<Ret(Args...)> final {
    37  using proto_type = Ret(*)(void *, Args...);
    38  using stub_type = std::pair<void *, proto_type>;
    39 
    40  static Ret fallback(void *, Args...) ENTT_NOEXCEPT { return {}; }
    41 
    42  template<Ret(*Function)(Args...)>
    43  static Ret proto(void *, Args... args) {
    44  return (Function)(args...);
    45  }
    46 
    47  template<typename Class, Ret(Class:: *Member)(Args...)>
    48  static Ret proto(void *instance, Args... args) {
    49  return (static_cast<Class *>(instance)->*Member)(args...);
    50  }
    51 
    52 public:
    54  Delegate() ENTT_NOEXCEPT
    55  : stub{std::make_pair(nullptr, &fallback)}
    56  {}
    57 
    62  template<Ret(*Function)(Args...)>
    63  void connect() ENTT_NOEXCEPT {
    64  stub = std::make_pair(nullptr, &proto<Function>);
    65  }
    66 
    78  template<typename Class, Ret(Class:: *Member)(Args...)>
    79  void connect(Class *instance) ENTT_NOEXCEPT {
    80  stub = std::make_pair(instance, &proto<Class, Member>);
    81  }
    82 
    88  void reset() ENTT_NOEXCEPT {
    89  stub = std::make_pair(nullptr, &fallback);
    90  }
    91 
    97  Ret operator()(Args... args) const {
    98  return stub.second(stub.first, args...);
    99  }
    100 
    109  bool operator==(const Delegate<Ret(Args...)> &other) const ENTT_NOEXCEPT {
    110  return stub.first == other.stub.first && stub.second == other.stub.second;
    111  }
    112 
    113 private:
    114  stub_type stub;
    115 };
    116 
    117 
    129 template<typename Ret, typename... Args>
    130 bool operator!=(const Delegate<Ret(Args...)> &lhs, const Delegate<Ret(Args...)> &rhs) ENTT_NOEXCEPT {
    131  return !(lhs == rhs);
    132 }
    133 
    134 
    135 }
    136 
    137 
    138 #endif // ENTT_SIGNAL_DELEGATE_HPP
    entt::operator!=
    constexpr bool operator!=(const HashedString &lhs, const HashedString &rhs) ENTT_NOEXCEPT
    Compares two hashed strings.
    Definition: hashed_string.hpp:103
    -
    entt::Delegate< Ret(Args...)>::connect
    void connect() ENTT_NOEXCEPT
    Binds a free function to a delegate.
    Definition: delegate.hpp:63
    -
    entt::Delegate< Ret(Args...)>::operator()
    Ret operator()(Args... args) const
    Triggers a delegate.
    Definition: delegate.hpp:97
    +
    1 #ifndef ENTT_SIGNAL_DELEGATE_HPP
    2 #define ENTT_SIGNAL_DELEGATE_HPP
    3 
    4 
    5 #include <utility>
    6 #include "../config/config.h"
    7 
    8 
    9 namespace entt {
    10 
    11 
    18 template<typename>
    19 class Delegate;
    20 
    21 
    35 template<typename Ret, typename... Args>
    36 class Delegate<Ret(Args...)> final {
    37  using proto_fn_type = Ret(void *, Args...);
    38  using stub_type = std::pair<void *, proto_fn_type *>;
    39 
    40  template<Ret(*Function)(Args...)>
    41  static Ret proto(void *, Args... args) {
    42  return (Function)(args...);
    43  }
    44 
    45  template<typename Class, Ret(Class:: *Member)(Args...)>
    46  static Ret proto(void *instance, Args... args) {
    47  return (static_cast<Class *>(instance)->*Member)(args...);
    48  }
    49 
    50 public:
    52  Delegate() ENTT_NOEXCEPT
    53  : stub{}
    54  {}
    55 
    60  bool empty() const ENTT_NOEXCEPT {
    61  // no need to test also stub.first
    62  return !stub.second;
    63  }
    64 
    69  template<Ret(*Function)(Args...)>
    70  void connect() ENTT_NOEXCEPT {
    71  stub = std::make_pair(nullptr, &proto<Function>);
    72  }
    73 
    85  template<typename Class, Ret(Class:: *Member)(Args...)>
    86  void connect(Class *instance) ENTT_NOEXCEPT {
    87  stub = std::make_pair(instance, &proto<Class, Member>);
    88  }
    89 
    95  void reset() ENTT_NOEXCEPT {
    96  stub.second = nullptr;
    97  }
    98 
    104  Ret operator()(Args... args) const {
    105  return stub.second(stub.first, args...);
    106  }
    107 
    116  bool operator==(const Delegate<Ret(Args...)> &other) const ENTT_NOEXCEPT {
    117  return stub.first == other.stub.first && stub.second == other.stub.second;
    118  }
    119 
    120 private:
    121  stub_type stub;
    122 };
    123 
    124 
    136 template<typename Ret, typename... Args>
    137 bool operator!=(const Delegate<Ret(Args...)> &lhs, const Delegate<Ret(Args...)> &rhs) ENTT_NOEXCEPT {
    138  return !(lhs == rhs);
    139 }
    140 
    141 
    142 }
    143 
    144 
    145 #endif // ENTT_SIGNAL_DELEGATE_HPP
    entt::operator!=
    constexpr bool operator!=(const HashedString &lhs, const HashedString &rhs) ENTT_NOEXCEPT
    Compares two hashed strings.
    Definition: hashed_string.hpp:103
    +
    entt::Delegate< Ret(Args...)>::connect
    void connect() ENTT_NOEXCEPT
    Binds a free function to a delegate.
    Definition: delegate.hpp:70
    +
    entt::Delegate< Ret(Args...)>::operator()
    Ret operator()(Args... args) const
    Triggers a delegate.
    Definition: delegate.hpp:104
    entt
    EnTT default namespace.
    Definition: algorithm.hpp:10
    entt::Delegate
    Basic delegate implementation.
    Definition: delegate.hpp:19
    -
    entt::Delegate< Ret(Args...)>::Delegate
    Delegate() ENTT_NOEXCEPT
    Default constructor.
    Definition: delegate.hpp:54
    -
    entt::Delegate< Ret(Args...)>::operator==
    bool operator==(const Delegate< Ret(Args...)> &other) const ENTT_NOEXCEPT
    Checks if the contents of the two delegates are different.
    Definition: delegate.hpp:109
    -
    entt::Delegate< Ret(Args...)>::reset
    void reset() ENTT_NOEXCEPT
    Resets a delegate.
    Definition: delegate.hpp:88
    -
    entt::Delegate< Ret(Args...)>::connect
    void connect(Class *instance) ENTT_NOEXCEPT
    Connects a member function for a given instance to a delegate.
    Definition: delegate.hpp:79
    +
    entt::Delegate< Ret(Args...)>::Delegate
    Delegate() ENTT_NOEXCEPT
    Default constructor.
    Definition: delegate.hpp:52
    +
    entt::Delegate< Ret(Args...)>::operator==
    bool operator==(const Delegate< Ret(Args...)> &other) const ENTT_NOEXCEPT
    Checks if the contents of the two delegates are different.
    Definition: delegate.hpp:116
    +
    entt::Delegate< Ret(Args...)>::empty
    bool empty() const ENTT_NOEXCEPT
    Checks whether a delegate actually stores a listener.
    Definition: delegate.hpp:60
    +
    entt::Delegate< Ret(Args...)>::reset
    void reset() ENTT_NOEXCEPT
    Resets a delegate.
    Definition: delegate.hpp:95
    +
    entt::Delegate< Ret(Args...)>::connect
    void connect(Class *instance) ENTT_NOEXCEPT
    Connects a member function for a given instance to a delegate.
    Definition: delegate.hpp:86
    diff --git a/entity_8hpp_source.html b/entity_8hpp_source.html new file mode 100644 index 000000000..95c271f9f --- /dev/null +++ b/entity_8hpp_source.html @@ -0,0 +1,81 @@ + + + + + + + +entt: src/entt/entity/entity.hpp Source File + + + + + + + + + +
    +
    + + + + + + +
    +
    entt +  2.6.1 +
    +
    +
    + + + + + + + + +
    +
    + + +
    + +
    + + +
    +
    +
    +
    entity.hpp
    +
    +
    +
    1 #ifndef ENTT_ENTITY_ENTITY_HPP
    2 #define ENTT_ENTITY_ENTITY_HPP
    3 
    4 
    5 #include "../config/config.h"
    6 #include "entt_traits.hpp"
    7 
    8 
    9 namespace entt {
    10 
    11 
    12 namespace internal {
    13 
    14 
    21 template<typename Entity>
    22 static constexpr auto null = ~typename entt_traits<Entity>::entity_type{};
    23 
    24 
    25 struct Null {
    26  explicit constexpr Null() = default;
    27 
    28  template<typename Entity>
    29  constexpr operator Entity() const ENTT_NOEXCEPT {
    30  return null<Entity>;
    31  }
    32 
    33  constexpr bool operator==(Null) const ENTT_NOEXCEPT {
    34  return true;
    35  }
    36 
    37  constexpr bool operator!=(Null) const ENTT_NOEXCEPT {
    38  return false;
    39  }
    40 
    41  template<typename Entity>
    42  constexpr bool operator==(const Entity entity) const ENTT_NOEXCEPT {
    43  return entity == null<Entity>;
    44  }
    45 
    46  template<typename Entity>
    47  constexpr bool operator!=(const Entity entity) const ENTT_NOEXCEPT {
    48  return entity != null<Entity>;
    49  }
    50 };
    51 
    52 
    53 template<typename Entity>
    54 constexpr bool operator==(const Entity entity, Null null) ENTT_NOEXCEPT {
    55  return null == entity;
    56 }
    57 
    58 
    59 template<typename Entity>
    60 constexpr bool operator!=(const Entity entity, Null null) ENTT_NOEXCEPT {
    61  return null != entity;
    62 }
    63 
    64 
    71 }
    72 
    73 
    81 constexpr auto null = internal::Null{};
    82 
    83 
    84 }
    85 
    86 
    87 #endif // ENTT_ENTITY_ENTITY_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::null
    constexpr auto null
    Null entity.
    Definition: entity.hpp:81
    +
    + +
    +Generated by   +doxygen + 1.8.13 +
    + + diff --git a/entt_8hpp_source.html b/entt_8hpp_source.html index a46690818..f6a3ec36e 100644 --- a/entt_8hpp_source.html +++ b/entt_8hpp_source.html @@ -67,7 +67,7 @@ $(function() {
    entt.hpp
    -
    1 #include "core/algorithm.hpp"
    2 #include "core/family.hpp"
    3 #include "core/hashed_string.hpp"
    4 #include "core/ident.hpp"
    5 #include "entity/actor.hpp"
    6 #include "entity/entt_traits.hpp"
    7 #include "entity/helper.hpp"
    8 #include "entity/prototype.hpp"
    9 #include "entity/registry.hpp"
    10 #include "entity/snapshot.hpp"
    11 #include "entity/sparse_set.hpp"
    12 #include "entity/utility.hpp"
    13 #include "entity/view.hpp"
    14 #include "locator/locator.hpp"
    15 #include "process/process.hpp"
    16 #include "process/scheduler.hpp"
    17 #include "resource/cache.hpp"
    18 #include "resource/handle.hpp"
    19 #include "resource/loader.hpp"
    20 #include "signal/delegate.hpp"
    21 #include "signal/dispatcher.hpp"
    22 #include "signal/emitter.hpp"
    23 #include "signal/sigh.hpp"
    +
    1 #include "core/algorithm.hpp"
    2 #include "core/family.hpp"
    3 #include "core/hashed_string.hpp"
    4 #include "core/ident.hpp"
    5 #include "core/monostate.hpp"
    6 #include "entity/actor.hpp"
    7 #include "entity/entity.hpp"
    8 #include "entity/entt_traits.hpp"
    9 #include "entity/helper.hpp"
    10 #include "entity/prototype.hpp"
    11 #include "entity/registry.hpp"
    12 #include "entity/snapshot.hpp"
    13 #include "entity/sparse_set.hpp"
    14 #include "entity/utility.hpp"
    15 #include "entity/view.hpp"
    16 #include "locator/locator.hpp"
    17 #include "process/process.hpp"
    18 #include "process/scheduler.hpp"
    19 #include "resource/cache.hpp"
    20 #include "resource/handle.hpp"
    21 #include "resource/loader.hpp"
    22 #include "signal/delegate.hpp"
    23 #include "signal/dispatcher.hpp"
    24 #include "signal/emitter.hpp"
    25 #include "signal/sigh.hpp"
    Generated by   diff --git a/entt__traits_8hpp_source.html b/entt__traits_8hpp_source.html index f85308caa..4f9273c32 100644 --- a/entt__traits_8hpp_source.html +++ b/entt__traits_8hpp_source.html @@ -67,13 +67,16 @@ $(function() {
    entt_traits.hpp
    -
    1 #ifndef ENTT_ENTITY_ENTT_TRAITS_HPP
    2 #define ENTT_ENTITY_ENTT_TRAITS_HPP
    3 
    4 
    5 #include <cstdint>
    6 
    7 
    8 namespace entt {
    9 
    10 
    17 template<typename>
    18 struct entt_traits;
    19 
    20 
    29 template<>
    30 struct entt_traits<std::uint16_t> {
    32  using entity_type = std::uint16_t;
    34  using version_type = std::uint8_t;
    35 
    37  static constexpr auto entity_mask = 0xFFF;
    39  static constexpr auto version_mask = 0xF;
    41  static constexpr auto entity_shift = 12;
    42 };
    43 
    44 
    53 template<>
    54 struct entt_traits<std::uint32_t> {
    56  using entity_type = std::uint32_t;
    58  using version_type = std::uint16_t;
    59 
    61  static constexpr auto entity_mask = 0xFFFFF;
    63  static constexpr auto version_mask = 0xFFF;
    65  static constexpr auto entity_shift = 20;
    66 };
    67 
    68 
    77 template<>
    78 struct entt_traits<std::uint64_t> {
    80  using entity_type = std::uint64_t;
    82  using version_type = std::uint32_t;
    83 
    85  static constexpr auto entity_mask = 0xFFFFFFFFFF;
    87  static constexpr auto version_mask = 0xFFFFFF;
    89  static constexpr auto entity_shift = 40;
    90 };
    91 
    92 
    93 }
    94 
    95 
    96 #endif // ENTT_ENTITY_ENTT_TRAITS_HPP
    entt::entt_traits< std::uint32_t >::entity_type
    std::uint32_t entity_type
    Underlying entity type.
    Definition: entt_traits.hpp:56
    -
    entt::entt_traits< std::uint64_t >::entity_type
    std::uint64_t entity_type
    Underlying entity type.
    Definition: entt_traits.hpp:80
    +
    1 #ifndef ENTT_ENTITY_ENTT_TRAITS_HPP
    2 #define ENTT_ENTITY_ENTT_TRAITS_HPP
    3 
    4 
    5 #include <cstdint>
    6 
    7 
    8 namespace entt {
    9 
    10 
    17 template<typename>
    18 struct entt_traits;
    19 
    20 
    29 template<>
    30 struct entt_traits<std::uint16_t> {
    32  using entity_type = std::uint16_t;
    34  using version_type = std::uint8_t;
    36  using difference_type = std::int32_t;
    37 
    39  static constexpr auto entity_mask = 0xFFF;
    41  static constexpr auto version_mask = 0xF;
    43  static constexpr auto entity_shift = 12;
    44 };
    45 
    46 
    55 template<>
    56 struct entt_traits<std::uint32_t> {
    58  using entity_type = std::uint32_t;
    60  using version_type = std::uint16_t;
    62  using difference_type = std::int64_t;
    63 
    65  static constexpr auto entity_mask = 0xFFFFF;
    67  static constexpr auto version_mask = 0xFFF;
    69  static constexpr auto entity_shift = 20;
    70 };
    71 
    72 
    81 template<>
    82 struct entt_traits<std::uint64_t> {
    84  using entity_type = std::uint64_t;
    86  using version_type = std::uint32_t;
    88  using difference_type = std::int64_t;
    89 
    91  static constexpr auto entity_mask = 0xFFFFFFFF;
    93  static constexpr auto version_mask = 0xFFFFFFFF;
    95  static constexpr auto entity_shift = 32;
    96 };
    97 
    98 
    99 }
    100 
    101 
    102 #endif // ENTT_ENTITY_ENTT_TRAITS_HPP
    entt::entt_traits< std::uint64_t >::difference_type
    std::int64_t difference_type
    Difference type.
    Definition: entt_traits.hpp:88
    +
    entt::entt_traits< std::uint32_t >::entity_type
    std::uint32_t entity_type
    Underlying entity type.
    Definition: entt_traits.hpp:58
    +
    entt::entt_traits< std::uint64_t >::entity_type
    std::uint64_t entity_type
    Underlying entity type.
    Definition: entt_traits.hpp:84
    +
    entt::entt_traits< std::uint32_t >::difference_type
    std::int64_t difference_type
    Difference type.
    Definition: entt_traits.hpp:62
    entt
    EnTT default namespace.
    Definition: algorithm.hpp:10
    +
    entt::entt_traits< std::uint16_t >::difference_type
    std::int32_t difference_type
    Difference type.
    Definition: entt_traits.hpp:36
    entt::entt_traits< std::uint16_t >::entity_type
    std::uint16_t entity_type
    Underlying entity type.
    Definition: entt_traits.hpp:32
    -
    entt::entt_traits< std::uint64_t >::version_type
    std::uint32_t version_type
    Underlying version type.
    Definition: entt_traits.hpp:82
    +
    entt::entt_traits< std::uint64_t >::version_type
    std::uint32_t version_type
    Underlying version type.
    Definition: entt_traits.hpp:86
    entt::entt_traits< std::uint16_t >::version_type
    std::uint8_t version_type
    Underlying version type.
    Definition: entt_traits.hpp:34
    -
    entt::entt_traits< std::uint32_t >::version_type
    std::uint16_t version_type
    Underlying version type.
    Definition: entt_traits.hpp:58
    +
    entt::entt_traits< std::uint32_t >::version_type
    std::uint16_t version_type
    Underlying version type.
    Definition: entt_traits.hpp:60
    entt::entt_traits
    Entity traits.
    Definition: entt_traits.hpp:18
    diff --git a/files.html b/files.html index bb64de470..59e233c79 100644 --- a/files.html +++ b/files.html @@ -74,16 +74,18 @@ $(function() {  family.hpp  hashed_string.hpp  ident.hpp - ▼ entity - actor.hpp - entt_traits.hpp - helper.hpp - prototype.hpp - registry.hpp - snapshot.hpp - sparse_set.hpp - utility.hpp - view.hpp + monostate.hpp + ▼ entity + actor.hpp + entity.hpp + entt_traits.hpp + helper.hpp + prototype.hpp + registry.hpp + snapshot.hpp + sparse_set.hpp + utility.hpp + view.hpp  ▼ locator  locator.hpp  ▼ process diff --git a/functions_b.html b/functions_b.html index 15ae991e5..a93f8daf6 100644 --- a/functions_b.html +++ b/functions_b.html @@ -65,7 +65,8 @@ $(function() {
  • begin() : entt::PersistentView< Entity, Component > , entt::RawView< Entity, Component > -, entt::SparseSet< Entity > +, entt::RuntimeView< Entity > +, entt::SparseSet< Entity > , entt::SparseSet< Entity, Type > , entt::View< Entity, Component >
    • diff --git a/functions_c.html b/functions_c.html index 19b094ac0..184893d75 100644 --- a/functions_c.html +++ b/functions_c.html @@ -63,11 +63,13 @@ $(function() {

    - c -

    diff --git a/functions_func_e.html b/functions_func_e.html index 3b20961a7..d2b671c48 100644 --- a/functions_func_e.html +++ b/functions_func_e.html @@ -66,17 +66,20 @@ $(function() { : entt::PersistentView< Entity, Component > , entt::RawView< Entity, Component > , entt::Registry< Entity > +, entt::RuntimeView< Entity > , entt::View< Entity, Component >
  • Emitter() : entt::Emitter< Derived >
  • empty() -: entt::Emitter< Derived > +: entt::Delegate< Ret(Args...)> +, entt::Emitter< Derived > , entt::PersistentView< Entity, Component > , entt::RawView< Entity, Component > , entt::Registry< Entity > , entt::ResourceCache< Resource > +, entt::RuntimeView< Entity > , entt::Scheduler< Delta > , entt::ServiceLocator< Service > , entt::SigH< Ret(Args...), Collector > @@ -84,11 +87,12 @@ $(function() { , entt::View< Entity, Component >
  • end() -: entt::PersistentView< Entity, Component > -, entt::RawView< Entity, Component > -, entt::SparseSet< Entity > +: entt::PersistentView< Entity, Component > +, entt::RawView< Entity, Component > +, entt::RuntimeView< Entity > +, entt::SparseSet< Entity > , entt::SparseSet< Entity, Type > -, entt::View< Entity, Component > +, entt::View< Entity, Component >
  • enqueue() : entt::Dispatcher diff --git a/functions_func_g.html b/functions_func_g.html index 5c926aab2..0b4b84856 100644 --- a/functions_func_g.html +++ b/functions_func_g.html @@ -64,14 +64,15 @@ $(function() {

    - g -

    diff --git a/functions_func_m.html b/functions_func_m.html index 912042459..ecd819098 100644 --- a/functions_func_m.html +++ b/functions_func_m.html @@ -66,7 +66,7 @@ $(function() { : entt::ContinuousLoader< Entity >
  • move() -: entt::Registry< Entity > +: entt::Registry< Entity >
    • diff --git a/functions_func_o.html b/functions_func_o.html index 8d0cbf124..44c58a93a 100644 --- a/functions_func_o.html +++ b/functions_func_o.html @@ -80,11 +80,14 @@ $(function() {
  • operator hash_type() : entt::HashedString
    • +
  • operator Type() +: entt::Monostate< hash_type > +
  • operator()() : entt::Delegate< Ret(Args...)> , entt::InsertionSort , entt::Prototype< Entity > -, entt::StdSort +, entt::StdSort
  • operator*() : entt::ResourceHandle< Resource > @@ -96,21 +99,30 @@ $(function() { : entt::Actor< Entity > , entt::ContinuousLoader< Entity > , entt::Emitter< Derived >::Connection< Event > -, entt::Emitter< Derived > -, entt::Registry< Entity > -, entt::ResourceCache< Resource > +, entt::Emitter< Derived > +, entt::Monostate< hash_type > +, entt::Prototype< Entity > +, entt::Registry< Entity > +, entt::ResourceCache< Resource > , entt::ResourceHandle< Resource > -, entt::Scheduler< Delta > +, 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...)> , entt::HashedString , entt::SigH< Ret(Args...), Collector >
    • +
  • operator[]() +: entt::PersistentView< Entity, Component > +, entt::RawView< Entity, Component > +, entt::SparseSet< Entity > +, entt::SparseSet< Entity, Type > +, entt::View< Entity, Component > +
  • orphan() : entt::Registry< Entity >
    • diff --git a/functions_func_p.html b/functions_func_p.html index d932364d1..81c46a124 100644 --- a/functions_func_p.html +++ b/functions_func_p.html @@ -75,7 +75,7 @@ $(function() { : entt::ProcessAdaptor< Func, Delta >
  • Prototype() -: entt::Prototype< Entity > +: entt::Prototype< Entity >
  • publish() : entt::Emitter< Derived > diff --git a/functions_func_r.html b/functions_func_r.html index 954a555d4..7f5aed365 100644 --- a/functions_func_r.html +++ b/functions_func_r.html @@ -113,7 +113,7 @@ $(function() { , entt::SparseSet< Entity, Type >
  • restore() -: entt::Registry< Entity > +: entt::Registry< Entity >
    • diff --git a/functions_func_s.html b/functions_func_s.html index ee64f3c47..2a73ed92e 100644 --- a/functions_func_s.html +++ b/functions_func_s.html @@ -77,41 +77,42 @@ $(function() {
  • sink() : entt::Dispatcher -, entt::SigH< Ret(Args...), Collector > +, entt::SigH< Ret(Args...), Collector >
  • size() : entt::PersistentView< Entity, Component > , entt::RawView< Entity, Component > , entt::Registry< Entity > , entt::ResourceCache< Resource > +, entt::RuntimeView< Entity > , entt::Scheduler< Delta > , entt::SigH< Ret(Args...), Collector > , entt::SparseSet< Entity > , entt::View< Entity, Component >
  • snapshot() -: entt::Registry< Entity > +: entt::Registry< Entity >
  • Snapshot() : entt::Snapshot< Entity >
  • SnapshotLoader() -: entt::SnapshotLoader< Entity > +: entt::SnapshotLoader< Entity >
  • sort() : entt::PersistentView< Entity, Component > -, entt::Registry< Entity > -, entt::SparseSet< Entity, Type > +, entt::Registry< Entity > +, entt::SparseSet< Entity, Type >
  • SparseSet() : entt::SparseSet< Entity > -, entt::SparseSet< Entity, Type > +, entt::SparseSet< Entity, Type >
  • succeed() : entt::Process< Derived, Delta >
  • swap() -: entt::SparseSet< Entity > +: entt::SparseSet< Entity >
    • diff --git a/functions_func_v.html b/functions_func_v.html index 605982c91..fa5953c71 100644 --- a/functions_func_v.html +++ b/functions_func_v.html @@ -69,7 +69,7 @@ $(function() { : entt::Registry< Entity >
  • view() -: entt::Registry< Entity > +: entt::Registry< Entity >
    • diff --git a/functions_g.html b/functions_g.html index a5e72a76d..6561e5e9c 100644 --- a/functions_g.html +++ b/functions_g.html @@ -64,14 +64,15 @@ $(function() {

    - g -

    diff --git a/functions_i.html b/functions_i.html index b9a989765..0602aa929 100644 --- a/functions_i.html +++ b/functions_i.html @@ -62,12 +62,16 @@ $(function() {
    Here is a list of all documented class members with links to the class documentation for each member:

    - i -

    diff --git a/functions_o.html b/functions_o.html index e2aebe9f3..3f31e01a9 100644 --- a/functions_o.html +++ b/functions_o.html @@ -83,11 +83,14 @@ $(function() {
  • operator hash_type() : entt::HashedString
    • +
  • operator Type() +: entt::Monostate< hash_type > +
  • operator()() : entt::Delegate< Ret(Args...)> , entt::InsertionSort , entt::Prototype< Entity > -, entt::StdSort +, entt::StdSort
  • operator*() : entt::ResourceHandle< Resource > @@ -100,13 +103,15 @@ $(function() { , entt::ContinuousLoader< Entity > , entt::Emitter< Derived >::Connection< Event > , entt::Emitter< Derived > +, entt::Monostate< hash_type > +, entt::Prototype< Entity > , entt::Registry< Entity > , entt::ResourceCache< Resource > -, entt::ResourceHandle< Resource > -, entt::Scheduler< Delta > +, entt::ResourceHandle< Resource > +, entt::Scheduler< Delta > , entt::Snapshot< Entity > , entt::SnapshotLoader< Entity > -, entt::SparseSet< Entity > +, entt::SparseSet< Entity > , entt::SparseSet< Entity, Type >
  • operator==() @@ -114,6 +119,13 @@ $(function() { , entt::HashedString , entt::SigH< Ret(Args...), Collector >
    • +
  • operator[]() +: entt::PersistentView< Entity, Component > +, entt::RawView< Entity, Component > +, entt::SparseSet< Entity > +, entt::SparseSet< Entity, Type > +, entt::View< Entity, Component > +
  • orphan() : entt::Registry< Entity >
    • diff --git a/functions_p.html b/functions_p.html index d4bd7ab67..8b034fd12 100644 --- a/functions_p.html +++ b/functions_p.html @@ -68,10 +68,6 @@ $(function() {
  • paused() : entt::Process< Derived, Delta >
    • -
  • pos_type -: entt::SparseSet< Entity > -, entt::SparseSet< Entity, Type > -
  • prepare() : entt::Registry< Entity >
    • @@ -79,7 +75,7 @@ $(function() { : entt::ProcessAdaptor< Func, Delta >
  • Prototype() -: entt::Prototype< Entity > +: entt::Prototype< Entity >
  • publish() : entt::Emitter< Derived > diff --git a/functions_r.html b/functions_r.html index dedd636b0..5fd0cfbab 100644 --- a/functions_r.html +++ b/functions_r.html @@ -84,6 +84,7 @@ $(function() {
  • Registry< Entity > : entt::PersistentView< Entity, Component > , entt::RawView< Entity, Component > +, entt::RuntimeView< Entity > , entt::Snapshot< Entity > , entt::SnapshotLoader< Entity > , entt::View< Entity, Component > @@ -100,10 +101,10 @@ $(function() {
  • remove() : entt::Actor< Entity > -, entt::Registry< Entity > +, entt::Registry< Entity >
  • replace() -: entt::Registry< Entity > +: entt::Registry< Entity >
  • reserve() : entt::Registry< Entity > @@ -112,7 +113,7 @@ $(function() {
  • reset() : entt::Delegate< Ret(Args...)> -, entt::Registry< Entity > +, entt::Registry< Entity > , entt::ServiceLocator< Service > , entt::SparseSet< Entity > , entt::SparseSet< Entity, Type > @@ -121,21 +122,21 @@ $(function() { : entt::ResourceCache< Resource >
  • ResourceCache() -: entt::ResourceCache< Resource > +: entt::ResourceCache< Resource >
  • ResourceCache< Resource > : entt::ResourceHandle< Resource > , entt::ResourceLoader< Loader, Resource >
  • ResourceHandle() -: entt::ResourceHandle< Resource > +: entt::ResourceHandle< Resource >
  • respect() : entt::SparseSet< Entity > , entt::SparseSet< Entity, Type >
  • restore() -: entt::Registry< Entity > +: entt::Registry< Entity >
    • diff --git a/functions_rela.html b/functions_rela.html index 2bce6df7d..6741242e1 100644 --- a/functions_rela.html +++ b/functions_rela.html @@ -66,6 +66,7 @@ $(function() {
  • Registry< Entity > : entt::PersistentView< Entity, Component > , entt::RawView< Entity, Component > +, entt::RuntimeView< Entity > , entt::Snapshot< Entity > , entt::SnapshotLoader< Entity > , entt::View< Entity, Component > diff --git a/functions_s.html b/functions_s.html index b0fa3fd28..efb4c7ac6 100644 --- a/functions_s.html +++ b/functions_s.html @@ -83,7 +83,7 @@ $(function() {
  • sink() : entt::Dispatcher -, entt::SigH< Ret(Args...), Collector > +, entt::SigH< Ret(Args...), Collector >
  • sink_type : entt::Dispatcher @@ -95,6 +95,7 @@ $(function() { , entt::RawView< Entity, Component > , entt::Registry< Entity > , entt::ResourceCache< Resource > +, entt::RuntimeView< Entity > , entt::Scheduler< Delta > , entt::SigH< Ret(Args...), Collector > , entt::SparseSet< Entity > @@ -106,6 +107,7 @@ $(function() { , entt::RawView< Entity, Component > , entt::Registry< Entity > , entt::ResourceCache< Resource > +, entt::RuntimeView< Entity > , entt::Scheduler< Delta > , entt::SigH< Ret(Args...), Collector > , entt::SparseSet< Entity > @@ -113,7 +115,7 @@ $(function() { , entt::View< Entity, Component >
  • snapshot() -: entt::Registry< Entity > +: entt::Registry< Entity >
  • Snapshot() : entt::Snapshot< Entity > @@ -123,19 +125,19 @@ $(function() {
  • sort() : entt::PersistentView< Entity, Component > -, entt::Registry< Entity > -, entt::SparseSet< Entity, Type > +, entt::Registry< Entity > +, entt::SparseSet< Entity, Type >
  • SparseSet() -: entt::SparseSet< Entity > -, entt::SparseSet< Entity, Type > +: entt::SparseSet< Entity > +, entt::SparseSet< Entity, Type >
  • succeed() : entt::Process< Derived, Delta >
  • swap : entt::SigH< Ret(Args...), Collector > -, entt::SparseSet< Entity > +, entt::SparseSet< Entity >
    • diff --git a/functions_type.html b/functions_type.html index f841d9a00..091249591 100644 --- a/functions_type.html +++ b/functions_type.html @@ -71,6 +71,7 @@ $(function() {
  • const_iterator_type : entt::PersistentView< Entity, Component > , entt::RawView< Entity, Component > +, entt::RuntimeView< Entity > , entt::SparseSet< Entity > , entt::SparseSet< Entity, Type > , entt::View< Entity, Component > @@ -82,6 +83,11 @@ $(function() {
  • delta_type : entt::Process< Derived, Delta >
    • +
  • difference_type +: entt::entt_traits< std::uint16_t > +, entt::entt_traits< std::uint32_t > +, entt::entt_traits< std::uint64_t > +
    • @@ -96,6 +102,7 @@ $(function() { , entt::Prototype< Entity > , entt::RawView< Entity, Component > , entt::Registry< Entity > +, entt::RuntimeView< Entity > , entt::SparseSet< Entity > , entt::SparseSet< Entity, Type > , entt::View< Entity, Component > @@ -118,12 +125,16 @@ $(function() {

    - i -

    -

    - p -

    - -

    - r -

    • raw_type : entt::RawView< Entity, Component > @@ -183,6 +186,7 @@ $(function() { , entt::RawView< Entity, Component > , entt::Registry< Entity > , entt::ResourceCache< Resource > +, entt::RuntimeView< Entity > , entt::Scheduler< Delta > , entt::SigH< Ret(Args...), Collector > , entt::SparseSet< Entity > diff --git a/handle_8hpp_source.html b/handle_8hpp_source.html index 845385643..d143ad3cd 100644 --- a/handle_8hpp_source.html +++ b/handle_8hpp_source.html @@ -68,7 +68,7 @@ $(function() {
      1 #ifndef ENTT_RESOURCE_HANDLE_HPP
      2 #define ENTT_RESOURCE_HANDLE_HPP
      3 
      4 
      5 #include <memory>
      6 #include <utility>
      7 #include <cassert>
      8 #include "../config/config.h"
      9 
      10 
      11 namespace entt {
      12 
      13 
      14 template<typename Resource>
      15 class ResourceCache;
      16 
      17 
      30 template<typename Resource>
      31 class ResourceHandle final {
      33  friend class ResourceCache<Resource>;
      34 
      35  ResourceHandle(std::shared_ptr<Resource> res) ENTT_NOEXCEPT
      36  : resource{std::move(res)}
      37  {}
      38 
      39 public:
      41  ResourceHandle(const ResourceHandle &) ENTT_NOEXCEPT = default;
      43  ResourceHandle(ResourceHandle &&) ENTT_NOEXCEPT = default;
      44 
      46  ResourceHandle & operator=(const ResourceHandle &) ENTT_NOEXCEPT = default;
      48  ResourceHandle & operator=(ResourceHandle &&) ENTT_NOEXCEPT = default;
      49 
      60  const Resource & get() const ENTT_NOEXCEPT {
      61  assert(static_cast<bool>(resource));
      62  return *resource;
      63  }
      64 
      73  inline operator const Resource &() const ENTT_NOEXCEPT { return get(); }
      74 
      85  inline const Resource & operator *() const ENTT_NOEXCEPT { return get(); }
      86 
      98  inline const Resource * operator ->() const ENTT_NOEXCEPT {
      99  assert(static_cast<bool>(resource));
      100  return resource.get();
      101  }
      102 
      106  explicit operator bool() const { return static_cast<bool>(resource); }
      107 
      108 private:
      109  std::shared_ptr<Resource> resource;
      110 };
      111 
      112 
      113 }
      114 
      115 
      116 #endif // ENTT_RESOURCE_HANDLE_HPP
      entt::ResourceHandle::get
      const Resource & get() const ENTT_NOEXCEPT
      Gets a reference to the managed resource.
      Definition: handle.hpp:60
      -
      entt::ResourceHandle::operator->
      const Resource * operator->() const ENTT_NOEXCEPT
      Gets a pointer to the managed resource from a handle .
      Definition: handle.hpp:98
      +
      entt::ResourceHandle::operator->
      const Resource * operator->() const ENTT_NOEXCEPT
      Gets a pointer to the managed resource from a handle.
      Definition: handle.hpp:98
      entt
      EnTT default namespace.
      Definition: algorithm.hpp:10
      entt::ResourceHandle
      Shared resource handle.
      Definition: handle.hpp:31
      entt::ResourceHandle::operator*
      const Resource & operator*() const ENTT_NOEXCEPT
      Dereferences a handle to obtain the managed resource.
      Definition: handle.hpp:85
      diff --git a/hashed__string_8hpp_source.html b/hashed__string_8hpp_source.html index d6d76bc5c..f30c98db6 100644 --- a/hashed__string_8hpp_source.html +++ b/hashed__string_8hpp_source.html @@ -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 #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 
      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
      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 d4c10bf60..b0865be4d 100644 --- a/helper_8hpp_source.html +++ b/helper_8hpp_source.html @@ -67,7 +67,7 @@ $(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:39
      +
      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
      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
      diff --git a/hierarchy.html b/hierarchy.html index 400dcc043..e969acc71 100644 --- a/hierarchy.html +++ b/hierarchy.html @@ -84,36 +84,39 @@ This inheritance list is sorted roughly, but not completely, alphabetically: ▼CFunc  Centt::ProcessAdaptor< Func, Delta >Adaptor for lambdas and functors to turn them into processes  Centt::HashedStringZero overhead resource identifier - Centt::InsertionSortFunction object for performing insertion sort - ▼CInvoker - Centt::SigH< Ret(Args...), Collector >Unmanaged signal handler definition - 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::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::Identifier< Types >Types identifiers + Centt::InsertionSortFunction object for performing insertion sort + ▼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
      diff --git a/ident_8hpp_source.html b/ident_8hpp_source.html index a0371831b..812d81153 100644 --- a/ident_8hpp_source.html +++ b/ident_8hpp_source.html @@ -67,8 +67,9 @@ $(function() {
      ident.hpp
      -
      1 #ifndef ENTT_CORE_IDENT_HPP
      2 #define ENTT_CORE_IDENT_HPP
      3 
      4 
      5 #include <type_traits>
      6 #include <cstddef>
      7 #include <utility>
      8 #include "../config/config.h"
      9 
      10 
      11 namespace entt {
      12 
      13 
      14 namespace internal {
      15 
      16 
      23 template<typename... Types>
      24 struct Identifier final: Identifier<Types>... {
      25  using identifier_type = std::size_t;
      26 
      27  template<std::size_t... Indexes>
      28  constexpr Identifier(std::index_sequence<Indexes...>) ENTT_NOEXCEPT
      29  : Identifier<Types>{std::index_sequence<Indexes>{}}...
      30  {}
      31 
      32  template<typename Type>
      33  constexpr std::size_t get() const ENTT_NOEXCEPT {
      34  return Identifier<std::decay_t<Type>>::get();
      35  }
      36 };
      37 
      38 
      39 template<typename Type>
      40 struct Identifier<Type> {
      41  using identifier_type = std::size_t;
      42 
      43  template<std::size_t Index>
      44  constexpr Identifier(std::index_sequence<Index>) ENTT_NOEXCEPT
      45  : index{Index}
      46  {}
      47 
      48  constexpr std::size_t get() const ENTT_NOEXCEPT {
      49  return index;
      50  }
      51 
      52 private:
      53  const std::size_t index;
      54 };
      55 
      56 
      63 }
      64 
      65 
      102 template<typename... Types>
      103 constexpr auto ident = internal::Identifier<std::decay_t<Types>...>{std::make_index_sequence<sizeof...(Types)>{}};
      104 
      105 
      106 }
      107 
      108 
      109 #endif // ENTT_CORE_IDENT_HPP
      entt
      EnTT default namespace.
      Definition: algorithm.hpp:10
      -
      entt::ident
      constexpr auto ident
      Types identifers.
      Definition: ident.hpp:103
      +
      1 #ifndef ENTT_CORE_IDENT_HPP
      2 #define ENTT_CORE_IDENT_HPP
      3 
      4 
      5 #include <type_traits>
      6 #include <cstddef>
      7 #include <utility>
      8 #include <tuple>
      9 #include "../config/config.h"
      10 
      11 
      12 namespace entt {
      13 
      14 
      15 namespace internal {
      16 
      17 
      24 template<typename...>
      25 struct IsPartOf;
      26 
      27 template<typename Type, typename Current, typename... Other>
      28 struct IsPartOf<Type, Current, Other...>: std::conditional_t<std::is_same<Type, Current>::value, std::true_type, IsPartOf<Type, Other...>> {};
      29 
      30 template<typename Type>
      31 struct IsPartOf<Type>: std::false_type {};
      32 
      33 
      40 }
      41 
      42 
      70 template<typename... Types>
      71 class Identifier final {
      72  using tuple_type = std::tuple<std::decay_t<Types>...>;
      73 
      74  template<typename Type, std::size_t... Indexes>
      75  static constexpr std::size_t get(std::index_sequence<Indexes...>) ENTT_NOEXCEPT {
      76  static_assert(internal::IsPartOf<Type, Types...>::value, "!");
      77 
      78  std::size_t max{};
      79  using accumulator_type = std::size_t[];
      80  accumulator_type accumulator = { (max = std::is_same<Type, std::tuple_element_t<Indexes, tuple_type>>::value ? Indexes : max)... };
      81  (void)accumulator;
      82  return max;
      83  }
      84 
      85 public:
      87  using identifier_type = std::size_t;
      88 
      94  template<typename Type>
      95  static constexpr identifier_type get() ENTT_NOEXCEPT {
      96  return get<std::decay_t<Type>>(std::make_index_sequence<sizeof...(Types)>{});
      97  }
      98 };
      99 
      100 
      101 }
      102 
      103 
      104 #endif // ENTT_CORE_IDENT_HPP
      entt
      EnTT default namespace.
      Definition: algorithm.hpp:10
      +
      entt::Identifier
      Types identifiers.
      Definition: ident.hpp:71
      +
      entt::Identifier::identifier_type
      std::size_t identifier_type
      Unsigned integer type.
      Definition: ident.hpp:87
      diff --git a/index.html b/index.html index 18ab2d1c4..cab0dce92 100644 --- a/index.html +++ b/index.html @@ -99,6 +99,7 @@ Table of Contents
    • Dependency function
    +
  • Null entity
  • View: to persist or not to persist?
    • -
  • Side notes
    • +
  • Iterations: what is allowed and what is not
    • +
  • Multithreading
  • Crash Course: core functionalities
  • Crash Course: service locator
    • @@ -187,7 +191,7 @@ State of the art 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.

    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.

    @@ -204,34 +208,26 @@ Performance Destroy 1M entities 0.0053s 0.0045s -Standard view, 1M entities, one component 0.0012s 1.9e-07s +1M entities, one component 0.0012s 1.9e-07s -Standard view, 1M entities, two components 0.0012s 3.8e-07s +1M entities, two components 0.0012s 3.8e-07s -Standard view, 1M entities, two components
    +1M entities, two components
    Half of the entities have all the components 0.0009s 3.8e-07s -Standard view, 1M entities, two components
    +1M entities, two components
    One of the entities has all the components 0.0008s 1.0e-06s -Persistent view, 1M entities, two components 0.0012s 2.8e-07s +1M entities, five components 0.0010s 7.0e-07s -Standard view, 1M entities, five components 0.0010s 7.0e-07s +1M entities, ten components 0.0011s 1.2e-06s -Persistent view, 1M entities, five components 0.0010s 2.8e-07s - -Standard view, 1M entities, ten components 0.0011s 1.2e-06s - -Standard view, 1M entities, ten components
    +1M entities, ten components
    Half of the entities have all the components 0.0010s 1.2e-06s -Standard view, 1M entities, ten components
    +1M entities, ten components
    One of the entities has all the components 0.0008s 1.2e-06s -Persistent view, 1M entities, ten components 0.0011s 3.0e-07s - -Raw view, 1M entities - 2.2e-07s - Sort 150k entities, one component
    Arrays are in reverse order - 0.0036s @@ -270,15 +266,15 @@ Library

    Documentation

    The documentation is based on doxygen. To build it: 

    $ cd build
-$ cmake ..
-$ make docs
+$ 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 to compile anything else.

    + cmake will download and compile the library before compiling anything else. In order to build without tests set CMake option BUILD_TESTING=OFF.

    To build the most basic set of tests:

    • $ cd build
      • @@ -317,11 +313,10 @@ The Registry, the Entity and the Component 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>.

      Entities are represented by entity identifiers. An entity identifier is an opaque type that users should not inspect or modify in any way. It carries information about the entity itself and its version.

      A registry can be used both to construct and destroy entities:

      -
      // constructs a naked entity with no components and returns its identifier
      auto entity = registry.create();
      // destroys an entity and all its components
      registry.destroy(entity);

      When an entity is destroyed, the registry can freely reuse it internally with a slightly different identifier. In particular, the version of an entity is increased each and every time it's discarded.
      +

      // constructs a naked entity with no components and returns its identifier
      auto entity = registry.create();
      // destroys an entity and all its components
      registry.destroy(entity);

      Entities can also be destroyed by type, that is by specifying the types of the tags or components that identify them:

      +
      // destroys the entity that owns the given tag, if any
      registry.destroy<MyTag>(entt::tag_t{});
      // destroys the entities that own the given components, if any
      registry.destroy<AComponent, AnotherComponent>();

      When an entity is destroyed, the registry can freely reuse it internally with a slightly different identifier. In particular, the version of an entity is increased each and every time it's discarded.
      In case entity identifiers are stored around, the registry offers all the functionalities required to test them and get out of the them all the information they carry:

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

      Finally, there is also a sort of null identifier made available to users. It's treated as if it were a null pointer that doesn't identify any entity. A registry will reject this identifier in all cases because it isn't considered valid.
      - The rules that define a null identifier are a bit tricky to explain. However, being Entity the type of the entities (for example, std::uint32_t), users can easily construct a null identifier by flipping all the bits of the zero:

      -
      using Entity = std::uint32_t;
      const auto null = ~Entity{};

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

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

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

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

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

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

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

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

      @@ -379,7 +374,7 @@ Who let the tags out?
      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 plugins and mods in general. However, it seems impossible with a tool designed around a bunch of templates. Indeed it's not that difficult.
      +

      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:

      @@ -400,12 +395,12 @@ Sorting: is it possible?
      • Components can be sorted directly:
      -
      registry.sort<Renderable>([](const auto &lhs, const auto &rhs) {
      return lhs.z < rhs.z;
      });

      There exists also the possibility to use a custom sort function object, as long as it adheres to the requirements described in the inline documentation.
      +

      registry.sort<Renderable>([](const auto &lhs, const auto &rhs) {
      return lhs.z < rhs.z;
      });

      There exists also the possibility to use a custom sort function object, as long as it adheres to the requirements described in the inline documentation.
      This is possible mainly because users can get much more with a custom sort function object if the pattern of usage is known. As an example, in case of an almost sorted pool, quick sort could be much, much slower than insertion sort.

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

      +
      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.
      @@ -414,7 +409,7 @@ Snapshot: complete vs continuous Intuitively, the use cases are different. As an example, the first approach is suitable for local save/restore functionalities while the latter is suitable for creating client-server applications and for transferring somehow parts of the representation side to side.

      To take a snapshot of the registry, use the snapshot member function. It returns a temporary object properly initialized to save the whole registry or parts of it.

      Example of use:

      -
      OutputArchive output;
      registry.snapshot()
      .entities(output)
      .destroyed(output)
      .component<AComponent, AnotherComponent>(output)
      .tag<MyTag>(output);

      It isn't necessary to invoke all these functions each and every time. What functions to use in which case mostly depends on the goal and there is not a golden rule to do that.

      +
      OutputArchive output;
      registry.snapshot()
      .entities(output)
      .destroyed(output)
      .component<AComponent, AnotherComponent>(output)
      .tag<MyTag>(output);

      It isn't necessary to invoke all these functions each and every time. What functions to use in which case mostly depends on the goal and there is not a golden rule to do that.

      The entities member function asks the registry to serialize all the entities that are still in use along with their versions. On the other side, the destroyed member function tells to the registry to serialize the entities that have been destroyed and are no longer in use.
      These two functions can be used to save and restore the whole set of entities with the versions they had during serialization.

      The component member function is a function template the aim of which is to store aside components. The presence of a template parameter list is a consequence of a couple of design choices from the past and in the present:

      @@ -424,7 +419,7 @@ Snapshot: complete vs continuous

    There exists also another version of the component member function that accepts a range of entities to serialize. This version is a bit slower than the other one, mainly because it iterates the range of entities more than once for internal purposes. However, it can be used to filter out those entities that shouldn't be serialized for some reasons.
    As an example:

    -
    const auto view = registry.view<Serialize>();
    OutputArchive output;
    registry.snapshot()
    .component<AComponent, AnotherComponent>(output, view.cbegin(), view.cend());

    The tag member function is similar to the previous one, apart from the fact that it works with tags and not with components.
    +

    const auto view = registry.view<Serialize>();
    OutputArchive output;
    registry.snapshot()
    .component<AComponent, AnotherComponent>(output, view.cbegin(), view.cend());

    The tag member function is similar to the previous one, apart from the fact that it works with tags and not with components.
    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.

    @@ -433,7 +428,7 @@ 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.

    Example of use:

    -
    InputArchive input;
    registry.restore()
    .entities(input)
    .destroyed(input)
    .component<AComponent, AnotherComponent>(input)
    .tag<MyTag>(input)
    .orphans();

    It isn't necessary to invoke all these functions each and every time. What functions to use in which case mostly depends on the goal and there is not a golden rule to do that. For obvious reasons, what is important is that the data are restored in exactly the same order in which they were serialized.

    +
    InputArchive input;
    registry.restore()
    .entities(input)
    .destroyed(input)
    .component<AComponent, AnotherComponent>(input)
    .tag<MyTag>(input)
    .orphans();

    It isn't necessary to invoke all these functions each and every time. What functions to use in which case mostly depends on the goal and there is not a golden rule to do that. For obvious reasons, what is important is that the data are restored in exactly the same order in which they were serialized.

    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.

    @@ -494,12 +489,19 @@ Dependency function 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>());

    +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:

    +
    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);

    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.
    It is a subtle difference that can help designing a better software sometimes.

    -

    There are mainly three kinds of views: standard (also known as View), persistent (also known as PersistentView) and raw (also known as RawView).
    +

    There are mainly four kinds of views: standard (also known as View), persistent (also known as PersistentView), raw (also known as RawView) and runtime (also known as RuntimeView).
    All of them have pros and cons to take in consideration. In particular:

    • Standard views:

      @@ -537,6 +539,17 @@ View: to persist or not to persist?
    • They don't return the entity to which a component belongs to the caller.
    +

  • Runtime views:

    +

    Pros:

      +
    • Their lists of components are defined at runtime and not at compile-time.
      • +
    • Creating and destroying them isn't expensive at all because they don't have any type of initialization.
      • +
    • They are the best tool for things like plugin systems and mods in general.
      • +
    • They don't affect any other operations of the registry.
      • +
    +

    Cons:

      +
    • Their performances are definitely lower than those of all the other views, although they are still usable and sufficient for most of the purposes.
      • +
    +

    • To sum up and as a rule of thumb:

      @@ -548,36 +561,37 @@ View: to persist or not to persist?
    • Prepare and use a persistent view when you want to iterate only entities for multiple components.
    • Prepare and use a persistent view when you want to iterate entities for multiple components and each component is assigned to a great number of entities but the intersection between the sets of entities is small.
    • Prepare and use a persistent view in all the cases where a standard view wouldn't fit well otherwise.
      • +
    • Finally, in case you don't know at compile-time what are the components to use, choose a runtime view and set them during execution.

    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.
    Refer to the inline documentation for all the details.

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

    + To iterate a single component standard view, either use it in a range-for loop:

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

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

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

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

    +
    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.
    Refer to the inline documentation for all the details.

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

    + To iterate a multi component standard view, either use it in a range-for loop:

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

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

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

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

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

    @@ -587,20 +601,32 @@ Persistent View
    registry.prepare<Position, Velocity>();

    If the registry is empty, preparation is extremely fast. Moreover the prepare member function template is idempotent. Feel free to invoke it even more than once: if the view has been already prepared before, the function returns immediately and does nothing.

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

    -

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

    +

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

    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.
    Refer to the inline documentation for all the details.

    Raw views can be used only to iterate components for a single type. To create this kind of views, the tag raw_t must also be used in order to disambiguate overloads of the view member function:

    auto view = registry.view<Renderable>(entt::raw_t{});

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

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

    Note: raw views don't have the each nor the get member function for obvious reasons. The former would only return the components and therefore it would be redundant, the latter isn't required at all.

    -

    + To iterate a raw view, use it in a range-for loop:

    +
    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.
    + Refer to the inline documentation for all the details.

    +

    Runtime view are extremely cheap to construct and should not be stored around in any case. They should be used immediately after creation and then they should be thrown away. The reasons for this go far beyond the scope of this document.
    + To iterate a runtime view, either use it in a range-for loop:

    +
    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:

    @@ -612,60 +638,67 @@ 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.

    -

    -Side notes

    +

    +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:

      -
    • Entity identifiers are numbers and nothing more. They are not classes and they have no member functions at all. As already mentioned, do no try to inspect or modify an entity descriptor in any way.
      • -
    • As shown in the examples above, the preferred way to get references to the components while iterating a view is by using the view itself. It's a faster alternative to the get member function template that is part of the API of the Registry. This is because the registry must ensure that a pool for the given component exists before to use it; on the other side, views force the construction of the pools for all their components and access them directly, thus avoiding all the checks.
      • -

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

      • Creating entities and components is allowed during iterations.
        • -
      • Deleting an entity or removing its components is allowed during iterations if it's the one currently returned by a view. For all the other entities, destroying them or removing their components isn't allowed and it can result in undefined behavior.
        • +
      • Deleting an entity or removing its components is allowed during iterations if it's the one currently returned by the view. For all the other entities, destroying them or removing their components isn't allowed and it can result in undefined behavior.
      -

      Iterators are invalidated and the behavior is undefined if an entity is modified or destroyed and it's not the one currently returned by the view.
      - To work around it, possible approaches are:

        +

        Iterators are invalidated and the behavior is undefined if an entity is modified or destroyed and it's not the one currently returned by the view nor a newly created one.
        + To work around it, possible approaches are:

        +
        • Store aside the entities and the components to be removed and perform the operations at the end of the iteration.
        • 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.
        - -
      • Views and thus their iterators aren't thread safe. Do no try to iterate a set of components and modify the same set concurrently.
        - That being said, as long as a thread iterates the entities that have the component X or assign and removes that component from a set of entities, another thread can safely do the same with components Y and Z and everything will work like a charm.
        - As a trivial example, users can freely execute the rendering system and iterate the renderable entities while updating a physic component concurrently on a separate thread.
        • -
      • 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.
        - This kind of entity-component systems can be used in single threaded applications as well as along with async stuff. Moreover, typical thread based models for ECS don't require a fully thread safe registry to work. Actually one could reach the goal with the registry as it is while working with most of the common models, after all.
        - Because of the few reasons mentioned above and many others not mentioned, users are completely responsible for synchronization whether required.
        • +

        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:

        +
          +
        • As long as a thread iterates the entities that have the component X or assign and removes that component from a set of entities, another thread can safely do the same with components Y and Z and everything will work like a charm. As a trivial example, users can freely execute the rendering system and iterate the renderable entities while updating a physic component concurrently on a separate thread.
          • +
        • Similarly, a single set of components can be iterated by multiple threads as long as the components are neither assigned nor removed in the meantime. In other words, a hypothetical movement system can start multiple threads, each of which will access the components that carry information about velocity and position for its entities.
        -

        +

        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.

        -

        +

        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.

        -

        The result of my efforts is the ident constexpr variable:

        -
        #include <ident.hpp>
        // defines the identifiers for the given types
        constexpr auto identifiers = entt::ident<AType, AnotherType>;
        // ...
        switch(aTypeIdentifier) {
        case identifers.get<AType>():
        // ...
        break;
        case identifers.get<AnotherType>():
        // ...
        break;
        default:
        // ...
        }

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

        +

        The result of my efforts is the Identifier class template:

        +
        #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 {};
        constexpr auto identifiers = entt::ident<
        ATypeStillValid,
        IgnoreType<ATypeNoLongerValid>,
        AnotherTypeStillValid
        >;

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

        -

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

        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"});

        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"}>{};

        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.

        @@ -673,11 +706,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.

        -

        +

        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):

        @@ -700,7 +733,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.

      @@ -714,14 +747,14 @@ 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.
    A process can also have a child. In this case, the process is replaced with its child when it terminates if it returns with success. In case of errors, both the process and its child are discarded. This way, it's easy to create chain of processes to run sequentially.

    Using a scheduler is straightforward. To create it, users must provide only the type for the elapsed times and no arguments at all:

    Scheduler<std::uint32_t> scheduler;

    It has member functions to query its internal data structures, like empty or size, as well as a clear utility to reset it to a clean state:

    -
    // checks if there are processes still running
    bool empty = scheduler.empty();
    // gets the number of processes still running
    Scheduler<std::uint32_t>::size_type size = scheduler.size();
    // resets the scheduler to its initial state and discards all the processes
    scheduler.clear();

    To attach a process to a scheduler there are mainly two ways:

    +
    // checks if there are processes still running
    const auto empty = scheduler.empty();
    // gets the number of processes still running
    Scheduler<std::uint32_t>::size_type size = scheduler.size();
    // resets the scheduler to its initial state and discards all the processes
    scheduler.clear();

    To attach a process to a scheduler there are mainly two ways:

    • If the process inherits from the Process class template, it's enough to indicate its type and submit all the parameters required to construct it to the attach member function:
    @@ -732,13 +765,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.
    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.
    @@ -753,7 +786,7 @@ The resource, the loader and the cache

    using MyResourceCache = entt::ResourceCache<MyResource>;
    // ...
    MyResourceCache cache{};

    The idea is to create different caches for different types of resources and to manage each one independently and in the most appropriate way.
    As a (very) trivial example, audio tracks can survive in most of the scenes of an application while meshes can be associated with a single scene and then discarded when the user leaves it.

    A cache offers a set of basic functionalities to query its internal state and to organize it:

    -
    // gets the number of resources managed by a cache
    auto size = cache.size();
    // checks if a cache contains at least a valid resource
    auto empty = cache.empty();
    // clears a cache and discards its content
    cache.clear();

    Besides these member functions, it contains what is needed to load, use and discard resources of the given type.
    +

    // gets the number of resources managed by a cache
    const auto size = cache.size();
    // checks if a cache contains at least a valid resource
    const auto empty = cache.empty();
    // clears a cache and discards its content
    cache.clear();

    Besides these member functions, it contains what is needed to load, use and discard resources of the given type.
    Before to explore this part of the interface, it makes sense to mention how resources are identified. The type of the identifiers to use is defined as:

    entt::ResourceCache<Resource>::resource_type

    Where resource_type is an alias for entt::HashedString. Therefore, resource identifiers are created explicitly as in the following example:

    constexpr auto identifier = entt::ResourceCache<Resource>::resource_type{"my/resource/identifier"};
    // this is equivalent to the following
    constexpr auto hs = entt::HashedString{"my/resource/identifier"};

    The class HashedString is described in a dedicated section, so I won't do in details here.

    @@ -782,14 +815,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.

    -

    +

    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.

    @@ -798,11 +831,11 @@ Signals

    Note: collectors are allowed only in case of function types whose the return type isn't void for obvious reasons.

    To create instances of signal handlers there exist mainly two ways:

    // no collector type
    entt::SigH<void(int, char)> signal;
    // explicit collector type
    entt::SigH<void(int, char), MyCollector<bool>> collector;

    As expected, they offer all the basic functionalities required to know how many listeners they contain (size) or if they contain at least a listener (empty) and even to swap two signal handlers (swap).

    -

    Besides them, there are member functions to use both to connect and disconnect listeners in all their forms by means of a sink::

    +

    Besides them, there are member functions to use both to connect and disconnect listeners in all their forms by means of a sink:

    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.

    @@ -811,9 +844,10 @@ Delegate

    Attempting to use an empty delegate by invoking its function call operator results in undefined behavior, most likely a crash actually. Before to use a delegate, it must be initialized.
    There exist two functions to do that, both named connect:

    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.
    - Finally, to invoke a delegate, the function call operator is the way to go as usual:

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

    -

    +

    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:

    @@ -826,7 +860,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.

    @@ -854,7 +888,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:

      @@ -863,14 +897,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.

    diff --git a/inherit_graph_14.map b/inherit_graph_14.map index 5b01a5f9b..0a22de5e5 100644 --- a/inherit_graph_14.map +++ b/inherit_graph_14.map @@ -1,3 +1,3 @@ - + diff --git a/inherit_graph_14.md5 b/inherit_graph_14.md5 index 693a576ce..846adf7dc 100644 --- a/inherit_graph_14.md5 +++ b/inherit_graph_14.md5 @@ -1 +1 @@ -346d632c706916a7b10653e1b85bd7a5 \ No newline at end of file +f08dc4dc73fa40e661d5b156da7ea472 \ No newline at end of file diff --git a/inherit_graph_14.png b/inherit_graph_14.png index 7956e292e..dc7261e0b 100644 Binary files a/inherit_graph_14.png and b/inherit_graph_14.png differ diff --git a/inherit_graph_15.map b/inherit_graph_15.map index 68b105f9f..5b01a5f9b 100644 --- a/inherit_graph_15.map +++ b/inherit_graph_15.map @@ -1,3 +1,3 @@ - + diff --git a/inherit_graph_15.md5 b/inherit_graph_15.md5 index b4cc67996..693a576ce 100644 --- a/inherit_graph_15.md5 +++ b/inherit_graph_15.md5 @@ -1 +1 @@ -20c874a300d88122441dac8e77bf11e8 \ No newline at end of file +346d632c706916a7b10653e1b85bd7a5 \ No newline at end of file diff --git a/inherit_graph_15.png b/inherit_graph_15.png index 6ce02376d..7956e292e 100644 Binary files a/inherit_graph_15.png and b/inherit_graph_15.png differ diff --git a/inherit_graph_16.map b/inherit_graph_16.map index f59ca3c15..83769395a 100644 --- a/inherit_graph_16.map +++ b/inherit_graph_16.map @@ -1,3 +1,3 @@ - + diff --git a/inherit_graph_16.md5 b/inherit_graph_16.md5 index 9e985e6b1..1bf4a4084 100644 --- a/inherit_graph_16.md5 +++ b/inherit_graph_16.md5 @@ -1 +1 @@ -68c3f1d2aaee71c81615b1ee951d2af7 \ No newline at end of file +469876f5b4b08c1af3415a4c19dd7941 \ No newline at end of file diff --git a/inherit_graph_16.png b/inherit_graph_16.png index 924d0c1dc..0838f9849 100644 Binary files a/inherit_graph_16.png and b/inherit_graph_16.png differ diff --git a/inherit_graph_17.map b/inherit_graph_17.map index 65672c65c..68b105f9f 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 95847419f..b4cc67996 100644 --- a/inherit_graph_17.md5 +++ b/inherit_graph_17.md5 @@ -1 +1 @@ -c978a805ca3e2559509fb10fb22ba569 \ No newline at end of file +20c874a300d88122441dac8e77bf11e8 \ No newline at end of file diff --git a/inherit_graph_17.png b/inherit_graph_17.png index bfd542e06..6ce02376d 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 406d96210..f59ca3c15 100644 --- a/inherit_graph_18.map +++ b/inherit_graph_18.map @@ -1,4 +1,3 @@ - - + diff --git a/inherit_graph_18.md5 b/inherit_graph_18.md5 index a144f15c3..9e985e6b1 100644 --- a/inherit_graph_18.md5 +++ b/inherit_graph_18.md5 @@ -1 +1 @@ -fc1f86739a4afb1e6029acc37b9af06c \ No newline at end of file +68c3f1d2aaee71c81615b1ee951d2af7 \ No newline at end of file diff --git a/inherit_graph_18.png b/inherit_graph_18.png index 7d998f344..924d0c1dc 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 0ec2cbabf..65672c65c 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 96a74eaf2..95847419f 100644 --- a/inherit_graph_19.md5 +++ b/inherit_graph_19.md5 @@ -1 +1 @@ -8717e582ab01906c25cce74e94efc8ba \ No newline at end of file +c978a805ca3e2559509fb10fb22ba569 \ No newline at end of file diff --git a/inherit_graph_19.png b/inherit_graph_19.png index 8001af7f7..bfd542e06 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 4a54762fb..406d96210 100644 --- a/inherit_graph_20.map +++ b/inherit_graph_20.map @@ -1,3 +1,4 @@ - + + diff --git a/inherit_graph_20.md5 b/inherit_graph_20.md5 index cee282778..79029b2fd 100644 --- a/inherit_graph_20.md5 +++ b/inherit_graph_20.md5 @@ -1 +1 @@ -290a5b9298ed0c6980ce61d3800f8661 \ No newline at end of file +4d9979ed2fcc17345a05e91549c6f353 \ No newline at end of file diff --git a/inherit_graph_20.png b/inherit_graph_20.png index d4e6d5031..7d998f344 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 6aba09019..0ec2cbabf 100644 --- a/inherit_graph_21.map +++ b/inherit_graph_21.map @@ -1,3 +1,3 @@ - + diff --git a/inherit_graph_21.md5 b/inherit_graph_21.md5 index e148f959b..96a74eaf2 100644 --- a/inherit_graph_21.md5 +++ b/inherit_graph_21.md5 @@ -1 +1 @@ -9a33b8231c878d5e6ebdbdd360973b53 \ No newline at end of file +8717e582ab01906c25cce74e94efc8ba \ No newline at end of file diff --git a/inherit_graph_21.png b/inherit_graph_21.png index 5250f1daa..8001af7f7 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 9f5c41240..4a54762fb 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 75b65452a..cee282778 100644 --- a/inherit_graph_22.md5 +++ b/inherit_graph_22.md5 @@ -1 +1 @@ -4e394cd62968962a42441b4a70fd88e4 \ No newline at end of file +290a5b9298ed0c6980ce61d3800f8661 \ No newline at end of file diff --git a/inherit_graph_22.png b/inherit_graph_22.png index d34389072..d4e6d5031 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 35299d892..6aba09019 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 da199b4a4..e148f959b 100644 --- a/inherit_graph_23.md5 +++ b/inherit_graph_23.md5 @@ -1 +1 @@ -51bd2d62cec2bcbbf0df1dd79babf051 \ No newline at end of file +9a33b8231c878d5e6ebdbdd360973b53 \ No newline at end of file diff --git a/inherit_graph_23.png b/inherit_graph_23.png index c96052a26..5250f1daa 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 62d3a9d46..9f5c41240 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 6fed19d4c..75b65452a 100644 --- a/inherit_graph_24.md5 +++ b/inherit_graph_24.md5 @@ -1 +1 @@ -79f5be431b4e27136879c42af4894284 \ No newline at end of file +4e394cd62968962a42441b4a70fd88e4 \ No newline at end of file diff --git a/inherit_graph_24.png b/inherit_graph_24.png index bbb8862d7..d34389072 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 ee7694b54..35299d892 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 e363686c9..da199b4a4 100644 --- a/inherit_graph_25.md5 +++ b/inherit_graph_25.md5 @@ -1 +1 @@ -b13e94c37667394c061cef177073e658 \ No newline at end of file +51bd2d62cec2bcbbf0df1dd79babf051 \ No newline at end of file diff --git a/inherit_graph_25.png b/inherit_graph_25.png index 37a607526..c96052a26 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 a8b498de3..62d3a9d46 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 d815e7823..6fed19d4c 100644 --- a/inherit_graph_26.md5 +++ b/inherit_graph_26.md5 @@ -1 +1 @@ -fcd13fd54c20a3b15b68df42f79e8750 \ No newline at end of file +79f5be431b4e27136879c42af4894284 \ No newline at end of file diff --git a/inherit_graph_26.png b/inherit_graph_26.png index d5e41b427..bbb8862d7 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 f63e56225..ee7694b54 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 8f03789a1..e363686c9 100644 --- a/inherit_graph_27.md5 +++ b/inherit_graph_27.md5 @@ -1 +1 @@ -041e5c12848cb9cfed45decbf29ab84a \ No newline at end of file +b13e94c37667394c061cef177073e658 \ No newline at end of file diff --git a/inherit_graph_27.png b/inherit_graph_27.png index 3b0848620..37a607526 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 286c35707..80abd0278 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 a6cb78e10..dbd2320db 100644 --- a/inherit_graph_28.md5 +++ b/inherit_graph_28.md5 @@ -1 +1 @@ -e0f7a1b094358c98dff7a3cba8246d13 \ No newline at end of file +27181bb2a8663aecc220cf73a1a33ee4 \ No newline at end of file diff --git a/inherit_graph_28.png b/inherit_graph_28.png index c561eac44..616d06561 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 41d8fb1ad..a8b498de3 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 03a4f00cc..d815e7823 100644 --- a/inherit_graph_29.md5 +++ b/inherit_graph_29.md5 @@ -1 +1 @@ -2b8e115b2ba3fed570323e8375588ece \ No newline at end of file +fcd13fd54c20a3b15b68df42f79e8750 \ No newline at end of file diff --git a/inherit_graph_29.png b/inherit_graph_29.png index c476458de..d5e41b427 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 2c9d579f9..f63e56225 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 7567b4969..8f03789a1 100644 --- a/inherit_graph_30.md5 +++ b/inherit_graph_30.md5 @@ -1 +1 @@ -32f62226ed08bbc862cab90e19b0b664 \ No newline at end of file +041e5c12848cb9cfed45decbf29ab84a \ No newline at end of file diff --git a/inherit_graph_30.png b/inherit_graph_30.png index 6dc9a20bb..3b0848620 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 b0c28a377..286c35707 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 9c537fb89..a6cb78e10 100644 --- a/inherit_graph_31.md5 +++ b/inherit_graph_31.md5 @@ -1 +1 @@ -38369dcd720ab0039d7bc3ae6bd935b7 \ No newline at end of file +e0f7a1b094358c98dff7a3cba8246d13 \ No newline at end of file diff --git a/inherit_graph_31.png b/inherit_graph_31.png index d7273b5ec..c561eac44 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 7902bf72e..41d8fb1ad 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 c66e60a30..9bb2e0c64 100644 --- a/inherit_graph_32.md5 +++ b/inherit_graph_32.md5 @@ -1 +1 @@ -452c0cc41e45b4a0855838fb8e7a10ff \ No newline at end of file +e261121843365a6714cf47f6436ea958 \ No newline at end of file diff --git a/inherit_graph_32.png b/inherit_graph_32.png index abac03b9a..c476458de 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 85ec12751..2c9d579f9 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 affeb35a9..7567b4969 100644 --- a/inherit_graph_33.md5 +++ b/inherit_graph_33.md5 @@ -1 +1 @@ -8abb22caca0c349e0d2a583fd575dc99 \ No newline at end of file +32f62226ed08bbc862cab90e19b0b664 \ No newline at end of file diff --git a/inherit_graph_33.png b/inherit_graph_33.png index f5b0eb482..6dc9a20bb 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 c511abbe7..b0c28a377 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 da5341960..9c537fb89 100644 --- a/inherit_graph_34.md5 +++ b/inherit_graph_34.md5 @@ -1 +1 @@ -1fadc2ef69a803635ec75ea2c3f6a5f2 \ No newline at end of file +38369dcd720ab0039d7bc3ae6bd935b7 \ No newline at end of file diff --git a/inherit_graph_34.png b/inherit_graph_34.png index 270cb90fe..d7273b5ec 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 b11003411..7902bf72e 100644 --- a/inherit_graph_35.map +++ b/inherit_graph_35.map @@ -1,4 +1,3 @@ - - + diff --git a/inherit_graph_35.md5 b/inherit_graph_35.md5 index c522d3c5e..c66e60a30 100644 --- a/inherit_graph_35.md5 +++ b/inherit_graph_35.md5 @@ -1 +1 @@ -8b49e5d4ab6821a094273ac533350361 \ No newline at end of file +452c0cc41e45b4a0855838fb8e7a10ff \ No newline at end of file diff --git a/inherit_graph_35.png b/inherit_graph_35.png index 9c3ded490..abac03b9a 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 8b565bf7e..85ec12751 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 b79b6846b..affeb35a9 100644 --- a/inherit_graph_36.md5 +++ b/inherit_graph_36.md5 @@ -1 +1 @@ -621c711cd444e7dcd7b795f1703c5cd0 \ No newline at end of file +8abb22caca0c349e0d2a583fd575dc99 \ No newline at end of file diff --git a/inherit_graph_36.png b/inherit_graph_36.png index 3b9f3f3b9..f5b0eb482 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 f3f0e77bd..c511abbe7 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 177fc5aa0..da5341960 100644 --- a/inherit_graph_37.md5 +++ b/inherit_graph_37.md5 @@ -1 +1 @@ -ed043cf7fc8e24545bbc5bcb24759660 \ No newline at end of file +1fadc2ef69a803635ec75ea2c3f6a5f2 \ No newline at end of file diff --git a/inherit_graph_37.png b/inherit_graph_37.png index 5697d7f2a..270cb90fe 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 8c48d78eb..b11003411 100644 --- a/inherit_graph_38.map +++ b/inherit_graph_38.map @@ -1,3 +1,4 @@ - + + diff --git a/inherit_graph_38.md5 b/inherit_graph_38.md5 index cc16fa558..c522d3c5e 100644 --- a/inherit_graph_38.md5 +++ b/inherit_graph_38.md5 @@ -1 +1 @@ -38a5043984aa729fe65aca223c7ae6b5 \ No newline at end of file +8b49e5d4ab6821a094273ac533350361 \ No newline at end of file diff --git a/inherit_graph_38.png b/inherit_graph_38.png index 1859301ff..9c3ded490 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 cd9cba107..8b565bf7e 100644 --- a/inherit_graph_39.map +++ b/inherit_graph_39.map @@ -1,3 +1,3 @@ - + diff --git a/inherit_graph_39.md5 b/inherit_graph_39.md5 index dcda05878..b79b6846b 100644 --- a/inherit_graph_39.md5 +++ b/inherit_graph_39.md5 @@ -1 +1 @@ -4dcecc0d02b196a20c46b12b739ad30e \ No newline at end of file +621c711cd444e7dcd7b795f1703c5cd0 \ No newline at end of file diff --git a/inherit_graph_39.png b/inherit_graph_39.png index 0c5a70d46..3b9f3f3b9 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 d4b0989d5..f3f0e77bd 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 054df0392..177fc5aa0 100644 --- a/inherit_graph_40.md5 +++ b/inherit_graph_40.md5 @@ -1 +1 @@ -e858ed2f3c399ac5179f89b14a40a3d7 \ No newline at end of file +ed043cf7fc8e24545bbc5bcb24759660 \ No newline at end of file diff --git a/inherit_graph_40.png b/inherit_graph_40.png index 0c5a70d46..5697d7f2a 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 new file mode 100644 index 000000000..8c48d78eb --- /dev/null +++ b/inherit_graph_41.map @@ -0,0 +1,3 @@ + + + diff --git a/inherit_graph_41.md5 b/inherit_graph_41.md5 new file mode 100644 index 000000000..cc16fa558 --- /dev/null +++ b/inherit_graph_41.md5 @@ -0,0 +1 @@ +38a5043984aa729fe65aca223c7ae6b5 \ No newline at end of file diff --git a/inherit_graph_41.png b/inherit_graph_41.png new file mode 100644 index 000000000..1859301ff Binary files /dev/null and b/inherit_graph_41.png differ diff --git a/inherit_graph_42.map b/inherit_graph_42.map new file mode 100644 index 000000000..cd9cba107 --- /dev/null +++ b/inherit_graph_42.map @@ -0,0 +1,3 @@ + + + diff --git a/inherit_graph_42.md5 b/inherit_graph_42.md5 new file mode 100644 index 000000000..dcda05878 --- /dev/null +++ b/inherit_graph_42.md5 @@ -0,0 +1 @@ +4dcecc0d02b196a20c46b12b739ad30e \ No newline at end of file diff --git a/inherit_graph_42.png b/inherit_graph_42.png new file mode 100644 index 000000000..0c5a70d46 Binary files /dev/null and b/inherit_graph_42.png differ diff --git a/inherit_graph_43.map b/inherit_graph_43.map new file mode 100644 index 000000000..d4b0989d5 --- /dev/null +++ b/inherit_graph_43.map @@ -0,0 +1,3 @@ + + + diff --git a/inherit_graph_43.md5 b/inherit_graph_43.md5 new file mode 100644 index 000000000..054df0392 --- /dev/null +++ b/inherit_graph_43.md5 @@ -0,0 +1 @@ +e858ed2f3c399ac5179f89b14a40a3d7 \ No newline at end of file diff --git a/inherit_graph_43.png b/inherit_graph_43.png new file mode 100644 index 000000000..0c5a70d46 Binary files /dev/null and b/inherit_graph_43.png differ diff --git a/inherit_graph_7.md5 b/inherit_graph_7.md5 index 1f3adf0ce..65a0cb47d 100644 --- a/inherit_graph_7.md5 +++ b/inherit_graph_7.md5 @@ -1 +1 @@ -01f5fadf3e4dea93a6b815c3226592d2 \ No newline at end of file +40f4469fb7f11fef360e323dce4d8001 \ No newline at end of file diff --git a/inherits.html b/inherits.html index c44eeb367..95d14b8c2 100644 --- a/inherits.html +++ b/inherits.html @@ -136,139 +136,154 @@ $(function() { - + + + + + + - + + + + + + - + - + - + - + - + - + - + - + - + - + - + + + + + + - + - + - + - + - + - + - + - + - + - + - + - + - + - + diff --git a/menudata.js b/menudata.js index 3a6475d47..eb678ef42 100644 --- a/menudata.js +++ b/menudata.js @@ -61,7 +61,6 @@ var menudata={children:[ {text:"i",url:"functions_type.html#index_i"}, {text:"l",url:"functions_type.html#index_l"}, {text:"o",url:"functions_type.html#index_o"}, -{text:"p",url:"functions_type.html#index_p"}, {text:"r",url:"functions_type.html#index_r"}, {text:"s",url:"functions_type.html#index_s"}, {text:"t",url:"functions_type.html#index_t"}, diff --git a/monostate_8hpp_source.html b/monostate_8hpp_source.html new file mode 100644 index 000000000..8cafe0910 --- /dev/null +++ b/monostate_8hpp_source.html @@ -0,0 +1,81 @@ + + + + + + + +entt: src/entt/core/monostate.hpp Source File + + + + + + + + + +
    +
    + + + + + + +
    +
    entt +  2.6.1 +
    +
    +
    + + + + + + + + +
    +
    + + +
    + +
    + + +
    +
    +
    +
    monostate.hpp
    +
    +
    +
    1 #ifndef ENTT_CORE_MONOSTATE_HPP
    2 #define ENTT_CORE_MONOSTATE_HPP
    3 
    4 
    5 #include <atomic>
    6 #include <cassert>
    7 #include "family.hpp"
    8 #include "hashed_string.hpp"
    9 
    10 
    11 namespace entt {
    12 
    13 
    25 template<HashedString::hash_type>
    26 struct Monostate {
    32  template<typename Type>
    33  void operator=(Type val) const ENTT_NOEXCEPT {
    34  Monostate::value<Type> = val;
    35  }
    36 
    42  template<typename Type>
    43  operator Type() const ENTT_NOEXCEPT {
    44  return Monostate::value<Type>;
    45  }
    46 
    47 private:
    48  template<typename Type>
    49  static std::atomic<Type> value;
    50 };
    51 
    52 
    53 template<HashedString::hash_type ID>
    54 template<typename Type>
    55 std::atomic<Type> Monostate<ID>::value{};
    56 
    57 
    58 }
    59 
    60 
    61 #endif // ENTT_CORE_MONOSTATE_HPP
    entt::Monostate::operator=
    void operator=(Type val) const ENTT_NOEXCEPT
    Assigns a value of a specific type to a given key.
    Definition: monostate.hpp:33
    +
    entt::Monostate
    Minimal implementation of the monostate pattern.
    Definition: monostate.hpp:26
    +
    entt
    EnTT default namespace.
    Definition: algorithm.hpp:10
    +
    + +
    +Generated by   +doxygen + 1.8.13 +
    + + diff --git a/namespaceentt.html b/namespaceentt.html index 89145443d..12e02dc4f 100644 --- a/namespaceentt.html +++ b/namespaceentt.html @@ -113,9 +113,15 @@ Classes class  HashedString  Zero overhead resource identifier. More...
      +class  Identifier + Types identifiers. More...
    +  struct  InsertionSort  Function object for performing insertion sort. More...
      +struct  Monostate + Minimal implementation of the monostate pattern. More...
    +  struct  persistent_t  Persistent view type used to disambiguate overloads. More...
      @@ -149,6 +155,9 @@ Classes class  ResourceLoader  Base class for resource loaders. More...
      +class  RuntimeView + Runtime view. More...
    +  class  Scheduler  Cooperative scheduler for processes. More...
      @@ -200,9 +209,9 @@ Typedefs using DefaultActor = Actor< DefaultRegistry::entity_type >  Default actor class. More...
      -using DefaultPrototype = Prototype< std::uint32_t > - Default prototype. More...
    -  +using DefaultPrototype = Prototype< DefaultRegistry::entity_type > + Default prototype. More...
    +  using DefaultRegistry = Registry< std::uint32_t >  Default registry class. More...
      @@ -235,10 +244,9 @@ Functions - - - - + + +

    Variables

    template<typename... Types>
    constexpr auto ident = internal::Identifier<std::decay_t<Types>...>{std::make_index_sequence<sizeof...(Types)>{}}
     Types identifers. More...
     
    constexpr auto null = internal::Null{}
     Null entity. More...
     

    Detailed Description

    EnTT default namespace.

    @@ -263,14 +271,14 @@ Variables
    - -

    ◆ DefaultPrototype

    + +

    ◆ DefaultPrototype

    - +
    using entt::DefaultPrototype = typedef Prototype<std::uint32_t>using entt::DefaultPrototype = typedef Prototype<DefaultRegistry::entity_type>
    @@ -279,7 +287,7 @@ Variables

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

    -

    Definition at line 446 of file prototype.hpp.

    +

    Definition at line 490 of file prototype.hpp.

    @@ -299,7 +307,7 @@ 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 1501 of file registry.hpp.

    +

    Definition at line 1598 of file registry.hpp.

    @@ -527,7 +535,7 @@ template<typename Ret , typename... Args>
    Returns
    True if the two delegates are different, false otherwise.
    -

    Definition at line 130 of file delegate.hpp.

    +

    Definition at line 137 of file delegate.hpp.

    @@ -582,33 +590,22 @@ template<typename Ret , typename... Args>

    Variable Documentation

    - -

    ◆ ident

    + +

    ◆ null

    -
    -template<typename... Types>
    - +
    constexpr auto entt::ident = internal::Identifier<std::decay_t<Types>...>{std::make_index_sequence<sizeof...(Types)>{}}constexpr auto entt::null = internal::Null{}
    -

    Types identifers.

    -

    Variable template used to generate identifiers at compile-time for the given types. Use the constexpr get member function to know what's the identifier associated to the specific type.

    -
    Note
    Identifiers are constant expression and can be used in any context where such an expression is required. As an example:
    constexpr auto identifiers = entt::ident<AType, AnotherType>;
    switch(aTypeIdentifier) {
    case identifers.get<AType>():
    // ...
    break;
    case identifers.get<AnotherType>():
    // ...
    break;
    default:
    // ...
    }
    -
    -In case of single type list, get isn't a member function template:
    func(std::integral_constant<
    entt::ident<AType>::identifier_type,
    entt::ident<AType>::get()
    >{});
    -
    Template Parameters
    - - -
    TypesList of types for which to generate identifiers.
    -
    -
    +

    Null entity.

    +

    There exist implicit conversions from this variable to entity identifiers of any allowed type. Similarly, there exist comparision operators between the null entity and any other entity identifier.

    -

    Definition at line 103 of file ident.hpp.

    +

    Definition at line 81 of file entity.hpp.

    diff --git a/namespacemembers.html b/namespacemembers.html index 60c5d7197..d6ab83de6 100644 --- a/namespacemembers.html +++ b/namespacemembers.html @@ -64,7 +64,7 @@ $(function() { : entt
  • DefaultPrototype -: entt +: entt
  • DefaultRegistry : entt @@ -72,8 +72,8 @@ $(function() {
  • dependency() : entt
    • -
  • ident -: entt +
  • null +: entt
  • operator!=() : entt diff --git a/namespacemembers_type.html b/namespacemembers_type.html index 3d268d01e..eec00c81f 100644 --- a/namespacemembers_type.html +++ b/namespacemembers_type.html @@ -64,7 +64,7 @@ $(function() { : entt
  • DefaultPrototype -: entt +: entt
  • DefaultRegistry : entt diff --git a/namespacemembers_vars.html b/namespacemembers_vars.html index bcae59b74..6e9b81c6b 100644 --- a/namespacemembers_vars.html +++ b/namespacemembers_vars.html @@ -60,8 +60,8 @@ $(function() {
     
    diff --git a/prototype_8hpp_source.html b/prototype_8hpp_source.html index 85bb8c7a6..a8dc2ccca 100644 --- a/prototype_8hpp_source.html +++ b/prototype_8hpp_source.html @@ -67,27 +67,30 @@ $(function() {
    prototype.hpp
    -
    1 #ifndef ENTT_ENTITY_PROTOTYPE_HPP
    2 #define ENTT_ENTITY_PROTOTYPE_HPP
    3 
    4 
    5 #include <tuple>
    6 #include <utility>
    7 #include <cstddef>
    8 #include <type_traits>
    9 #include <unordered_map>
    10 #include "../config/config.h"
    11 #include "registry.hpp"
    12 
    13 
    14 namespace entt {
    15 
    16 
    38 template<typename Entity>
    39 class Prototype final {
    40  using fn_type = void(*)(const Prototype &, Registry<Entity> &, const Entity);
    41  using component_type = typename Registry<Entity>::component_type;
    42 
    43  template<typename Component>
    44  struct Wrapper { Component component; };
    45 
    46  struct Handler {
    47  fn_type accommodate;
    48  fn_type assign;
    49  };
    50 
    51 public:
    53  using registry_type = Registry<Entity>;
    55  using entity_type = Entity;
    57  using size_type = std::size_t;
    58 
    63  Prototype(Registry<Entity> &registry)
    64  : registry{registry},
    65  entity{registry.create()}
    66  {}
    67 
    71  ~Prototype() {
    72  registry.destroy(entity);
    73  }
    74 
    82  template<typename Component, typename... Args>
    83  Component & set(Args &&... args) {
    84  fn_type accommodate = [](const Prototype &prototype, Registry<Entity> &other, const Entity dst) {
    85  const auto &wrapper = prototype.registry.template get<Wrapper<Component>>(prototype.entity);
    86  other.template accommodate<Component>(dst, wrapper.component);
    87  };
    88 
    89  fn_type assign = [](const Prototype &prototype, Registry<Entity> &other, const Entity dst) {
    90  if(!other.template has<Component>(dst)) {
    91  const auto &wrapper = prototype.registry.template get<Wrapper<Component>>(prototype.entity);
    92  other.template accommodate<Component>(dst, wrapper.component);
    93  }
    94  };
    95 
    96  handlers[registry.template type<Component>()] = Handler{accommodate, assign};
    97  auto &wrapper = registry.template accommodate<Wrapper<Component>>(entity, Component{std::forward<Args>(args)...});
    98  return wrapper.component;
    99  }
    100 
    105  template<typename Component>
    106  void unset() ENTT_NOEXCEPT {
    107  registry.template reset<Wrapper<Component>>(entity);
    108  handlers.erase(registry.template type<Component>());
    109  }
    110 
    116  template<typename... Component>
    117  bool has() const ENTT_NOEXCEPT {
    118  return registry.template has<Wrapper<Component>...>(entity);
    119  }
    120 
    133  template<typename Component>
    134  const Component & get() const ENTT_NOEXCEPT {
    135  return registry.template get<Wrapper<Component>>(entity).component;
    136  }
    137 
    150  template<typename Component>
    151  inline Component & get() ENTT_NOEXCEPT {
    152  return const_cast<Component &>(const_cast<const Prototype *>(this)->get<Component>());
    153  }
    154 
    167  template<typename... Component>
    168  inline std::enable_if_t<(sizeof...(Component) > 1), std::tuple<const Component &...>>
    169  get() const ENTT_NOEXCEPT {
    170  return std::tuple<const Component &...>{get<Component>()...};
    171  }
    172 
    185  template<typename... Component>
    186  inline std::enable_if_t<(sizeof...(Component) > 1), std::tuple<Component &...>>
    187  get() ENTT_NOEXCEPT {
    188  return std::tuple<Component &...>{get<Component>()...};
    189  }
    190 
    209  entity_type create(registry_type &other) const {
    210  const auto entity = other.create();
    211  assign(other, entity);
    212  return entity;
    213  }
    214 
    232  entity_type create() const {
    233  const auto entity = registry.create();
    234  assign(registry, entity);
    235  return entity;
    236  }
    237 
    259  void assign(registry_type &other, const entity_type dst) const {
    260  for(auto &handler: handlers) {
    261  handler.second.assign(*this, other, dst);
    262  }
    263  }
    264 
    285  void assign(const entity_type dst) const {
    286  for(auto &handler: handlers) {
    287  handler.second.assign(*this, registry, dst);
    288  }
    289  }
    290 
    310  void accommodate(registry_type &other, const entity_type dst) const {
    311  for(auto &handler: handlers) {
    312  handler.second.accommodate(*this, other, dst);
    313  }
    314  }
    315 
    334  void accommodate(const entity_type dst) const {
    335  for(auto &handler: handlers) {
    336  handler.second.accommodate(*this, registry, dst);
    337  }
    338  }
    339 
    361  inline void operator()(registry_type &other, const entity_type dst) const ENTT_NOEXCEPT {
    362  assign(other, dst);
    363  }
    364 
    385  inline void operator()(const entity_type dst) const ENTT_NOEXCEPT {
    386  assign(registry, dst);
    387  }
    388 
    407  inline entity_type operator()(registry_type &other) const ENTT_NOEXCEPT {
    408  return create(other);
    409  }
    410 
    428  inline entity_type operator()() const ENTT_NOEXCEPT {
    429  return create(registry);
    430  }
    431 
    432 private:
    433  std::unordered_map<component_type, Handler> handlers;
    434  Registry<Entity> &registry;
    435  entity_type entity;
    436 };
    437 
    438 
    446 using DefaultPrototype = Prototype<std::uint32_t>;
    447 
    448 
    449 }
    450 
    451 
    452 #endif // ENTT_ENTITY_PROTOTYPE_HPP
    entt::Prototype::size_type
    std::size_t size_type
    Unsigned integer type.
    Definition: prototype.hpp:57
    -
    entt::Prototype::entity_type
    Entity entity_type
    Underlying entity identifier.
    Definition: prototype.hpp:55
    -
    entt::Registry
    Fast and reliable entity-component system.
    Definition: registry.hpp:39
    -
    entt::Prototype::Prototype
    Prototype(Registry< Entity > &registry)
    Constructs a prototype that is bound to a given registry.
    Definition: prototype.hpp:63
    -
    entt::Prototype::assign
    void assign(const entity_type dst) const
    Assigns the components of a prototype to a given entity.
    Definition: prototype.hpp:285
    -
    entt::Registry::create
    entity_type create() ENTT_NOEXCEPT
    Creates a new entity and returns it.
    Definition: registry.hpp:390
    +
    1 #ifndef ENTT_ENTITY_PROTOTYPE_HPP
    2 #define ENTT_ENTITY_PROTOTYPE_HPP
    3 
    4 
    5 #include <tuple>
    6 #include <utility>
    7 #include <cstddef>
    8 #include <type_traits>
    9 #include <unordered_map>
    10 #include "../config/config.h"
    11 #include "registry.hpp"
    12 
    13 
    14 namespace entt {
    15 
    16 
    38 template<typename Entity>
    39 class Prototype final {
    40  using basic_fn_type = void(const Prototype &, Registry<Entity> &, const Entity);
    41  using component_type = typename Registry<Entity>::component_type;
    42 
    43  template<typename Component>
    44  struct Wrapper { Component component; };
    45 
    46  struct Handler {
    47  basic_fn_type *accommodate;
    48  basic_fn_type *assign;
    49  };
    50 
    51  void release() {
    52  if(registry->valid(entity)) {
    53  registry->destroy(entity);
    54  }
    55  }
    56 
    57 public:
    59  using registry_type = Registry<Entity>;
    61  using entity_type = Entity;
    63  using size_type = std::size_t;
    64 
    69  Prototype(Registry<Entity> &registry)
    70  : registry{&registry},
    71  entity{registry.create()}
    72  {}
    73 
    77  ~Prototype() {
    78  release();
    79  }
    80 
    82  Prototype(const Prototype &) = delete;
    83 
    93  Prototype(Prototype &&other)
    94  : handlers{std::move(other.handlers)},
    95  registry{other.registry},
    96  entity{other.entity}
    97  {
    98  other.entity = ~entity_type{};
    99  }
    100 
    102  Prototype & operator=(const Prototype &) = delete;
    103 
    114  Prototype & operator=(Prototype &&other) {
    115  if(this != &other) {
    116  auto tmp{std::move(other)};
    117  handlers.swap(tmp.handlers);
    118  std::swap(registry, tmp.registry);
    119  std::swap(entity, tmp.entity);
    120  }
    121 
    122  return *this;
    123  }
    124 
    132  template<typename Component, typename... Args>
    133  Component & set(Args &&... args) {
    134  basic_fn_type *accommodate = [](const Prototype &prototype, Registry<Entity> &other, const Entity dst) {
    135  const auto &wrapper = prototype.registry->template get<Wrapper<Component>>(prototype.entity);
    136  other.template accommodate<Component>(dst, wrapper.component);
    137  };
    138 
    139  basic_fn_type *assign = [](const Prototype &prototype, Registry<Entity> &other, const Entity dst) {
    140  if(!other.template has<Component>(dst)) {
    141  const auto &wrapper = prototype.registry->template get<Wrapper<Component>>(prototype.entity);
    142  other.template accommodate<Component>(dst, wrapper.component);
    143  }
    144  };
    145 
    146  handlers[registry->template type<Component>()] = Handler{accommodate, assign};
    147  auto &wrapper = registry->template accommodate<Wrapper<Component>>(entity, Component{std::forward<Args>(args)...});
    148  return wrapper.component;
    149  }
    150 
    155  template<typename Component>
    156  void unset() ENTT_NOEXCEPT {
    157  registry->template reset<Wrapper<Component>>(entity);
    158  handlers.erase(registry->template type<Component>());
    159  }
    160 
    166  template<typename... Component>
    167  bool has() const ENTT_NOEXCEPT {
    168  return registry->template has<Wrapper<Component>...>(entity);
    169  }
    170 
    183  template<typename Component>
    184  const Component & get() const ENTT_NOEXCEPT {
    185  return registry->template get<Wrapper<Component>>(entity).component;
    186  }
    187 
    200  template<typename Component>
    201  inline Component & get() ENTT_NOEXCEPT {
    202  return const_cast<Component &>(const_cast<const Prototype *>(this)->get<Component>());
    203  }
    204 
    217  template<typename... Component>
    218  inline std::enable_if_t<(sizeof...(Component) > 1), std::tuple<const Component &...>>
    219  get() const ENTT_NOEXCEPT {
    220  return std::tuple<const Component &...>{get<Component>()...};
    221  }
    222 
    235  template<typename... Component>
    236  inline std::enable_if_t<(sizeof...(Component) > 1), std::tuple<Component &...>>
    237  get() ENTT_NOEXCEPT {
    238  return std::tuple<Component &...>{get<Component>()...};
    239  }
    240 
    259  entity_type create(registry_type &other) const {
    260  const auto entity = other.create();
    261  assign(other, entity);
    262  return entity;
    263  }
    264 
    282  inline entity_type create() const {
    283  return create(*registry);
    284  }
    285 
    307  void assign(registry_type &other, const entity_type dst) const {
    308  for(auto &handler: handlers) {
    309  handler.second.assign(*this, other, dst);
    310  }
    311  }
    312 
    333  inline void assign(const entity_type dst) const {
    334  assign(*registry, dst);
    335  }
    336 
    356  void accommodate(registry_type &other, const entity_type dst) const {
    357  for(auto &handler: handlers) {
    358  handler.second.accommodate(*this, other, dst);
    359  }
    360  }
    361 
    380  inline void accommodate(const entity_type dst) const {
    381  accommodate(*registry, dst);
    382  }
    383 
    405  inline void operator()(registry_type &other, const entity_type dst) const ENTT_NOEXCEPT {
    406  assign(other, dst);
    407  }
    408 
    429  inline void operator()(const entity_type dst) const ENTT_NOEXCEPT {
    430  assign(*registry, dst);
    431  }
    432 
    451  inline entity_type operator()(registry_type &other) const ENTT_NOEXCEPT {
    452  return create(other);
    453  }
    454 
    472  inline entity_type operator()() const ENTT_NOEXCEPT {
    473  return create(*registry);
    474  }
    475 
    476 private:
    477  std::unordered_map<component_type, Handler> handlers;
    478  Registry<Entity> *registry;
    479  entity_type entity;
    480 };
    481 
    482 
    490 using DefaultPrototype = Prototype<DefaultRegistry::entity_type>;
    491 
    492 
    493 }
    494 
    495 
    496 #endif // ENTT_ENTITY_PROTOTYPE_HPP
    entt::Prototype::size_type
    std::size_t size_type
    Unsigned integer type.
    Definition: prototype.hpp:63
    +
    entt::Prototype::entity_type
    Entity entity_type
    Underlying entity identifier.
    Definition: prototype.hpp:61
    +
    entt::Registry
    Fast and reliable entity-component system.
    Definition: registry.hpp:40
    +
    entt::Prototype::Prototype
    Prototype(Registry< Entity > &registry)
    Constructs a prototype that is bound to a given registry.
    Definition: prototype.hpp:69
    +
    entt::Prototype::assign
    void assign(const entity_type dst) const
    Assigns the components of a prototype to a given entity.
    Definition: prototype.hpp:333
    +
    entt::Prototype::Prototype
    Prototype(Prototype &&other)
    Move constructor.
    Definition: prototype.hpp:93
    entt
    EnTT default namespace.
    Definition: algorithm.hpp:10
    -
    entt::Prototype::operator()
    void operator()(const entity_type dst) const ENTT_NOEXCEPT
    Assigns the components of a prototype to an entity.
    Definition: prototype.hpp:385
    -
    entt::Prototype::create
    entity_type create() const
    Creates a new entity using a given prototype.
    Definition: prototype.hpp:232
    -
    entt::Prototype::accommodate
    void accommodate(registry_type &other, const entity_type dst) const
    Assigns or replaces the components of a prototype for an entity.
    Definition: prototype.hpp:310
    -
    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:361
    -
    entt::Prototype::~Prototype
    ~Prototype()
    Releases all its resources.
    Definition: prototype.hpp:71
    -
    entt::Prototype::unset
    void unset() ENTT_NOEXCEPT
    Removes the given component from a prototype.
    Definition: prototype.hpp:106
    -
    entt::Prototype::operator()
    entity_type operator()(registry_type &other) const ENTT_NOEXCEPT
    Creates a new entity using a given prototype.
    Definition: prototype.hpp:407
    -
    entt::Prototype::has
    bool has() const ENTT_NOEXCEPT
    Checks if a prototype owns all the given components.
    Definition: prototype.hpp:117
    -
    entt::Registry::component_type
    typename component_family::family_type component_type
    Unsigned integer type.
    Definition: registry.hpp:128
    -
    entt::Prototype::operator()
    entity_type operator()() const ENTT_NOEXCEPT
    Creates a new entity using a given prototype.
    Definition: prototype.hpp:428
    +
    entt::Prototype::operator()
    void operator()(const entity_type dst) const ENTT_NOEXCEPT
    Assigns the components of a prototype to an entity.
    Definition: prototype.hpp:429
    +
    entt::Prototype::create
    entity_type create() const
    Creates a new entity using a given prototype.
    Definition: prototype.hpp:282
    +
    entt::Prototype::accommodate
    void accommodate(registry_type &other, const entity_type dst) const
    Assigns or replaces the components of a prototype for an entity.
    Definition: prototype.hpp:356
    +
    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::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::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:259
    -
    entt::Prototype::accommodate
    void accommodate(const entity_type dst) const
    Assigns or replaces the components of a prototype for an entity.
    Definition: prototype.hpp:334
    -
    entt::Prototype::create
    entity_type create(registry_type &other) const
    Creates a new entity using a given prototype.
    Definition: prototype.hpp:209
    +
    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
    +
    entt::Prototype::accommodate
    void accommodate(const entity_type dst) const
    Assigns or replaces the components of a prototype for an entity.
    Definition: prototype.hpp:380
    +
    entt::Prototype::operator=
    Prototype & operator=(Prototype &&other)
    Move assignment operator.
    Definition: prototype.hpp:114
    +
    entt::Prototype::create
    entity_type create(registry_type &other) const
    Creates a new entity using a given prototype.
    Definition: prototype.hpp:259
    diff --git a/registry_8hpp_source.html b/registry_8hpp_source.html index 468fe361d..a5da1296f 100644 --- a/registry_8hpp_source.html +++ b/registry_8hpp_source.html @@ -67,78 +67,84 @@ $(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 <algorithm>
    13 #include <type_traits>
    14 #include "../config/config.h"
    15 #include "../core/algorithm.hpp"
    16 #include "../core/family.hpp"
    17 #include "../signal/sigh.hpp"
    18 #include "entt_traits.hpp"
    19 #include "snapshot.hpp"
    20 #include "sparse_set.hpp"
    21 #include "utility.hpp"
    22 #include "view.hpp"
    23 
    24 
    25 namespace entt {
    26 
    27 
    38 template<typename Entity>
    39 class Registry {
    40  using tag_family = Family<struct InternalRegistryTagFamily>;
    41  using component_family = Family<struct InternalRegistryComponentFamily>;
    42  using handler_family = Family<struct InternalRegistryHandlerFamily>;
    43  using signal_type = SigH<void(Registry &, const Entity)>;
    44  using traits_type = entt_traits<Entity>;
    45 
    46  template<typename... Component>
    47  static void creating(Registry &registry, const Entity entity) {
    48  if(registry.has<Component...>(entity)) {
    49  registry.handlers[handler_family::type<Component...>()]->construct(entity);
    50  }
    51  }
    52 
    53  template<typename... Component>
    54  static void destroying(Registry &registry, const Entity entity) {
    55  auto &handler = *registry.handlers[handler_family::type<Component...>()];
    56  return handler.has(entity) ? handler.destroy(entity) : void();
    57  }
    58 
    59  struct Attachee {
    60  Attachee(const Entity entity): entity{entity} {}
    61  virtual ~Attachee() = default;
    62  Entity entity;
    63  };
    64 
    65  template<typename Tag>
    66  struct Attaching: Attachee {
    67  // requirements for aggregates are relaxed only since C++17
    68  template<typename... Args>
    69  Attaching(const Entity entity, Args &&... args)
    70  : Attachee{entity}, tag{std::forward<Args>(args)...}
    71  {}
    72 
    73  Tag tag;
    74  };
    75 
    76  template<typename Component>
    77  bool managed() const ENTT_NOEXCEPT {
    78  const auto ctype = component_family::type<Component>();
    79  return ctype < pools.size() && std::get<0>(pools[ctype]);
    80  }
    81 
    82  template<typename Component>
    83  const SparseSet<Entity, Component> & pool() const ENTT_NOEXCEPT {
    84  assert(managed<Component>());
    85  const auto ctype = component_family::type<Component>();
    86  return static_cast<SparseSet<Entity, Component> &>(*std::get<0>(pools[ctype]));
    87  }
    88 
    89  template<typename Component>
    90  inline SparseSet<Entity, Component> & pool() ENTT_NOEXCEPT {
    91  return const_cast<SparseSet<Entity, Component> &>(const_cast<const Registry *>(this)->pool<Component>());
    92  }
    93 
    94  template<typename Component>
    95  void assure() {
    96  const auto ctype = component_family::type<Component>();
    97 
    98  if(!(ctype < pools.size())) {
    99  pools.resize(ctype + 1);
    100  }
    101 
    102  auto &cpool = std::get<0>(pools[ctype]);
    103 
    104  if(!cpool) {
    105  cpool = std::make_unique<SparseSet<Entity, Component>>();
    106  }
    107  }
    108 
    109  template<typename Tag>
    110  void assure(tag_t) {
    111  const auto ttype = tag_family::type<Tag>();
    112 
    113  if(!(ttype < tags.size())) {
    114  tags.resize(ttype + 1);
    115  }
    116  }
    117 
    118 public:
    120  using entity_type = typename traits_type::entity_type;
    122  using version_type = typename traits_type::version_type;
    124  using size_type = std::size_t;
    126  using tag_type = typename tag_family::family_type;
    128  using component_type = typename component_family::family_type;
    130  using sink_type = typename signal_type::sink_type;
    131 
    133  Registry() = default;
    134 
    136  Registry(const Registry &) = delete;
    138  Registry(Registry &&) = default;
    139 
    141  Registry & operator=(const Registry &) = delete;
    143  Registry & operator=(Registry &&) = default;
    144 
    157  template<typename Tag>
    158  static tag_type type(tag_t) ENTT_NOEXCEPT {
    159  return tag_family::type<Tag>();
    160  }
    161 
    174  template<typename Component>
    175  static component_type type() ENTT_NOEXCEPT {
    176  return component_family::type<Component>();
    177  }
    178 
    184  template<typename Component>
    185  size_type size() const ENTT_NOEXCEPT {
    186  return managed<Component>() ? pool<Component>().size() : size_type{};
    187  }
    188 
    193  size_type size() const ENTT_NOEXCEPT {
    194  return entities.size() - available;
    195  }
    196 
    206  template<typename Component>
    207  void reserve(const size_type cap) {
    208  assure<Component>();
    209  pool<Component>().reserve(cap);
    210  }
    211 
    220  void reserve(const size_type cap) {
    221  entities.reserve(cap);
    222  }
    223 
    228  size_type capacity() const ENTT_NOEXCEPT {
    229  return entities.size();
    230  }
    231 
    238  template<typename Component>
    239  bool empty() const ENTT_NOEXCEPT {
    240  return !managed<Component>() || pool<Component>().empty();
    241  }
    242 
    247  bool empty() const ENTT_NOEXCEPT {
    248  return entities.size() == available;
    249  }
    250 
    265  template<typename Component>
    266  const Component * raw() const ENTT_NOEXCEPT {
    267  return managed<Component>() ? pool<Component>().raw() : nullptr;
    268  }
    269 
    284  template<typename Component>
    285  inline Component * raw() ENTT_NOEXCEPT {
    286  return const_cast<Component *>(const_cast<const Registry *>(this)->raw<Component>());
    287  }
    288 
    303  template<typename Component>
    304  const entity_type * data() const ENTT_NOEXCEPT {
    305  return managed<Component>() ? pool<Component>().data() : nullptr;
    306  }
    307 
    313  bool valid(const entity_type entity) const ENTT_NOEXCEPT {
    314  const auto pos = size_type(entity & traits_type::entity_mask);
    315  return (pos < entities.size() && entities[pos] == entity);
    316  }
    317 
    335  bool fast(const entity_type entity) const ENTT_NOEXCEPT {
    336  const auto pos = size_type(entity & traits_type::entity_mask);
    337  assert(pos < entities.size());
    338  return (entities[pos] == entity);
    339  }
    340 
    346  version_type version(const entity_type entity) const ENTT_NOEXCEPT {
    347  return version_type((entity >> traits_type::entity_shift) & traits_type::version_mask);
    348  }
    349 
    367  version_type current(const entity_type entity) const ENTT_NOEXCEPT {
    368  const auto pos = size_type(entity & traits_type::entity_mask);
    369  assert(pos < entities.size());
    370  return version_type((entities[pos] >> traits_type::entity_shift) & traits_type::version_mask);
    371  }
    372 
    390  entity_type create() ENTT_NOEXCEPT {
    391  entity_type entity;
    392 
    393  if(available) {
    394  const auto entt = next;
    395  const auto version = entities[entt] & (~traits_type::entity_mask);
    396 
    397  entity = entt | version;
    398  next = entities[entt] & traits_type::entity_mask;
    399  entities[entt] = entity;
    400  --available;
    401  } else {
    402  entity = entity_type(entities.size());
    403  entities.push_back(entity);
    404  // traits_type::entity_mask is reserved to allow for null identifiers
    405  assert(entity < traits_type::entity_mask);
    406  }
    407 
    408  return entity;
    409  }
    410 
    433  void destroy(const entity_type entity) {
    434  assert(valid(entity));
    435 
    436  for(auto pos = pools.size(); pos; --pos) {
    437  auto &tup = pools[pos-1];
    438  auto &cpool = std::get<0>(tup);
    439 
    440  if(cpool && cpool->has(entity)) {
    441  std::get<2>(tup).publish(*this, entity);
    442  cpool->destroy(entity);
    443  }
    444  };
    445 
    446  for(auto pos = tags.size(); pos; --pos) {
    447  auto &tup = tags[pos-1];
    448  auto &tag = std::get<0>(tup);
    449 
    450  if(tag && tag->entity == entity) {
    451  std::get<2>(tup).publish(*this, entity);
    452  tag.reset();
    453  }
    454  };
    455 
    456  // just a way to protect users from listeners that attach components
    457  assert(orphan(entity));
    458 
    459  const auto entt = entity & traits_type::entity_mask;
    460  const auto version = (((entity >> traits_type::entity_shift) + 1) & traits_type::version_mask) << traits_type::entity_shift;
    461  const auto node = (available ? next : ((entt + 1) & traits_type::entity_mask)) | version;
    462 
    463  entities[entt] = node;
    464  next = entt;
    465  ++available;
    466  }
    467 
    489  template<typename Tag, typename... Args>
    490  Tag & assign(tag_t, const entity_type entity, Args &&... args) {
    491  assert(valid(entity));
    492  assert(!has<Tag>());
    493  assure<Tag>(tag_t{});
    494  auto &tup = tags[tag_family::type<Tag>()];
    495  std::get<0>(tup).reset(new Attaching<Tag>{entity, std::forward<Args>(args)...});
    496  std::get<1>(tup).publish(*this, entity);
    497  return get<Tag>();
    498  }
    499 
    520  template<typename Component, typename... Args>
    521  Component & assign(const entity_type entity, Args &&... args) {
    522  assert(valid(entity));
    523  assure<Component>();
    524  pool<Component>().construct(entity, std::forward<Args>(args)...);
    525  std::get<1>(pools[component_family::type<Component>()]).publish(*this, entity);
    526  return pool<Component>().get(entity);
    527  }
    528 
    533  template<typename Tag>
    534  void remove() {
    535  if(has<Tag>()) {
    536  auto &tup = tags[tag_family::type<Tag>()];
    537  auto &tag = std::get<0>(tup);
    538  std::get<2>(tup).publish(*this, tag->entity);
    539  tag.reset();
    540  }
    541  }
    542 
    556  template<typename Component>
    557  void remove(const entity_type entity) {
    558  assert(valid(entity));
    559  assert(managed<Component>());
    560  const auto ctype = component_family::type<Component>();
    561  std::get<2>(pools[ctype]).publish(*this, entity);
    562  pool<Component>().destroy(entity);
    563  }
    564 
    570  template<typename Tag>
    571  bool has() const ENTT_NOEXCEPT {
    572  const auto ttype = tag_family::type<Tag>();
    573  bool found = false;
    574 
    575  if(ttype < tags.size()) {
    576  auto &tag = std::get<0>(tags[ttype]);
    577  // it's a valid tag and the associated entity hasn't been destroyed in the meantime
    578  found = tag && (tag->entity == (entities[tag->entity & traits_type::entity_mask]));
    579  }
    580 
    581  return found;
    582  }
    583 
    597  template<typename Tag>
    598  bool has(tag_t, const entity_type entity) const ENTT_NOEXCEPT {
    599  return has<Tag>() && attachee<Tag>() == entity;
    600  }
    601 
    614  template<typename... Component>
    615  bool has(const entity_type entity) const ENTT_NOEXCEPT {
    616  assert(valid(entity));
    617  bool all = true;
    618  using accumulator_type = bool[];
    619  accumulator_type accumulator = { all, (all = all && managed<Component>() && pool<Component>().has(entity))... };
    620  (void)accumulator;
    621  return all;
    622  }
    623 
    636  template<typename Tag>
    637  const Tag & get() const ENTT_NOEXCEPT {
    638  assert(has<Tag>());
    639  return static_cast<Attaching<Tag> *>(std::get<0>(tags[tag_family::type<Tag>()]).get())->tag;
    640  }
    641 
    654  template<typename Tag>
    655  inline Tag & get() ENTT_NOEXCEPT {
    656  return const_cast<Tag &>(const_cast<const Registry *>(this)->get<Tag>());
    657  }
    658 
    673  template<typename Component>
    674  const Component & get(const entity_type entity) const ENTT_NOEXCEPT {
    675  assert(valid(entity));
    676  assert(managed<Component>());
    677  return pool<Component>().get(entity);
    678  }
    679 
    694  template<typename Component>
    695  inline Component & get(const entity_type entity) ENTT_NOEXCEPT {
    696  return const_cast<Component &>(const_cast<const Registry *>(this)->get<Component>(entity));
    697  }
    698 
    713  template<typename... Component>
    714  inline std::enable_if_t<(sizeof...(Component) > 1), std::tuple<const Component &...>>
    715  get(const entity_type entity) const ENTT_NOEXCEPT {
    716  return std::tuple<const Component &...>{get<Component>(entity)...};
    717  }
    718 
    733  template<typename... Component>
    734  inline std::enable_if_t<(sizeof...(Component) > 1), std::tuple<Component &...>>
    735  get(const entity_type entity) ENTT_NOEXCEPT {
    736  return std::tuple<Component &...>{get<Component>(entity)...};
    737  }
    738 
    757  template<typename Tag, typename... Args>
    758  Tag & replace(tag_t, Args &&... args) {
    759  return (get<Tag>() = Tag{std::forward<Args>(args)...});
    760  }
    761 
    782  template<typename Component, typename... Args>
    783  Component & replace(const entity_type entity, Args &&... args) {
    784  return (get<Component>(entity) = Component{std::forward<Args>(args)...});
    785  }
    786 
    803  template<typename Tag>
    804  entity_type move(const entity_type entity) {
    805  assert(valid(entity));
    806  assert(has<Tag>());
    807  auto &tag = std::get<0>(tags[tag_family::type<Tag>()]);
    808  const auto owner = tag->entity;
    809  tag->entity = entity;
    810  return owner;
    811  }
    812 
    825  template<typename Tag>
    826  entity_type attachee() const ENTT_NOEXCEPT {
    827  assert(has<Tag>());
    828  return std::get<0>(tags[tag_family::type<Tag>()])->entity;
    829  }
    830 
    857  template<typename Component, typename... Args>
    858  Component & accommodate(const entity_type entity, Args &&... args) {
    859  assure<Component>();
    860  auto &cpool = pool<Component>();
    861 
    862  return (cpool.has(entity)
    863  ? cpool.get(entity) = Component{std::forward<Args>(args)...}
    864  : cpool.construct(entity, std::forward<Args>(args)...));
    865  }
    866 
    890  template<typename Tag>
    891  sink_type construction(tag_t) ENTT_NOEXCEPT {
    892  assure<Tag>(tag_t{});
    893  return std::get<1>(tags[tag_family::type<Tag>()]).sink();
    894  }
    895 
    919  template<typename Component>
    920  sink_type construction() ENTT_NOEXCEPT {
    921  assure<Component>();
    922  return std::get<1>(pools[component_family::type<Component>()]).sink();
    923  }
    924 
    948  template<typename Tag>
    949  sink_type destruction(tag_t) ENTT_NOEXCEPT {
    950  assure<Tag>(tag_t{});
    951  return std::get<2>(tags[tag_family::type<Tag>()]).sink();
    952  }
    953 
    977  template<typename Component>
    978  sink_type destruction() ENTT_NOEXCEPT {
    979  assure<Component>();
    980  return std::get<2>(pools[component_family::type<Component>()]).sink();
    981  }
    982 
    1022  template<typename Component, typename Compare, typename Sort = StdSort>
    1023  void sort(Compare compare, Sort sort = Sort{}) {
    1024  assure<Component>();
    1025  pool<Component>().sort(std::move(compare), std::move(sort));
    1026  }
    1027 
    1058  template<typename To, typename From>
    1059  void sort() {
    1060  assure<To>();
    1061  assure<From>();
    1062  pool<To>().respect(pool<From>());
    1063  }
    1064 
    1079  template<typename Component>
    1080  void reset(const entity_type entity) {
    1081  assert(valid(entity));
    1082  assure<Component>();
    1083  const auto ctype = component_family::type<Component>();
    1084  auto &cpool = *std::get<0>(pools[ctype]);
    1085 
    1086  if(cpool.has(entity)) {
    1087  std::get<2>(pools[ctype]).publish(*this, entity);
    1088  cpool.destroy(entity);
    1089  }
    1090  }
    1091 
    1100  template<typename Component>
    1101  void reset() {
    1102  assure<Component>();
    1103  const auto ctype = component_family::type<Component>();
    1104  auto &cpool = *std::get<0>(pools[ctype]);
    1105  auto &sig = std::get<2>(pools[ctype]);
    1106 
    1107  for(const auto entity: cpool) {
    1108  sig.publish(*this, entity);
    1109  cpool.destroy(entity);
    1110  }
    1111  }
    1112 
    1121  void reset() {
    1122  each([this](const auto entity) {
    1123  destroy(entity);
    1124  });
    1125  }
    1126 
    1147  template<typename Func>
    1148  void each(Func func) const {
    1149  if(available) {
    1150  for(auto pos = entities.size(); pos; --pos) {
    1151  const entity_type curr = pos - 1;
    1152  const auto entity = entities[curr];
    1153  const auto entt = entity & traits_type::entity_mask;
    1154 
    1155  if(curr == entt) {
    1156  func(entity);
    1157  }
    1158  }
    1159  } else {
    1160  for(auto pos = entities.size(); pos; --pos) {
    1161  func(entities[pos-1]);
    1162  }
    1163  }
    1164  }
    1165 
    1175  bool orphan(const entity_type entity) const {
    1176  assert(valid(entity));
    1177  bool orphan = true;
    1178 
    1179  for(std::size_t i = 0; i < pools.size() && orphan; ++i) {
    1180  const auto &pool = std::get<0>(pools[i]);
    1181  orphan = !(pool && pool->has(entity));
    1182  }
    1183 
    1184  for(std::size_t i = 0; i < tags.size() && orphan; ++i) {
    1185  const auto &tag = std::get<0>(tags[i]);
    1186  orphan = !(tag && (tag->entity == entity));
    1187  }
    1188 
    1189  return orphan;
    1190  }
    1191 
    1208  template<typename Func>
    1209  void orphans(Func func) const {
    1210  each([func = std::move(func), this](const auto entity) {
    1211  if(orphan(entity)) {
    1212  func(entity);
    1213  }
    1214  });
    1215  }
    1216 
    1250  template<typename... Component>
    1251  View<Entity, Component...> view() {
    1252  return View<Entity, Component...>{(assure<Component>(), pool<Component>())...};
    1253  }
    1254 
    1271  template<typename... Component>
    1272  void prepare() {
    1273  static_assert(sizeof...(Component) > 1, "!");
    1274  const auto htype = handler_family::type<Component...>();
    1275 
    1276  if(!(htype < handlers.size())) {
    1277  handlers.resize(htype + 1);
    1278  }
    1279 
    1280  if(!handlers[htype]) {
    1281  handlers[htype] = std::make_unique<SparseSet<entity_type>>();
    1282  auto &handler = handlers[htype];
    1283 
    1284  for(auto entity: view<Component...>()) {
    1285  handler->construct(entity);
    1286  }
    1287 
    1288  auto connect = [this](const auto ctype) {
    1289  auto &cpool = pools[ctype];
    1290  std::get<1>(cpool).sink().template connect<&Registry::creating<Component...>>();
    1291  std::get<2>(cpool).sink().template connect<&Registry::destroying<Component...>>();
    1292  };
    1293 
    1294  using accumulator_type = int[];
    1295  accumulator_type accumulator = { (assure<Component>(), connect(component_family::type<Component>()), 0)... };
    1296  (void)accumulator;
    1297  }
    1298  }
    1299 
    1315  template<typename... Component>
    1316  void discard() {
    1317  if(contains<Component...>()) {
    1318  const auto htype = handler_family::type<Component...>();
    1319 
    1320  auto disconnect = [this](const auto ctype) {
    1321  auto &cpool = pools[ctype];
    1322  std::get<1>(cpool).sink().template disconnect<&Registry::creating<Component...>>();
    1323  std::get<2>(cpool).sink().template disconnect<&Registry::destroying<Component...>>();
    1324  };
    1325 
    1326  // if a set exists, pools have already been created for it
    1327  using accumulator_type = int[];
    1328  accumulator_type accumulator = { (disconnect(component_family::type<Component>()), 0)... };
    1329  handlers[htype].reset();
    1330  (void)accumulator;
    1331  }
    1332  }
    1333 
    1339  template<typename... Component>
    1340  bool contains() const ENTT_NOEXCEPT {
    1341  static_assert(sizeof...(Component) > 1, "!");
    1342  const auto htype = handler_family::type<Component...>();
    1343  return (htype < handlers.size() && handlers[htype]);
    1344  }
    1345 
    1384  template<typename... Component>
    1385  PersistentView<Entity, Component...> view(persistent_t) {
    1386  prepare<Component...>();
    1387  const auto htype = handler_family::type<Component...>();
    1388  return PersistentView<Entity, Component...>{*handlers[htype], (assure<Component>(), pool<Component>())...};
    1389  }
    1390 
    1413  template<typename Component>
    1414  RawView<Entity, Component> view(raw_t) {
    1415  assure<Component>();
    1416  return RawView<Entity, Component>{pool<Component>()};
    1417  }
    1418 
    1429  Snapshot<Entity> snapshot() const {
    1430  using follow_fn_type = entity_type(*)(const Registry &, const entity_type);
    1431  const entity_type seed = available ? (next | (entities[next] & ~traits_type::entity_mask)) : next;
    1432 
    1433  follow_fn_type follow = [](const Registry &registry, const entity_type entity) -> entity_type {
    1434  const auto &entities = registry.entities;
    1435  const auto entt = entity & traits_type::entity_mask;
    1436  const auto next = entities[entt] & traits_type::entity_mask;
    1437  return (next | (entities[next] & ~traits_type::entity_mask));
    1438  };
    1439 
    1440  return { *this, seed, follow };
    1441  }
    1442 
    1458  SnapshotLoader<Entity> restore() {
    1459  using assure_fn_type = void(*)(Registry &, const entity_type, const bool);
    1460 
    1461  assure_fn_type assure = [](Registry &registry, const entity_type entity, const bool destroyed) {
    1462  using promotion_type = std::conditional_t<sizeof(size_type) >= sizeof(entity_type), size_type, entity_type>;
    1463  // explicit promotion to avoid warnings with std::uint16_t
    1464  const auto entt = promotion_type{entity} & traits_type::entity_mask;
    1465  auto &entities = registry.entities;
    1466 
    1467  if(!(entt < entities.size())) {
    1468  auto curr = entities.size();
    1469  entities.resize(entt + 1);
    1470  std::iota(entities.data() + curr, entities.data() + entt, entity_type(curr));
    1471  }
    1472 
    1473  entities[entt] = entity;
    1474 
    1475  if(destroyed) {
    1476  registry.destroy(entity);
    1477  const auto version = (entity & (~traits_type::entity_mask));
    1478  entities[entt] = ((entities[entt] & traits_type::entity_mask) | version);
    1479  }
    1480  };
    1481 
    1482  return { (*this = {}), assure };
    1483  }
    1484 
    1485 private:
    1486  std::vector<std::unique_ptr<SparseSet<Entity>>> handlers;
    1487  std::vector<std::tuple<std::unique_ptr<SparseSet<Entity>>, signal_type, signal_type>> pools;
    1488  std::vector<std::tuple<std::unique_ptr<Attachee>, signal_type, signal_type>> tags;
    1489  std::vector<entity_type> entities;
    1490  size_type available{};
    1491  entity_type next{};
    1492 };
    1493 
    1494 
    1501 using DefaultRegistry = Registry<std::uint32_t>;
    1502 
    1503 
    1504 }
    1505 
    1506 
    1507 #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:1148
    -
    entt::Registry::discard
    void discard()
    Discards all the data structures used for a given persitent view.
    Definition: registry.hpp:1316
    -
    entt::Registry::sink_type
    typename signal_type::sink_type sink_type
    Type of sink for the given component.
    Definition: registry.hpp:130
    -
    entt::Registry::orphans
    void orphans(Func func) const
    Iterates orphans and applies them the given function object.
    Definition: registry.hpp:1209
    -
    entt::Registry::size
    size_type size() const ENTT_NOEXCEPT
    Returns the number of entities still in use.
    Definition: registry.hpp:193
    -
    entt::Registry::has
    bool has() const ENTT_NOEXCEPT
    Checks if the given tag has an owner.
    Definition: registry.hpp:571
    -
    entt::Registry::reset
    void reset()
    Resets the pool of the given component.
    Definition: registry.hpp:1101
    -
    entt::Registry::accommodate
    Component & accommodate(const entity_type entity, Args &&... args)
    Assigns or replaces the given component for an entity.
    Definition: registry.hpp:858
    -
    entt::Registry::destroy
    void destroy(const entity_type entity)
    Destroys an entity and lets the registry recycle the identifier.
    Definition: registry.hpp:433
    -
    entt::Registry
    Fast and reliable entity-component system.
    Definition: registry.hpp:39
    +
    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
    +
    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:978
    -
    entt::Registry::type
    static component_type type() ENTT_NOEXCEPT
    Returns the numeric identifier of a type of component at runtime.
    Definition: registry.hpp:175
    -
    entt::Registry::size
    size_type size() const ENTT_NOEXCEPT
    Returns the number of existing components of the given type.
    Definition: registry.hpp:185
    +
    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::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:521
    -
    entt::Registry::create
    entity_type create() ENTT_NOEXCEPT
    Creates a new entity and returns it.
    Definition: registry.hpp:390
    -
    entt::Registry::prepare
    void prepare()
    Prepares the internal data structures used by persistent views.
    Definition: registry.hpp:1272
    -
    entt::RawView
    Raw view.
    Definition: view.hpp:1276
    +
    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
    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::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:247
    -
    entt::Registry::has
    bool has(const entity_type entity) const ENTT_NOEXCEPT
    Checks if an entity has all the given components.
    Definition: registry.hpp:615
    -
    entt::Registry::destruction
    sink_type destruction(tag_t) ENTT_NOEXCEPT
    Returns a sink object for the given tag.
    Definition: registry.hpp:949
    -
    entt::Registry::replace
    Tag & replace(tag_t, Args &&... args)
    Replaces the given tag.
    Definition: registry.hpp:758
    +
    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::Registry
    Registry()=default
    Default constructor.
    -
    entt::SparseSet
    Sparse set.
    Definition: sparse_set.hpp:28
    -
    entt::Registry::construction
    sink_type construction() ENTT_NOEXCEPT
    Returns a sink object for the given component.
    Definition: registry.hpp:920
    -
    entt::Registry::contains
    bool contains() const ENTT_NOEXCEPT
    Checks if a persistent view has already been prepared.
    Definition: registry.hpp:1340
    -
    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:158
    -
    entt::Registry::snapshot
    Snapshot< Entity > snapshot() const
    Returns a temporary object to use to create snapshots.
    Definition: registry.hpp:1429
    -
    entt::Registry::raw
    const Component * raw() const ENTT_NOEXCEPT
    Direct access to the list of components of a given pool.
    Definition: registry.hpp:266
    -
    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:346
    -
    entt::Registry::version_type
    typename traits_type::version_type version_type
    Underlying version type.
    Definition: registry.hpp:122
    -
    entt::Registry::reset
    void reset()
    Resets a whole registry.
    Definition: registry.hpp:1121
    +
    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::Family::type
    static family_type type() ENTT_NOEXCEPT
    Returns an unique identifier for the given type.
    Definition: family.hpp:40
    -
    entt::Registry::empty
    bool empty() const ENTT_NOEXCEPT
    Checks whether the pool for the given component is empty.
    Definition: registry.hpp:239
    -
    entt::Registry::view
    View< Entity, Component... > view()
    Returns a standard view for the given components.
    Definition: registry.hpp:1251
    -
    entt::Registry::current
    version_type current(const entity_type entity) const ENTT_NOEXCEPT
    Returns the actual version for an entity identifier.
    Definition: registry.hpp:367
    -
    entt::Registry::reserve
    void reserve(const size_type cap)
    Increases the capacity of the pool for a given component.
    Definition: registry.hpp:207
    -
    entt::Registry::sort
    void sort(Compare compare, Sort sort=Sort{})
    Sorts the pool of entities for the given component.
    Definition: registry.hpp:1023
    -
    entt::Registry::move
    entity_type move(const entity_type entity)
    Changes the owner of the given tag.
    Definition: registry.hpp:804
    -
    entt::Registry::view
    PersistentView< Entity, Component... > view(persistent_t)
    Returns a persistent view for the given components.
    Definition: registry.hpp:1385
    -
    entt::Registry::raw
    Component * raw() ENTT_NOEXCEPT
    Direct access to the list of components of a given pool.
    Definition: registry.hpp:285
    -
    entt::Registry::construction
    sink_type construction(tag_t) ENTT_NOEXCEPT
    Returns a sink object for the given tag.
    Definition: registry.hpp:891
    -
    entt::Registry::view
    RawView< Entity, Component > view(raw_t)
    Returns a raw view for the given component.
    Definition: registry.hpp:1414
    +
    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::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:124
    -
    entt::Registry::sort
    void sort()
    Sorts two pools of components in the same way.
    Definition: registry.hpp:1059
    -
    entt::Registry::data
    const entity_type * data() const ENTT_NOEXCEPT
    Direct access to the list of entities of a given pool.
    Definition: registry.hpp:304
    -
    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:313
    -
    entt::Registry::component_type
    typename component_family::family_type component_type
    Unsigned integer type.
    Definition: registry.hpp:128
    -
    entt::Registry::assign
    Tag & assign(tag_t, const entity_type entity, Args &&... args)
    Attaches the given tag to an entity.
    Definition: registry.hpp:490
    -
    entt::Registry::entity_type
    typename traits_type::entity_type entity_type
    Underlying entity identifier.
    Definition: registry.hpp:120
    -
    entt::View
    Multi component view.
    Definition: view.hpp:453
    -
    entt::Registry::restore
    SnapshotLoader< Entity > restore()
    Returns a temporary object to use to load snapshots.
    Definition: registry.hpp:1458
    -
    entt::PersistentView
    Persistent view.
    Definition: view.hpp:68
    +
    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::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::capacity
    size_type capacity() const ENTT_NOEXCEPT
    Returns the number of entities ever created.
    Definition: registry.hpp:228
    -
    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:335
    +
    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::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:1080
    +
    entt::Registry::reset
    void reset(const entity_type entity)
    Resets the given component for an entity.
    Definition: registry.hpp:1135
    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:783
    -
    entt::Registry::tag_type
    typename tag_family::family_type tag_type
    Unsigned integer type.
    Definition: registry.hpp:126
    -
    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:598
    -
    entt::Registry::attachee
    entity_type attachee() const ENTT_NOEXCEPT
    Gets the owner of the given tag, if any.
    Definition: registry.hpp:826
    -
    entt::Registry::orphan
    bool orphan(const entity_type entity) const
    Checks if an entity is an orphan.
    Definition: registry.hpp:1175
    +
    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::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:220
    +
    entt::Registry::reserve
    void reserve(const size_type cap)
    Increases the capacity of a registry in terms of entities.
    Definition: registry.hpp:221
    diff --git a/scheduler_8hpp_source.html b/scheduler_8hpp_source.html index 568206eb8..105f80822 100644 --- a/scheduler_8hpp_source.html +++ b/scheduler_8hpp_source.html @@ -67,19 +67,19 @@ $(function() {
    scheduler.hpp
    -
    1 #ifndef ENTT_PROCESS_SCHEDULER_HPP
    2 #define ENTT_PROCESS_SCHEDULER_HPP
    3 
    4 
    5 #include <vector>
    6 #include <memory>
    7 #include <utility>
    8 #include <iterator>
    9 #include <algorithm>
    10 #include <type_traits>
    11 #include "../config/config.h"
    12 #include "process.hpp"
    13 
    14 
    15 namespace entt {
    16 
    17 
    44 template<typename Delta>
    45 class Scheduler final {
    46  template<typename T>
    47  struct type_t { using type = T; };
    48 
    49  struct ProcessHandler final {
    50  using instance_type = std::unique_ptr<void, void(*)(void *)>;
    51  using update_type = bool(*)(ProcessHandler &, Delta, void *);
    52  using abort_type = void(*)(ProcessHandler &, bool);
    53  using next_type = std::unique_ptr<ProcessHandler>;
    54 
    55  instance_type instance;
    56  update_type update;
    57  abort_type abort;
    58  next_type next;
    59  };
    60 
    61  template<typename Lambda>
    62  struct Then final: Lambda {
    63  Then(Lambda &&lambda, ProcessHandler *handler)
    64  : Lambda{std::forward<Lambda>(lambda)}, handler{handler}
    65  {}
    66 
    67  template<typename Proc, typename... Args>
    68  decltype(auto) then(Args &&... args) && {
    69  static_assert(std::is_base_of<Process<Proc, Delta>, Proc>::value, "!");
    70  handler = Lambda::operator()(handler, type_t<Proc>{}, std::forward<Args>(args)...);
    71  return std::move(*this);
    72  }
    73 
    74  template<typename Func>
    75  decltype(auto) then(Func &&func) && {
    76  using Proc = ProcessAdaptor<std::decay_t<Func>, Delta>;
    77  return std::move(*this).template then<Proc>(std::forward<Func>(func));
    78  }
    79 
    80  private:
    81  ProcessHandler *handler;
    82  };
    83 
    84  template<typename Proc>
    85  static bool update(ProcessHandler &handler, const Delta delta, void *data) {
    86  auto *process = static_cast<Proc *>(handler.instance.get());
    87  process->tick(delta, data);
    88 
    89  auto dead = process->dead();
    90 
    91  if(dead) {
    92  if(handler.next && !process->rejected()) {
    93  handler = std::move(*handler.next);
    94  dead = handler.update(handler, delta, data);
    95  } else {
    96  handler.instance.reset();
    97  }
    98  }
    99 
    100  return dead;
    101  }
    102 
    103  template<typename Proc>
    104  static void abort(ProcessHandler &handler, const bool immediately) {
    105  static_cast<Proc *>(handler.instance.get())->abort(immediately);
    106  }
    107 
    108  template<typename Proc>
    109  static void deleter(void *proc) {
    110  delete static_cast<Proc *>(proc);
    111  }
    112 
    113  auto then(ProcessHandler *handler) {
    114  auto lambda = [](ProcessHandler *handler, auto next, auto... args) {
    115  using Proc = typename decltype(next)::type;
    116 
    117  if(handler) {
    118  auto proc = typename ProcessHandler::instance_type{new Proc{std::forward<decltype(args)>(args)...}, &Scheduler::deleter<Proc>};
    119  handler->next.reset(new ProcessHandler{std::move(proc), &Scheduler::update<Proc>, &Scheduler::abort<Proc>, nullptr});
    120  handler = handler->next.get();
    121  }
    122 
    123  return handler;
    124  };
    125 
    126  return Then<decltype(lambda)>{std::move(lambda), handler};
    127  }
    128 
    129 public:
    131  using size_type = typename std::vector<ProcessHandler>::size_type;
    132 
    134  Scheduler() ENTT_NOEXCEPT = default;
    135 
    137  Scheduler(const Scheduler &) = delete;
    139  Scheduler(Scheduler &&) = default;
    140 
    142  Scheduler & operator=(const Scheduler &) = delete;
    144  Scheduler & operator=(Scheduler &&) = default;
    145 
    150  size_type size() const ENTT_NOEXCEPT {
    151  return handlers.size();
    152  }
    153 
    158  bool empty() const ENTT_NOEXCEPT {
    159  return handlers.empty();
    160  }
    161 
    168  void clear() {
    169  handlers.clear();
    170  }
    171 
    197  template<typename Proc, typename... Args>
    198  auto attach(Args &&... args) {
    199  static_assert(std::is_base_of<Process<Proc, Delta>, Proc>::value, "!");
    200 
    201  auto proc = typename ProcessHandler::instance_type{new Proc{std::forward<Args>(args)...}, &Scheduler::deleter<Proc>};
    202  ProcessHandler handler{std::move(proc), &Scheduler::update<Proc>, &Scheduler::abort<Proc>, nullptr};
    203  handlers.push_back(std::move(handler));
    204 
    205  return then(&handlers.back());
    206  }
    207 
    258  template<typename Func>
    259  auto attach(Func &&func) {
    260  using Proc = ProcessAdaptor<std::decay_t<Func>, Delta>;
    261  return attach<Proc>(std::forward<Func>(func));
    262  }
    263 
    275  void update(const Delta delta, void *data = nullptr) {
    276  bool clean = false;
    277 
    278  for(auto pos = handlers.size(); pos; --pos) {
    279  auto &handler = handlers[pos-1];
    280  const bool dead = handler.update(handler, delta, data);
    281  clean = clean || dead;
    282  }
    283 
    284  if(clean) {
    285  handlers.erase(std::remove_if(handlers.begin(), handlers.end(), [](auto &handler) {
    286  return !handler.instance;
    287  }), handlers.end());
    288  }
    289  }
    290 
    301  void abort(const bool immediately = false) {
    302  decltype(handlers) exec;
    303  exec.swap(handlers);
    304 
    305  std::for_each(exec.begin(), exec.end(), [immediately](auto &handler) {
    306  handler.abort(handler, immediately);
    307  });
    308 
    309  std::move(handlers.begin(), handlers.end(), std::back_inserter(exec));
    310  handlers.swap(exec);
    311  }
    312 
    313 private:
    314  std::vector<ProcessHandler> handlers{};
    315 };
    316 
    317 
    318 }
    319 
    320 
    321 #endif // ENTT_PROCESS_SCHEDULER_HPP
    entt::Scheduler::size
    size_type size() const ENTT_NOEXCEPT
    Number of processes currently scheduled.
    Definition: scheduler.hpp:150
    +
    1 #ifndef ENTT_PROCESS_SCHEDULER_HPP
    2 #define ENTT_PROCESS_SCHEDULER_HPP
    3 
    4 
    5 #include <vector>
    6 #include <memory>
    7 #include <utility>
    8 #include <algorithm>
    9 #include <type_traits>
    10 #include "../config/config.h"
    11 #include "process.hpp"
    12 
    13 
    14 namespace entt {
    15 
    16 
    43 template<typename Delta>
    44 class Scheduler final {
    45  struct ProcessHandler final {
    46  using instance_type = std::unique_ptr<void, void(*)(void *)>;
    47  using update_fn_type = bool(ProcessHandler &, Delta, void *);
    48  using abort_fn_type = void(ProcessHandler &, bool);
    49  using next_type = std::unique_ptr<ProcessHandler>;
    50 
    51  instance_type instance;
    52  update_fn_type *update;
    53  abort_fn_type *abort;
    54  next_type next;
    55  };
    56 
    57  struct Then final {
    58  Then(ProcessHandler *handler)
    59  : handler{handler}
    60  {}
    61 
    62  template<typename Proc, typename... Args>
    63  decltype(auto) then(Args &&... args) && {
    64  static_assert(std::is_base_of<Process<Proc, Delta>, Proc>::value, "!");
    65  handler = Scheduler::then<Proc>(handler, std::forward<Args>(args)...);
    66  return std::move(*this);
    67  }
    68 
    69  template<typename Func>
    70  decltype(auto) then(Func &&func) && {
    71  using Proc = ProcessAdaptor<std::decay_t<Func>, Delta>;
    72  return std::move(*this).template then<Proc>(std::forward<Func>(func));
    73  }
    74 
    75  private:
    76  ProcessHandler *handler;
    77  };
    78 
    79  template<typename Proc>
    80  static bool update(ProcessHandler &handler, const Delta delta, void *data) {
    81  auto *process = static_cast<Proc *>(handler.instance.get());
    82  process->tick(delta, data);
    83 
    84  auto dead = process->dead();
    85 
    86  if(dead) {
    87  if(handler.next && !process->rejected()) {
    88  handler = std::move(*handler.next);
    89  dead = handler.update(handler, delta, data);
    90  } else {
    91  handler.instance.reset();
    92  }
    93  }
    94 
    95  return dead;
    96  }
    97 
    98  template<typename Proc>
    99  static void abort(ProcessHandler &handler, const bool immediately) {
    100  static_cast<Proc *>(handler.instance.get())->abort(immediately);
    101  }
    102 
    103  template<typename Proc>
    104  static void deleter(void *proc) {
    105  delete static_cast<Proc *>(proc);
    106  }
    107 
    108  template<typename Proc, typename... Args>
    109  static auto then(ProcessHandler *handler, Args &&... args) {
    110  if(handler) {
    111  auto proc = typename ProcessHandler::instance_type{new Proc{std::forward<Args>(args)...}, &Scheduler::deleter<Proc>};
    112  handler->next.reset(new ProcessHandler{std::move(proc), &Scheduler::update<Proc>, &Scheduler::abort<Proc>, nullptr});
    113  handler = handler->next.get();
    114  }
    115 
    116  return handler;
    117  }
    118 
    119 public:
    121  using size_type = typename std::vector<ProcessHandler>::size_type;
    122 
    124  Scheduler() ENTT_NOEXCEPT = default;
    125 
    127  Scheduler(const Scheduler &) = delete;
    129  Scheduler(Scheduler &&) = default;
    130 
    132  Scheduler & operator=(const Scheduler &) = delete;
    134  Scheduler & operator=(Scheduler &&) = default;
    135 
    140  size_type size() const ENTT_NOEXCEPT {
    141  return handlers.size();
    142  }
    143 
    148  bool empty() const ENTT_NOEXCEPT {
    149  return handlers.empty();
    150  }
    151 
    158  void clear() {
    159  handlers.clear();
    160  }
    161 
    187  template<typename Proc, typename... Args>
    188  auto attach(Args &&... args) {
    189  static_assert(std::is_base_of<Process<Proc, Delta>, Proc>::value, "!");
    190 
    191  auto proc = typename ProcessHandler::instance_type{new Proc{std::forward<Args>(args)...}, &Scheduler::deleter<Proc>};
    192  ProcessHandler handler{std::move(proc), &Scheduler::update<Proc>, &Scheduler::abort<Proc>, nullptr};
    193  handlers.push_back(std::move(handler));
    194 
    195  return Then{&handlers.back()};
    196  }
    197 
    248  template<typename Func>
    249  auto attach(Func &&func) {
    250  using Proc = ProcessAdaptor<std::decay_t<Func>, Delta>;
    251  return attach<Proc>(std::forward<Func>(func));
    252  }
    253 
    265  void update(const Delta delta, void *data = nullptr) {
    266  bool clean = false;
    267 
    268  for(auto pos = handlers.size(); pos; --pos) {
    269  auto &handler = handlers[pos-1];
    270  const bool dead = handler.update(handler, delta, data);
    271  clean = clean || dead;
    272  }
    273 
    274  if(clean) {
    275  handlers.erase(std::remove_if(handlers.begin(), handlers.end(), [](auto &handler) {
    276  return !handler.instance;
    277  }), handlers.end());
    278  }
    279  }
    280 
    291  void abort(const bool immediately = false) {
    292  decltype(handlers) exec;
    293  exec.swap(handlers);
    294 
    295  std::for_each(exec.begin(), exec.end(), [immediately](auto &handler) {
    296  handler.abort(handler, immediately);
    297  });
    298 
    299  std::move(handlers.begin(), handlers.end(), std::back_inserter(exec));
    300  handlers.swap(exec);
    301  }
    302 
    303 private:
    304  std::vector<ProcessHandler> handlers{};
    305 };
    306 
    307 
    308 }
    309 
    310 
    311 #endif // ENTT_PROCESS_SCHEDULER_HPP
    entt::Scheduler::size
    size_type size() const ENTT_NOEXCEPT
    Number of processes currently scheduled.
    Definition: scheduler.hpp:140
    entt::Process
    Base class for processes.
    Definition: process.hpp:73
    -
    entt::Scheduler::clear
    void clear()
    Discards all scheduled processes.
    Definition: scheduler.hpp:168
    -
    entt::Scheduler::empty
    bool empty() const ENTT_NOEXCEPT
    Returns true if at least a process is currently scheduled.
    Definition: scheduler.hpp:158
    -
    entt::Scheduler::update
    void update(const Delta delta, void *data=nullptr)
    Updates all scheduled processes.
    Definition: scheduler.hpp:275
    +
    entt::Scheduler::clear
    void clear()
    Discards all scheduled processes.
    Definition: scheduler.hpp:158
    +
    entt::Scheduler::empty
    bool empty() const ENTT_NOEXCEPT
    Returns true if at least a process is currently scheduled.
    Definition: scheduler.hpp:148
    +
    entt::Scheduler::update
    void update(const Delta delta, void *data=nullptr)
    Updates all scheduled processes.
    Definition: scheduler.hpp:265
    entt
    EnTT default namespace.
    Definition: algorithm.hpp:10
    entt::Scheduler::Scheduler
    Scheduler() ENTT_NOEXCEPT=default
    Default constructor.
    entt::ProcessAdaptor
    Adaptor for lambdas and functors to turn them into processes.
    Definition: process.hpp:314
    -
    entt::Scheduler::size_type
    typename std::vector< ProcessHandler >::size_type size_type
    Unsigned integer type.
    Definition: scheduler.hpp:131
    -
    entt::Scheduler::abort
    void abort(const bool immediately=false)
    Aborts all scheduled processes.
    Definition: scheduler.hpp:301
    -
    entt::Scheduler::attach
    auto attach(Args &&... args)
    Schedules a process for the next tick.
    Definition: scheduler.hpp:198
    -
    entt::Scheduler::attach
    auto attach(Func &&func)
    Schedules a process for the next tick.
    Definition: scheduler.hpp:259
    -
    entt::Scheduler
    Cooperative scheduler for processes.
    Definition: scheduler.hpp:45
    +
    entt::Scheduler::size_type
    typename std::vector< ProcessHandler >::size_type size_type
    Unsigned integer type.
    Definition: scheduler.hpp:121
    +
    entt::Scheduler::abort
    void abort(const bool immediately=false)
    Aborts all scheduled processes.
    Definition: scheduler.hpp:291
    +
    entt::Scheduler::attach
    auto attach(Args &&... args)
    Schedules a process for the next tick.
    Definition: scheduler.hpp:188
    +
    entt::Scheduler::attach
    auto attach(Func &&func)
    Schedules a process for the next tick.
    Definition: scheduler.hpp:249
    +
    entt::Scheduler
    Cooperative scheduler for processes.
    Definition: scheduler.hpp:44
    diff --git a/search/all_1.js b/search/all_1.js index 7015edf7b..fdbc6950c 100644 --- a/search/all_1.js +++ b/search/all_1.js @@ -1,5 +1,5 @@ var searchData= [ - ['begin',['begin',['../classentt_1_1SparseSet_3_01Entity_01_4.html#aebd9c479dc54907cf42a4423f34edeb2',1,'entt::SparseSet< Entity >::begin() const ENTT_NOEXCEPT'],['../classentt_1_1SparseSet_3_01Entity_01_4.html#a6b33b62684d62255ca53a371cfbe1d28',1,'entt::SparseSet< Entity >::begin() ENTT_NOEXCEPT'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#a6f177729ba483b37119881db872b7736',1,'entt::SparseSet< Entity, Type >::begin() const ENTT_NOEXCEPT'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#aef10db6199e31f72c14c4be9347b0822',1,'entt::SparseSet< Entity, Type >::begin() ENTT_NOEXCEPT'],['../classentt_1_1PersistentView.html#af1469f9dd45ebc68729e88e741c465a4',1,'entt::PersistentView::begin() const ENTT_NOEXCEPT'],['../classentt_1_1PersistentView.html#a6bb6ca7b9dbbbf6da3f2cf7250a61075',1,'entt::PersistentView::begin() ENTT_NOEXCEPT'],['../classentt_1_1View.html#a7c59406241bd142289a0d618a33f98d3',1,'entt::View::begin() const ENTT_NOEXCEPT'],['../classentt_1_1View.html#a5d4b1ac137a2dd3ac7f8f91a40b6eb0e',1,'entt::View::begin() ENTT_NOEXCEPT'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a7c59406241bd142289a0d618a33f98d3',1,'entt::View< Entity, Component >::begin() const ENTT_NOEXCEPT'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a5d4b1ac137a2dd3ac7f8f91a40b6eb0e',1,'entt::View< Entity, Component >::begin() ENTT_NOEXCEPT'],['../classentt_1_1RawView.html#a564cc60d60b8d80aefca967eea79031f',1,'entt::RawView::begin() const ENTT_NOEXCEPT'],['../classentt_1_1RawView.html#a195eb860ca3f49f72fc08e4505431286',1,'entt::RawView::begin() ENTT_NOEXCEPT']]], + ['begin',['begin',['../classentt_1_1SparseSet_3_01Entity_01_4.html#aebd9c479dc54907cf42a4423f34edeb2',1,'entt::SparseSet< Entity >::begin() const ENTT_NOEXCEPT'],['../classentt_1_1SparseSet_3_01Entity_01_4.html#a6b33b62684d62255ca53a371cfbe1d28',1,'entt::SparseSet< Entity >::begin() ENTT_NOEXCEPT'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#a6f177729ba483b37119881db872b7736',1,'entt::SparseSet< Entity, Type >::begin() const ENTT_NOEXCEPT'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#aef10db6199e31f72c14c4be9347b0822',1,'entt::SparseSet< Entity, Type >::begin() ENTT_NOEXCEPT'],['../classentt_1_1PersistentView.html#af1469f9dd45ebc68729e88e741c465a4',1,'entt::PersistentView::begin() const ENTT_NOEXCEPT'],['../classentt_1_1PersistentView.html#a6bb6ca7b9dbbbf6da3f2cf7250a61075',1,'entt::PersistentView::begin() ENTT_NOEXCEPT'],['../classentt_1_1View.html#a7c59406241bd142289a0d618a33f98d3',1,'entt::View::begin() const ENTT_NOEXCEPT'],['../classentt_1_1View.html#a5d4b1ac137a2dd3ac7f8f91a40b6eb0e',1,'entt::View::begin() ENTT_NOEXCEPT'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a7c59406241bd142289a0d618a33f98d3',1,'entt::View< Entity, Component >::begin() const ENTT_NOEXCEPT'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a5d4b1ac137a2dd3ac7f8f91a40b6eb0e',1,'entt::View< Entity, Component >::begin() ENTT_NOEXCEPT'],['../classentt_1_1RawView.html#a564cc60d60b8d80aefca967eea79031f',1,'entt::RawView::begin() const ENTT_NOEXCEPT'],['../classentt_1_1RawView.html#a195eb860ca3f49f72fc08e4505431286',1,'entt::RawView::begin() ENTT_NOEXCEPT'],['../classentt_1_1RuntimeView.html#af1fb74dd84e6ffd0f8626b8f0f55af91',1,'entt::RuntimeView::begin() const ENTT_NOEXCEPT'],['../classentt_1_1RuntimeView.html#a8b424a07dd1fdca3a11103dbc6ad76ac',1,'entt::RuntimeView::begin() ENTT_NOEXCEPT']]], ['break_5ft',['break_t',['../structentt_1_1break__t.html',1,'entt']]] ]; diff --git a/search/all_10.js b/search/all_10.js index 585dca5cd..1af19899d 100644 --- a/search/all_10.js +++ b/search/all_10.js @@ -1,6 +1,10 @@ var searchData= [ - ['unpause',['unpause',['../classentt_1_1Process.html#aeb2057ef29594395ef68b965e6b27c7e',1,'entt::Process']]], - ['unset',['unset',['../classentt_1_1Prototype.html#ac75f485a3afa9dada4574269be50166d',1,'entt::Prototype']]], - ['update',['update',['../structentt_1_1ProcessAdaptor.html#a46e837972764bdd457f7512212367eb5',1,'entt::ProcessAdaptor::update()'],['../classentt_1_1Scheduler.html#aff001b4bf5aaa53fe1fda94991e73935',1,'entt::Scheduler::update()'],['../classentt_1_1Dispatcher.html#a2c3ffb218856dd962c7e50a5de14b918',1,'entt::Dispatcher::update()'],['../classentt_1_1Dispatcher.html#a88431e5c4e050d8c2e5ee880b920f5a5',1,'entt::Dispatcher::update() const']]] + ['tag',['tag',['../classentt_1_1Snapshot.html#ac13d5fe79511e27f7b935e84c112e051',1,'entt::Snapshot::tag(Archive &archive) const'],['../classentt_1_1Snapshot.html#a960471c2f13bc1c693a9c58396e63b93',1,'entt::Snapshot::tag(Archive &archive) const'],['../classentt_1_1SnapshotLoader.html#afc4964c76a8fc7a8a1c6a435babc796f',1,'entt::SnapshotLoader::tag()'],['../classentt_1_1ContinuousLoader.html#a8d50d3f90d95b370305561da67da6c3b',1,'entt::ContinuousLoader::tag()']]], + ['tag_5ft',['tag_t',['../structentt_1_1tag__t.html',1,'entt']]], + ['tag_5ftype',['tag_type',['../classentt_1_1Registry.html#a357cfdc1b3c5abc7a36e8eddbd6ce5c7',1,'entt::Registry']]], + ['temp',['temp',['../classentt_1_1ResourceCache.html#a00ad6d9478d2f6721f0a846b49adec07',1,'entt::ResourceCache']]], + ['tick',['tick',['../classentt_1_1Process.html#a9298c55069b27d4ffa005f4345be4d59',1,'entt::Process']]], + ['trigger',['trigger',['../classentt_1_1Dispatcher.html#a89d44e6fa992fba9ba927f4b1492f66f',1,'entt::Dispatcher']]], + ['type',['type',['../classentt_1_1Family.html#aa5ce983dfef17bf0df6a608308193f6d',1,'entt::Family::type()'],['../classentt_1_1Registry.html#a682552d500d7768b5d9d4e5f547cdfaf',1,'entt::Registry::type(tag_t) ENTT_NOEXCEPT'],['../classentt_1_1Registry.html#a484018ca7d1898708ea17a651eddc7e4',1,'entt::Registry::type() ENTT_NOEXCEPT']]] ]; diff --git a/search/all_11.js b/search/all_11.js index 8157cecea..585dca5cd 100644 --- a/search/all_11.js +++ b/search/all_11.js @@ -1,9 +1,6 @@ var searchData= [ - ['valid',['valid',['../classentt_1_1Registry.html#aaba72db4ebf99a911b58327063ec8ad9',1,'entt::Registry']]], - ['version',['version',['../classentt_1_1Registry.html#ad7467ac1c8a7657062b1b4386dded54e',1,'entt::Registry']]], - ['version_5fmask',['version_mask',['../structentt_1_1entt__traits_3_01std_1_1uint16__t_01_4.html#a78f400e87476e73bf4eb324ccb977682',1,'entt::entt_traits< std::uint16_t >::version_mask()'],['../structentt_1_1entt__traits_3_01std_1_1uint32__t_01_4.html#a6aa8692650455fe7b691a69b7621f9a1',1,'entt::entt_traits< std::uint32_t >::version_mask()'],['../structentt_1_1entt__traits_3_01std_1_1uint64__t_01_4.html#ab242af30841712877cd2d4042840551b',1,'entt::entt_traits< std::uint64_t >::version_mask()']]], - ['version_5ftype',['version_type',['../structentt_1_1entt__traits_3_01std_1_1uint16__t_01_4.html#ab37d10c3be3d59159a63c0bd1e9e2924',1,'entt::entt_traits< std::uint16_t >::version_type()'],['../structentt_1_1entt__traits_3_01std_1_1uint32__t_01_4.html#aee59dc7455ea0be015e699c3e46a22d1',1,'entt::entt_traits< std::uint32_t >::version_type()'],['../structentt_1_1entt__traits_3_01std_1_1uint64__t_01_4.html#aeac4d9172940a9dec0682860ac176725',1,'entt::entt_traits< std::uint64_t >::version_type()'],['../classentt_1_1Registry.html#a82c8996277034df5e72b5f30a70ebb2d',1,'entt::Registry::version_type()']]], - ['view',['View',['../classentt_1_1View.html',1,'entt::View< Entity, Component >'],['../classentt_1_1Registry.html#aed83d4c8f80ae647ee73f2a8440fa09d',1,'entt::Registry::view()'],['../classentt_1_1Registry.html#abb1eb5f1a2ec31d14b5b98271ff78f1e',1,'entt::Registry::view(persistent_t)'],['../classentt_1_1Registry.html#aedc2a2344c5d13a0483608d48189a92a',1,'entt::Registry::view(raw_t)']]], - ['view_3c_20entity_2c_20component_20_3e',['View< Entity, Component >',['../classentt_1_1View_3_01Entity_00_01Component_01_4.html',1,'entt']]] + ['unpause',['unpause',['../classentt_1_1Process.html#aeb2057ef29594395ef68b965e6b27c7e',1,'entt::Process']]], + ['unset',['unset',['../classentt_1_1Prototype.html#ac75f485a3afa9dada4574269be50166d',1,'entt::Prototype']]], + ['update',['update',['../structentt_1_1ProcessAdaptor.html#a46e837972764bdd457f7512212367eb5',1,'entt::ProcessAdaptor::update()'],['../classentt_1_1Scheduler.html#aff001b4bf5aaa53fe1fda94991e73935',1,'entt::Scheduler::update()'],['../classentt_1_1Dispatcher.html#a2c3ffb218856dd962c7e50a5de14b918',1,'entt::Dispatcher::update()'],['../classentt_1_1Dispatcher.html#a88431e5c4e050d8c2e5ee880b920f5a5',1,'entt::Dispatcher::update() const']]] ]; diff --git a/search/all_12.js b/search/all_12.js index 4c96dc25c..085e413fa 100644 --- a/search/all_12.js +++ b/search/all_12.js @@ -1,9 +1,9 @@ var searchData= [ - ['_7eactor',['~Actor',['../structentt_1_1Actor.html#a3ab5d325569b88346684a1cffd6bd633',1,'entt::Actor']]], - ['_7eemitter',['~Emitter',['../classentt_1_1Emitter.html#ac713dddc6b8f7b056e3c1a8979a4e271',1,'entt::Emitter']]], - ['_7eprocess',['~Process',['../classentt_1_1Process.html#abcfd11c007770ec8bd997333b00f5f8b',1,'entt::Process']]], - ['_7eprototype',['~Prototype',['../classentt_1_1Prototype.html#acb70104c3d32fcf22fbe37afa7602ed5',1,'entt::Prototype']]], - ['_7eservicelocator',['~ServiceLocator',['../structentt_1_1ServiceLocator.html#af0dc69f829f93c86b6537cf0c133ef75',1,'entt::ServiceLocator']]], - ['_7esparseset',['~SparseSet',['../classentt_1_1SparseSet_3_01Entity_01_4.html#a7a0a9d11f6b89102468b45ed83651bc8',1,'entt::SparseSet< Entity >']]] + ['valid',['valid',['../classentt_1_1Registry.html#aaba72db4ebf99a911b58327063ec8ad9',1,'entt::Registry']]], + ['version',['version',['../classentt_1_1Registry.html#ad7467ac1c8a7657062b1b4386dded54e',1,'entt::Registry']]], + ['version_5fmask',['version_mask',['../structentt_1_1entt__traits_3_01std_1_1uint16__t_01_4.html#a78f400e87476e73bf4eb324ccb977682',1,'entt::entt_traits< std::uint16_t >::version_mask()'],['../structentt_1_1entt__traits_3_01std_1_1uint32__t_01_4.html#a6aa8692650455fe7b691a69b7621f9a1',1,'entt::entt_traits< std::uint32_t >::version_mask()'],['../structentt_1_1entt__traits_3_01std_1_1uint64__t_01_4.html#ab242af30841712877cd2d4042840551b',1,'entt::entt_traits< std::uint64_t >::version_mask()']]], + ['version_5ftype',['version_type',['../structentt_1_1entt__traits_3_01std_1_1uint16__t_01_4.html#ab37d10c3be3d59159a63c0bd1e9e2924',1,'entt::entt_traits< std::uint16_t >::version_type()'],['../structentt_1_1entt__traits_3_01std_1_1uint32__t_01_4.html#aee59dc7455ea0be015e699c3e46a22d1',1,'entt::entt_traits< std::uint32_t >::version_type()'],['../structentt_1_1entt__traits_3_01std_1_1uint64__t_01_4.html#aeac4d9172940a9dec0682860ac176725',1,'entt::entt_traits< std::uint64_t >::version_type()'],['../classentt_1_1Registry.html#a82c8996277034df5e72b5f30a70ebb2d',1,'entt::Registry::version_type()']]], + ['view',['View',['../classentt_1_1View.html',1,'entt::View< Entity, Component >'],['../classentt_1_1Registry.html#aed83d4c8f80ae647ee73f2a8440fa09d',1,'entt::Registry::view()'],['../classentt_1_1Registry.html#abb1eb5f1a2ec31d14b5b98271ff78f1e',1,'entt::Registry::view(persistent_t)'],['../classentt_1_1Registry.html#aedc2a2344c5d13a0483608d48189a92a',1,'entt::Registry::view(raw_t)'],['../classentt_1_1Registry.html#a4a157973e57670b5df3eedc8d137de7e',1,'entt::Registry::view(It first, It last)']]], + ['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/typedefs_c.html b/search/all_13.html similarity index 94% rename from search/typedefs_c.html rename to search/all_13.html index 28f5aad20..b4a8bca69 100644 --- a/search/typedefs_c.html +++ b/search/all_13.html @@ -3,7 +3,7 @@ - + diff --git a/search/all_13.js b/search/all_13.js new file mode 100644 index 000000000..4c96dc25c --- /dev/null +++ b/search/all_13.js @@ -0,0 +1,9 @@ +var searchData= +[ + ['_7eactor',['~Actor',['../structentt_1_1Actor.html#a3ab5d325569b88346684a1cffd6bd633',1,'entt::Actor']]], + ['_7eemitter',['~Emitter',['../classentt_1_1Emitter.html#ac713dddc6b8f7b056e3c1a8979a4e271',1,'entt::Emitter']]], + ['_7eprocess',['~Process',['../classentt_1_1Process.html#abcfd11c007770ec8bd997333b00f5f8b',1,'entt::Process']]], + ['_7eprototype',['~Prototype',['../classentt_1_1Prototype.html#acb70104c3d32fcf22fbe37afa7602ed5',1,'entt::Prototype']]], + ['_7eservicelocator',['~ServiceLocator',['../structentt_1_1ServiceLocator.html#af0dc69f829f93c86b6537cf0c133ef75',1,'entt::ServiceLocator']]], + ['_7esparseset',['~SparseSet',['../classentt_1_1SparseSet_3_01Entity_01_4.html#a7a0a9d11f6b89102468b45ed83651bc8',1,'entt::SparseSet< Entity >']]] +]; diff --git a/search/all_2.js b/search/all_2.js index 1997a48e9..68cbe0079 100644 --- a/search/all_2.js +++ b/search/all_2.js @@ -1,8 +1,8 @@ var searchData= [ - ['capacity',['capacity',['../classentt_1_1Registry.html#aefe4ec26db45257de26da19147a9e3f3',1,'entt::Registry']]], - ['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()']]], - ['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()']]], + ['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()']]], ['clear',['clear',['../classentt_1_1Scheduler.html#a2fd48cfd2ce32308f5e7bb8bafd5cda2',1,'entt::Scheduler::clear()'],['../classentt_1_1ResourceCache.html#a9ab70500ad42f8bd565ce1c379f472b4',1,'entt::ResourceCache::clear()'],['../classentt_1_1Emitter.html#a4e722d57776f3185e39386e6f252c56b',1,'entt::Emitter::clear() ENTT_NOEXCEPT'],['../classentt_1_1Emitter.html#a12ce32d79978c671a4d72532cd8e33f7',1,'entt::Emitter::clear() ENTT_NOEXCEPT']]], ['collect',['collect',['../classentt_1_1SigH_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4.html#af50a728e8b61c75af4286132e1312c77',1,'entt::SigH< Ret(Args...), Collector >']]], ['collector_5ftype',['collector_type',['../classentt_1_1SigH_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4.html#ad0e4e34e41daec83437b1c607855079a',1,'entt::SigH< Ret(Args...), Collector >']]], @@ -10,11 +10,11 @@ var searchData= ['component_5ftype',['component_type',['../classentt_1_1Registry.html#aefd07a0cdff88ebf1e35e531d58c3077',1,'entt::Registry']]], ['connect',['connect',['../classentt_1_1Delegate_3_01Ret_07Args_8_8_8_08_4.html#a51d3c462c56349e09a1c7fe0d58859b7',1,'entt::Delegate< Ret(Args...)>::connect() ENTT_NOEXCEPT'],['../classentt_1_1Delegate_3_01Ret_07Args_8_8_8_08_4.html#a453219af4b49ccaf258e564006ed1f07',1,'entt::Delegate< Ret(Args...)>::connect(Class *instance) ENTT_NOEXCEPT'],['../classentt_1_1Sink_3_01Ret_07Args_8_8_8_08_4.html#a1b37a003e4d4edc19f95b1924ef18323',1,'entt::Sink< Ret(Args...)>::connect()'],['../classentt_1_1Sink_3_01Ret_07Args_8_8_8_08_4.html#a53d91eccac3db8a7b64534f2b52d31bb',1,'entt::Sink< Ret(Args...)>::connect(Class *instance)']]], ['connection',['Connection',['../structentt_1_1Emitter_1_1Connection.html',1,'entt::Emitter< Derived >::Connection< Event >'],['../structentt_1_1Emitter_1_1Connection.html#a1091537202d401609a73f0ee3fcc9ea6',1,'entt::Emitter::Connection::Connection() ENTT_NOEXCEPT=default'],['../structentt_1_1Emitter_1_1Connection.html#af059ef0d0aa727ea11e6873144fcbc1b',1,'entt::Emitter::Connection::Connection(typename Handler< Event >::connection_type conn)'],['../structentt_1_1Emitter_1_1Connection.html#a1ccd273683a9fb65a7a4d0c9bf7d0543',1,'entt::Emitter::Connection::Connection(const Connection &)=default'],['../structentt_1_1Emitter_1_1Connection.html#a0c5020d2127d9d0e45abd7e9c08c65c3',1,'entt::Emitter::Connection::Connection(Connection &&)=default']]], - ['const_5fiterator_5ftype',['const_iterator_type',['../classentt_1_1SparseSet_3_01Entity_01_4.html#aba42055f0c8a43cae63d443a17f6a5e2',1,'entt::SparseSet< Entity >::const_iterator_type()'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#a947d3fd0440167f469331a31b1d8d782',1,'entt::SparseSet< Entity, Type >::const_iterator_type()'],['../classentt_1_1PersistentView.html#a260bd2740fb90caf984ce62c26bb887b',1,'entt::PersistentView::const_iterator_type()'],['../classentt_1_1View.html#a81b76e0389ffeb60195a3391c4c5ce3a',1,'entt::View::const_iterator_type()'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a79316bcf7c15b52712689653fff419c3',1,'entt::View< Entity, Component >::const_iterator_type()'],['../classentt_1_1RawView.html#a5fa9cd28fb18ccfe01fd0eb3ea6e3dc7',1,'entt::RawView::const_iterator_type()']]], + ['const_5fiterator_5ftype',['const_iterator_type',['../classentt_1_1SparseSet_3_01Entity_01_4.html#aba42055f0c8a43cae63d443a17f6a5e2',1,'entt::SparseSet< Entity >::const_iterator_type()'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#a947d3fd0440167f469331a31b1d8d782',1,'entt::SparseSet< Entity, Type >::const_iterator_type()'],['../classentt_1_1PersistentView.html#a260bd2740fb90caf984ce62c26bb887b',1,'entt::PersistentView::const_iterator_type()'],['../classentt_1_1View.html#a81b76e0389ffeb60195a3391c4c5ce3a',1,'entt::View::const_iterator_type()'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a79316bcf7c15b52712689653fff419c3',1,'entt::View< Entity, Component >::const_iterator_type()'],['../classentt_1_1RawView.html#a5fa9cd28fb18ccfe01fd0eb3ea6e3dc7',1,'entt::RawView::const_iterator_type()'],['../classentt_1_1RuntimeView.html#acf976983924a5e0194a19a9b98fdc249',1,'entt::RuntimeView::const_iterator_type()']]], ['construct',['construct',['../classentt_1_1SparseSet_3_01Entity_01_4.html#a47dad39fa63ac4be07dcd9234c8a57c7',1,'entt::SparseSet< Entity >::construct()'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#acf06fa56b6b0880d546dd3bc0ddc087f',1,'entt::SparseSet< Entity, Type >::construct(const entity_type entity, Args &&... args)'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#aded5c64ff04ee1a78e7e238208923d58',1,'entt::SparseSet< Entity, Type >::construct(const entity_type entity, Args &&... args)']]], ['construction',['construction',['../classentt_1_1Registry.html#a6f6b29268ba11a8526fa3f9d3bdb58e5',1,'entt::Registry::construction(tag_t) ENTT_NOEXCEPT'],['../classentt_1_1Registry.html#af43b25946f4cbdec633df25317edc020',1,'entt::Registry::construction() ENTT_NOEXCEPT']]], - ['contains',['contains',['../classentt_1_1Registry.html#a67a9d1a75fa1f8e29091f1127c0f3a70',1,'entt::Registry::contains()'],['../classentt_1_1PersistentView.html#af98a61a6ac04e08b6b46e4163ad3d415',1,'entt::PersistentView::contains()'],['../classentt_1_1View.html#abbc407e2fecdbcf97c129ade5db185e8',1,'entt::View::contains()'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#abbc407e2fecdbcf97c129ade5db185e8',1,'entt::View< Entity, Component >::contains()'],['../classentt_1_1ResourceCache.html#aa133ec347db1ee8fab5d757b8b24a185',1,'entt::ResourceCache::contains()']]], + ['contains',['contains',['../classentt_1_1Registry.html#a67a9d1a75fa1f8e29091f1127c0f3a70',1,'entt::Registry::contains()'],['../classentt_1_1PersistentView.html#af98a61a6ac04e08b6b46e4163ad3d415',1,'entt::PersistentView::contains()'],['../classentt_1_1View.html#abbc407e2fecdbcf97c129ade5db185e8',1,'entt::View::contains()'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#abbc407e2fecdbcf97c129ade5db185e8',1,'entt::View< Entity, Component >::contains()'],['../classentt_1_1RuntimeView.html#a903cb93104fba0816f71f8851c6ff162',1,'entt::RuntimeView::contains()'],['../classentt_1_1ResourceCache.html#aa133ec347db1ee8fab5d757b8b24a185',1,'entt::ResourceCache::contains()']]], ['continuousloader',['ContinuousLoader',['../classentt_1_1ContinuousLoader.html',1,'entt::ContinuousLoader< Entity >'],['../classentt_1_1ContinuousLoader.html#a26ccd96f9ee4219ad7e3d1b8138ade37',1,'entt::ContinuousLoader::ContinuousLoader(Registry< entity_type > &registry) ENTT_NOEXCEPT'],['../classentt_1_1ContinuousLoader.html#a4d7cdac6b296eedb3dffd7ad0f182e3a',1,'entt::ContinuousLoader::ContinuousLoader(const ContinuousLoader &)=delete'],['../classentt_1_1ContinuousLoader.html#a4ba9abb1659a78f2ba4e12f86da68402',1,'entt::ContinuousLoader::ContinuousLoader(ContinuousLoader &&)=default']]], - ['create',['create',['../classentt_1_1Prototype.html#a434b43ae5f761093a0c9e74da0802523',1,'entt::Prototype::create(registry_type &other) const'],['../classentt_1_1Prototype.html#a5a659d7582d8fb52c5be59b0a319e2ec',1,'entt::Prototype::create() const'],['../classentt_1_1Registry.html#a10de276e8fc78fe205907c808ddb8d9a',1,'entt::Registry::create()']]], + ['create',['create',['../classentt_1_1Prototype.html#a434b43ae5f761093a0c9e74da0802523',1,'entt::Prototype::create(registry_type &other) const'],['../classentt_1_1Prototype.html#a5a659d7582d8fb52c5be59b0a319e2ec',1,'entt::Prototype::create() const'],['../classentt_1_1Registry.html#a433ac3fc8ea49347f691dd4ad1ccb58b',1,'entt::Registry::create()']]], ['current',['current',['../classentt_1_1Registry.html#a9e79305f5a066bdc2b272181a08b17ac',1,'entt::Registry']]] ]; diff --git a/search/all_3.js b/search/all_3.js index 87cd8613c..093414dd5 100644 --- a/search/all_3.js +++ b/search/all_3.js @@ -3,15 +3,16 @@ var searchData= ['data',['data',['../classentt_1_1Registry.html#a2bb7899d022c90b2385cad18a31e48dd',1,'entt::Registry::data()'],['../classentt_1_1SparseSet_3_01Entity_01_4.html#a3da83139d2ef41982399948a94383c0b',1,'entt::SparseSet< Entity >::data()'],['../classentt_1_1PersistentView.html#ae3e2d20cb89f810542c0ec4fe4537176',1,'entt::PersistentView::data()'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a7b1ac1bc68c41fb4007ad5c47ed754a0',1,'entt::View< Entity, Component >::data()'],['../classentt_1_1RawView.html#a27edc55b8d2d18f75118b3b1e68ff270',1,'entt::RawView::data()']]], ['dead',['dead',['../classentt_1_1Process.html#a08265296592bcc0e5a6632b7067329b9',1,'entt::Process']]], ['defaultactor',['DefaultActor',['../namespaceentt.html#a0790fdd772249d8b22f1cf2d5e2403d4',1,'entt']]], - ['defaultprototype',['DefaultPrototype',['../namespaceentt.html#a0d57efa94559b7bae0129ca483ae8927',1,'entt']]], + ['defaultprototype',['DefaultPrototype',['../namespaceentt.html#a94d8a4552b7bd5a3543c2ffc6eaf878c',1,'entt']]], ['defaultregistry',['DefaultRegistry',['../namespaceentt.html#aa56ef01a9c62f21d68dd60f005296b23',1,'entt']]], ['delegate',['Delegate',['../classentt_1_1Delegate.html',1,'entt::Delegate< typename >'],['../classentt_1_1Delegate_3_01Ret_07Args_8_8_8_08_4.html#a57a011f4b42c3358ee5219f63997e00b',1,'entt::Delegate< Ret(Args...)>::Delegate()']]], ['delegate_3c_20ret_28args_2e_2e_2e_29_3e',['Delegate< Ret(Args...)>',['../classentt_1_1Delegate_3_01Ret_07Args_8_8_8_08_4.html',1,'entt']]], ['delta_5ftype',['delta_type',['../classentt_1_1Process.html#aaa304f69a0344fffd3a53daa922284ad',1,'entt::Process']]], ['dependency',['dependency',['../namespaceentt.html#ab9d53b0eb1c6fb4d7636d4ab451b615d',1,'entt::dependency(Registry< Entity > &registry, const Entity entity)'],['../namespaceentt.html#a693c0ab0c40b622dbc76350a316368b8',1,'entt::dependency(Sink< void(Registry< Entity > &, const Entity)> sink)'],['../namespaceentt.html#a76885d90dfdc0d66f1b505fbf3be4768',1,'entt::dependency(break_t, Sink< void(Registry< Entity > &, const Entity)> sink)']]], - ['destroy',['destroy',['../classentt_1_1Registry.html#a197afcc6da68df6eb87575284232a3ff',1,'entt::Registry::destroy()'],['../classentt_1_1SparseSet_3_01Entity_01_4.html#a7bd15b00eb2ce0e52d3d957673b4dd97',1,'entt::SparseSet< Entity >::destroy()'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#ae763b848ccde63e554f5b3f04b9dcdea',1,'entt::SparseSet< Entity, Type >::destroy()']]], + ['destroy',['destroy',['../classentt_1_1Registry.html#a140dfdb699d360b7c0e066ae298aab5e',1,'entt::Registry::destroy(tag_t)'],['../classentt_1_1Registry.html#a197afcc6da68df6eb87575284232a3ff',1,'entt::Registry::destroy(const entity_type entity)'],['../classentt_1_1Registry.html#a8169422afda942f5915ee68b46636c3b',1,'entt::Registry::destroy(Type...)'],['../classentt_1_1SparseSet_3_01Entity_01_4.html#a7bd15b00eb2ce0e52d3d957673b4dd97',1,'entt::SparseSet< Entity >::destroy()'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#ae763b848ccde63e554f5b3f04b9dcdea',1,'entt::SparseSet< Entity, Type >::destroy()']]], ['destroyed',['destroyed',['../classentt_1_1Snapshot.html#ac7d571f0901df2476451e2fd26d9dab9',1,'entt::Snapshot::destroyed()'],['../classentt_1_1SnapshotLoader.html#a094ec796643b2c7422533c24e80963f3',1,'entt::SnapshotLoader::destroyed()'],['../classentt_1_1ContinuousLoader.html#a8aa96c02f3fa734078b4e77198665c91',1,'entt::ContinuousLoader::destroyed()']]], ['destruction',['destruction',['../classentt_1_1Registry.html#a89df80b61b83bc3c4c3ed6d9324aa8b4',1,'entt::Registry::destruction(tag_t) ENTT_NOEXCEPT'],['../classentt_1_1Registry.html#aaa38dca5bb6875370d50a923cf52fcfb',1,'entt::Registry::destruction() ENTT_NOEXCEPT']]], + ['difference_5ftype',['difference_type',['../structentt_1_1entt__traits_3_01std_1_1uint16__t_01_4.html#ac16a602de26d43d316b497cb11b7c6b2',1,'entt::entt_traits< std::uint16_t >::difference_type()'],['../structentt_1_1entt__traits_3_01std_1_1uint32__t_01_4.html#a9809b457e16f4a071a91530b23c930d6',1,'entt::entt_traits< std::uint32_t >::difference_type()'],['../structentt_1_1entt__traits_3_01std_1_1uint64__t_01_4.html#afba2f77f80b0bf89a208f6876ab67271',1,'entt::entt_traits< std::uint64_t >::difference_type()']]], ['discard',['discard',['../classentt_1_1Registry.html#a9289a7c5d8bed1ba59948311f8fcd3f4',1,'entt::Registry::discard()'],['../classentt_1_1ResourceCache.html#a771ee2c8c203eb018731e7914afbe5fa',1,'entt::ResourceCache::discard()']]], ['disconnect',['disconnect',['../classentt_1_1Sink_3_01Ret_07Args_8_8_8_08_4.html#a3ecbd44accc33e5eb2d9e1920c347f5a',1,'entt::Sink< Ret(Args...)>::disconnect()'],['../classentt_1_1Sink_3_01Ret_07Args_8_8_8_08_4.html#a4c3eb2a296d7e99fd09b9e81ddab9777',1,'entt::Sink< Ret(Args...)>::disconnect(Class *instance)'],['../classentt_1_1Sink_3_01Ret_07Args_8_8_8_08_4.html#aa7ba0d3b192499927ac7714bc04d10f8',1,'entt::Sink< Ret(Args...)>::disconnect(Class *instance)'],['../classentt_1_1Sink_3_01Ret_07Args_8_8_8_08_4.html#af537cc1833d4c5dbc5216f7c70440539',1,'entt::Sink< Ret(Args...)>::disconnect()']]], ['dispatcher',['Dispatcher',['../classentt_1_1Dispatcher.html',1,'entt']]] diff --git a/search/all_4.js b/search/all_4.js index 1a140b618..7f06fdd6d 100644 --- a/search/all_4.js +++ b/search/all_4.js @@ -1,15 +1,15 @@ var searchData= [ - ['each',['each',['../classentt_1_1Registry.html#a1d7547f6d8503265480d235fe48dfb1d',1,'entt::Registry::each()'],['../classentt_1_1PersistentView.html#abaf27560862f9b514695e61fa6a8c6e6',1,'entt::PersistentView::each(Func func) const'],['../classentt_1_1PersistentView.html#aa71f689a8ac192907617a4316492f03c',1,'entt::PersistentView::each(Func func)'],['../classentt_1_1View.html#a85eea1ef9655368de8da355019fbeaa0',1,'entt::View::each(Func func) const'],['../classentt_1_1View.html#a6c540ac6937e6e9cf931cccaabcec745',1,'entt::View::each(Func func)'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a85eea1ef9655368de8da355019fbeaa0',1,'entt::View< Entity, Component >::each(Func func) const'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a6c540ac6937e6e9cf931cccaabcec745',1,'entt::View< Entity, Component >::each(Func func)'],['../classentt_1_1RawView.html#a2f88d86e1ad74bb558df47e7507612b1',1,'entt::RawView::each(Func func) const'],['../classentt_1_1RawView.html#ad54a334bfbd407df75b93e428117d598',1,'entt::RawView::each(Func func)']]], + ['each',['each',['../classentt_1_1Registry.html#a1d7547f6d8503265480d235fe48dfb1d',1,'entt::Registry::each()'],['../classentt_1_1PersistentView.html#abaf27560862f9b514695e61fa6a8c6e6',1,'entt::PersistentView::each(Func func) const'],['../classentt_1_1PersistentView.html#aa71f689a8ac192907617a4316492f03c',1,'entt::PersistentView::each(Func func)'],['../classentt_1_1View.html#a85eea1ef9655368de8da355019fbeaa0',1,'entt::View::each(Func func) const'],['../classentt_1_1View.html#a6c540ac6937e6e9cf931cccaabcec745',1,'entt::View::each(Func func)'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a85eea1ef9655368de8da355019fbeaa0',1,'entt::View< Entity, Component >::each(Func func) const'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a6c540ac6937e6e9cf931cccaabcec745',1,'entt::View< Entity, Component >::each(Func func)'],['../classentt_1_1RawView.html#a2f88d86e1ad74bb558df47e7507612b1',1,'entt::RawView::each(Func func) const'],['../classentt_1_1RawView.html#ad54a334bfbd407df75b93e428117d598',1,'entt::RawView::each(Func func)'],['../classentt_1_1RuntimeView.html#aa67ccd106835ddc0cc8c10bbdbcdd4e4',1,'entt::RuntimeView::each()']]], ['emitter',['Emitter',['../classentt_1_1Emitter.html',1,'entt::Emitter< Derived >'],['../structentt_1_1Emitter_1_1Connection.html#a1cad71ec309b8c8b0beee324b9b65e5a',1,'entt::Emitter::Connection::Emitter()'],['../classentt_1_1Emitter.html#a69aedf4db58a11af9eb6c36859e951c8',1,'entt::Emitter::Emitter() ENTT_NOEXCEPT=default'],['../classentt_1_1Emitter.html#ab4ee1e31a476217c9c8c5a9b9dfe856b',1,'entt::Emitter::Emitter(const Emitter &)=delete'],['../classentt_1_1Emitter.html#aef84a369260e86a006c151ab4a9041a8',1,'entt::Emitter::Emitter(Emitter &&)=default']]], - ['empty',['empty',['../classentt_1_1Registry.html#a57193f01b75256867ba34342cd46ec13',1,'entt::Registry::empty() const ENTT_NOEXCEPT'],['../classentt_1_1Registry.html#a8735df0baab2fea088e6946e2811e29b',1,'entt::Registry::empty() const ENTT_NOEXCEPT'],['../classentt_1_1SparseSet_3_01Entity_01_4.html#a62f5ebeb316c3d52877c6eca45c652ce',1,'entt::SparseSet< Entity >::empty()'],['../classentt_1_1PersistentView.html#a25cf198e023b229190aa6d62852f4d10',1,'entt::PersistentView::empty()'],['../classentt_1_1View.html#aee65a80863abccbe3117e60b22695dc4',1,'entt::View::empty()'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#aee65a80863abccbe3117e60b22695dc4',1,'entt::View< Entity, Component >::empty()'],['../classentt_1_1RawView.html#abf0001549a9555166c532405bd3b647d',1,'entt::RawView::empty()'],['../structentt_1_1ServiceLocator.html#afb0038914d828b6b3483484cc906ec44',1,'entt::ServiceLocator::empty()'],['../classentt_1_1Scheduler.html#aba0da7c946d76561a8694ecf7c5b29e3',1,'entt::Scheduler::empty()'],['../classentt_1_1ResourceCache.html#a03f2f3c02e84ec7f5825fe415c3f1cdb',1,'entt::ResourceCache::empty()'],['../classentt_1_1Emitter.html#a4c54c5f15827be561e2912f7e91d1a6f',1,'entt::Emitter::empty() const ENTT_NOEXCEPT'],['../classentt_1_1Emitter.html#a733f11dc3c15aa910e3f2e6f167b62fd',1,'entt::Emitter::empty() const ENTT_NOEXCEPT'],['../classentt_1_1SigH_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4.html#a6b35b22faefe41acd8c1426a1bdcd149',1,'entt::SigH< Ret(Args...), Collector >::empty()']]], - ['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']]], + ['empty',['empty',['../classentt_1_1Registry.html#a57193f01b75256867ba34342cd46ec13',1,'entt::Registry::empty() const ENTT_NOEXCEPT'],['../classentt_1_1Registry.html#a8735df0baab2fea088e6946e2811e29b',1,'entt::Registry::empty() const ENTT_NOEXCEPT'],['../classentt_1_1SparseSet_3_01Entity_01_4.html#a62f5ebeb316c3d52877c6eca45c652ce',1,'entt::SparseSet< Entity >::empty()'],['../classentt_1_1PersistentView.html#a25cf198e023b229190aa6d62852f4d10',1,'entt::PersistentView::empty()'],['../classentt_1_1View.html#aee65a80863abccbe3117e60b22695dc4',1,'entt::View::empty()'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#aee65a80863abccbe3117e60b22695dc4',1,'entt::View< Entity, Component >::empty()'],['../classentt_1_1RawView.html#abf0001549a9555166c532405bd3b647d',1,'entt::RawView::empty()'],['../classentt_1_1RuntimeView.html#ab08f06a99381e857657b2875e23c90a4',1,'entt::RuntimeView::empty()'],['../structentt_1_1ServiceLocator.html#afb0038914d828b6b3483484cc906ec44',1,'entt::ServiceLocator::empty()'],['../classentt_1_1Scheduler.html#aba0da7c946d76561a8694ecf7c5b29e3',1,'entt::Scheduler::empty()'],['../classentt_1_1ResourceCache.html#a03f2f3c02e84ec7f5825fe415c3f1cdb',1,'entt::ResourceCache::empty()'],['../classentt_1_1Delegate_3_01Ret_07Args_8_8_8_08_4.html#ab776848ee5ece9b92740d8a2ad0b84a8',1,'entt::Delegate< Ret(Args...)>::empty()'],['../classentt_1_1Emitter.html#a4c54c5f15827be561e2912f7e91d1a6f',1,'entt::Emitter::empty() const ENTT_NOEXCEPT'],['../classentt_1_1Emitter.html#a733f11dc3c15aa910e3f2e6f167b62fd',1,'entt::Emitter::empty() const ENTT_NOEXCEPT'],['../classentt_1_1SigH_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4.html#a6b35b22faefe41acd8c1426a1bdcd149',1,'entt::SigH< Ret(Args...), Collector >::empty()']]], + ['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_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()']]], + ['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()']]], ['entt',['entt',['../namespaceentt.html',1,'']]], ['entt_5ftraits',['entt_traits',['../structentt_1_1entt__traits.html',1,'entt']]], ['entt_5ftraits_3c_20std_3a_3auint16_5ft_20_3e',['entt_traits< std::uint16_t >',['../structentt_1_1entt__traits_3_01std_1_1uint16__t_01_4.html',1,'entt']]], diff --git a/search/all_6.js b/search/all_6.js index 7364835aa..d41d5d94e 100644 --- a/search/all_6.js +++ b/search/all_6.js @@ -1,4 +1,4 @@ var searchData= [ - ['get',['get',['../structentt_1_1Actor.html#ae6a07d30d0aca366d5b1eb3e839e36bc',1,'entt::Actor::get(tag_t) const ENTT_NOEXCEPT'],['../structentt_1_1Actor.html#ae3ef92c5829b365871bb9fffb013d825',1,'entt::Actor::get(tag_t) ENTT_NOEXCEPT'],['../structentt_1_1Actor.html#acd9d53518e387076d89df97767fee4f1',1,'entt::Actor::get() const ENTT_NOEXCEPT'],['../structentt_1_1Actor.html#a636b3ba19d4762b9b616a5e47e959b08',1,'entt::Actor::get() ENTT_NOEXCEPT'],['../classentt_1_1Prototype.html#a0d23c82dcf122123ee29ffd3254b4b84',1,'entt::Prototype::get() const ENTT_NOEXCEPT'],['../classentt_1_1Prototype.html#a4069701eaf29716ed9bbb404da5f1b59',1,'entt::Prototype::get() ENTT_NOEXCEPT'],['../classentt_1_1Prototype.html#ae52596223d2a61e52c41979b1e76d68f',1,'entt::Prototype::get() const ENTT_NOEXCEPT'],['../classentt_1_1Prototype.html#a35fcf29a4c01caa611cffa9f73cbe535',1,'entt::Prototype::get() ENTT_NOEXCEPT'],['../classentt_1_1Registry.html#a2079fb67093feb86b75e9dede6bb6c4d',1,'entt::Registry::get() const ENTT_NOEXCEPT'],['../classentt_1_1Registry.html#a3c71607135bee449a486c8a5241dc70d',1,'entt::Registry::get() ENTT_NOEXCEPT'],['../classentt_1_1Registry.html#aa40aa6a87415b2e88c67b8b9f895bfe8',1,'entt::Registry::get(const entity_type entity) const ENTT_NOEXCEPT'],['../classentt_1_1Registry.html#aefa861cd4cd2750ddb43f587fc756531',1,'entt::Registry::get(const entity_type entity) ENTT_NOEXCEPT'],['../classentt_1_1Registry.html#a19e0832f4aceb58f1be1e7540313cec0',1,'entt::Registry::get(const entity_type entity) const ENTT_NOEXCEPT'],['../classentt_1_1Registry.html#a73f3a68af4e73a74a273cca9ceab68a2',1,'entt::Registry::get(const entity_type entity) ENTT_NOEXCEPT'],['../classentt_1_1SparseSet_3_01Entity_01_4.html#a15ae580507381985e2bf3e4098d71f6c',1,'entt::SparseSet< Entity >::get()'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#a00ef6f3c6da43a1ef864a5252bc9b0a6',1,'entt::SparseSet< Entity, Type >::get(const entity_type entity) const ENTT_NOEXCEPT'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#ab0a6f42129ec08ab607545712e67ce92',1,'entt::SparseSet< Entity, Type >::get(const entity_type entity) ENTT_NOEXCEPT'],['../classentt_1_1PersistentView.html#a51452939486c5e98036b60838f69a32d',1,'entt::PersistentView::get(const entity_type entity) const ENTT_NOEXCEPT'],['../classentt_1_1PersistentView.html#a0a088e6e40be777f9834c1c3fc6d1b15',1,'entt::PersistentView::get(const entity_type entity) ENTT_NOEXCEPT'],['../classentt_1_1PersistentView.html#af6931b058d6009776cc19082eb9a512f',1,'entt::PersistentView::get(const entity_type entity) const ENTT_NOEXCEPT'],['../classentt_1_1PersistentView.html#ad2e8b8cf33831f8ea2caf1bd9a0474b6',1,'entt::PersistentView::get(const entity_type entity) ENTT_NOEXCEPT'],['../classentt_1_1View.html#a8f2e5fc95bb71c698b8ce61b9b4a8a5e',1,'entt::View::get(const entity_type entity) const ENTT_NOEXCEPT'],['../classentt_1_1View.html#ade86403331b51e25fae9238dd8997de0',1,'entt::View::get(const entity_type entity) ENTT_NOEXCEPT'],['../classentt_1_1View.html#a9fb10d57d05afa48c0f25ea0b475c81f',1,'entt::View::get(const entity_type entity) const ENTT_NOEXCEPT'],['../classentt_1_1View.html#ac5b199f031c48da2393eb56fea35b83e',1,'entt::View::get(const entity_type entity) ENTT_NOEXCEPT'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a51d497700a0322a130022eea97643d0f',1,'entt::View< Entity, Component >::get(const entity_type entity) const ENTT_NOEXCEPT'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a269fac4009da89c9743202b16dcd6d87',1,'entt::View< Entity, Component >::get(const entity_type entity) ENTT_NOEXCEPT'],['../structentt_1_1ServiceLocator.html#a87a0d27f2ce4ac8a94229e32853503ca',1,'entt::ServiceLocator::get()'],['../classentt_1_1ResourceHandle.html#a32e791c4556d040273643ca5f42755a9',1,'entt::ResourceHandle::get()']]] + ['get',['get',['../classentt_1_1Identifier.html#aed05b85b75f2b0646e007f156e43ca6a',1,'entt::Identifier::get()'],['../structentt_1_1Actor.html#ae6a07d30d0aca366d5b1eb3e839e36bc',1,'entt::Actor::get(tag_t) const ENTT_NOEXCEPT'],['../structentt_1_1Actor.html#ae3ef92c5829b365871bb9fffb013d825',1,'entt::Actor::get(tag_t) ENTT_NOEXCEPT'],['../structentt_1_1Actor.html#acd9d53518e387076d89df97767fee4f1',1,'entt::Actor::get() const ENTT_NOEXCEPT'],['../structentt_1_1Actor.html#a636b3ba19d4762b9b616a5e47e959b08',1,'entt::Actor::get() ENTT_NOEXCEPT'],['../classentt_1_1Prototype.html#a0d23c82dcf122123ee29ffd3254b4b84',1,'entt::Prototype::get() const ENTT_NOEXCEPT'],['../classentt_1_1Prototype.html#a4069701eaf29716ed9bbb404da5f1b59',1,'entt::Prototype::get() ENTT_NOEXCEPT'],['../classentt_1_1Prototype.html#ae52596223d2a61e52c41979b1e76d68f',1,'entt::Prototype::get() const ENTT_NOEXCEPT'],['../classentt_1_1Prototype.html#a35fcf29a4c01caa611cffa9f73cbe535',1,'entt::Prototype::get() ENTT_NOEXCEPT'],['../classentt_1_1Registry.html#a2079fb67093feb86b75e9dede6bb6c4d',1,'entt::Registry::get() const ENTT_NOEXCEPT'],['../classentt_1_1Registry.html#a3c71607135bee449a486c8a5241dc70d',1,'entt::Registry::get() ENTT_NOEXCEPT'],['../classentt_1_1Registry.html#aa40aa6a87415b2e88c67b8b9f895bfe8',1,'entt::Registry::get(const entity_type entity) const ENTT_NOEXCEPT'],['../classentt_1_1Registry.html#aefa861cd4cd2750ddb43f587fc756531',1,'entt::Registry::get(const entity_type entity) ENTT_NOEXCEPT'],['../classentt_1_1Registry.html#a19e0832f4aceb58f1be1e7540313cec0',1,'entt::Registry::get(const entity_type entity) const ENTT_NOEXCEPT'],['../classentt_1_1Registry.html#a73f3a68af4e73a74a273cca9ceab68a2',1,'entt::Registry::get(const entity_type entity) ENTT_NOEXCEPT'],['../classentt_1_1SparseSet_3_01Entity_01_4.html#aa7893474e3b47da7c2568a0dc4ab4bcf',1,'entt::SparseSet< Entity >::get()'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#a00ef6f3c6da43a1ef864a5252bc9b0a6',1,'entt::SparseSet< Entity, Type >::get(const entity_type entity) const ENTT_NOEXCEPT'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#ab0a6f42129ec08ab607545712e67ce92',1,'entt::SparseSet< Entity, Type >::get(const entity_type entity) ENTT_NOEXCEPT'],['../classentt_1_1PersistentView.html#a51452939486c5e98036b60838f69a32d',1,'entt::PersistentView::get(const entity_type entity) const ENTT_NOEXCEPT'],['../classentt_1_1PersistentView.html#a0a088e6e40be777f9834c1c3fc6d1b15',1,'entt::PersistentView::get(const entity_type entity) ENTT_NOEXCEPT'],['../classentt_1_1PersistentView.html#af6931b058d6009776cc19082eb9a512f',1,'entt::PersistentView::get(const entity_type entity) const ENTT_NOEXCEPT'],['../classentt_1_1PersistentView.html#ad2e8b8cf33831f8ea2caf1bd9a0474b6',1,'entt::PersistentView::get(const entity_type entity) ENTT_NOEXCEPT'],['../classentt_1_1View.html#a8f2e5fc95bb71c698b8ce61b9b4a8a5e',1,'entt::View::get(const entity_type entity) const ENTT_NOEXCEPT'],['../classentt_1_1View.html#ade86403331b51e25fae9238dd8997de0',1,'entt::View::get(const entity_type entity) ENTT_NOEXCEPT'],['../classentt_1_1View.html#a9fb10d57d05afa48c0f25ea0b475c81f',1,'entt::View::get(const entity_type entity) const ENTT_NOEXCEPT'],['../classentt_1_1View.html#ac5b199f031c48da2393eb56fea35b83e',1,'entt::View::get(const entity_type entity) ENTT_NOEXCEPT'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a51d497700a0322a130022eea97643d0f',1,'entt::View< Entity, Component >::get(const entity_type entity) const ENTT_NOEXCEPT'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a269fac4009da89c9743202b16dcd6d87',1,'entt::View< Entity, Component >::get(const entity_type entity) ENTT_NOEXCEPT'],['../structentt_1_1ServiceLocator.html#a87a0d27f2ce4ac8a94229e32853503ca',1,'entt::ServiceLocator::get()'],['../classentt_1_1ResourceHandle.html#a32e791c4556d040273643ca5f42755a9',1,'entt::ResourceHandle::get()']]] ]; diff --git a/search/all_8.js b/search/all_8.js index a8a498f13..0fa2e71e9 100644 --- a/search/all_8.js +++ b/search/all_8.js @@ -1,7 +1,8 @@ var searchData= [ - ['ident',['ident',['../namespaceentt.html#a02c0c4d37a2cdf573029814c1903de3c',1,'entt']]], + ['identifier',['Identifier',['../classentt_1_1Identifier.html',1,'entt']]], + ['identifier_5ftype',['identifier_type',['../classentt_1_1Identifier.html#a80c4fd9773928949e788790fac671169',1,'entt::Identifier']]], ['insertionsort',['InsertionSort',['../structentt_1_1InsertionSort.html',1,'entt']]], ['instance_5ftype',['instance_type',['../classentt_1_1SigH_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4.html#aad306ac41adf5562740f5528bed80014',1,'entt::SigH< Ret(Args...), Collector >']]], - ['iterator_5ftype',['iterator_type',['../classentt_1_1SparseSet_3_01Entity_01_4.html#a1ad77aed1e49af60b61044c996969b9a',1,'entt::SparseSet< Entity >::iterator_type()'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#a7ff4726f5e0ae6698cb8e3f039289b52',1,'entt::SparseSet< Entity, Type >::iterator_type()'],['../classentt_1_1PersistentView.html#ae563ed31a62fd9f33f93767f0ecdfff5',1,'entt::PersistentView::iterator_type()'],['../classentt_1_1View.html#a738fb04a466b1f858a1eb5d7bc8fd668',1,'entt::View::iterator_type()'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a791a1288db896fda8e77acad396aa513',1,'entt::View< Entity, Component >::iterator_type()'],['../classentt_1_1RawView.html#ab34740dea79327742888e84ba5c14328',1,'entt::RawView::iterator_type()']]] + ['iterator_5ftype',['iterator_type',['../classentt_1_1SparseSet_3_01Entity_01_4.html#a1ad77aed1e49af60b61044c996969b9a',1,'entt::SparseSet< Entity >::iterator_type()'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#a7ff4726f5e0ae6698cb8e3f039289b52',1,'entt::SparseSet< Entity, Type >::iterator_type()'],['../classentt_1_1PersistentView.html#ae563ed31a62fd9f33f93767f0ecdfff5',1,'entt::PersistentView::iterator_type()'],['../classentt_1_1View.html#a738fb04a466b1f858a1eb5d7bc8fd668',1,'entt::View::iterator_type()'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a791a1288db896fda8e77acad396aa513',1,'entt::View< Entity, Component >::iterator_type()'],['../classentt_1_1RawView.html#ab34740dea79327742888e84ba5c14328',1,'entt::RawView::iterator_type()'],['../classentt_1_1RuntimeView.html#a59c6645fb86e079986d04887aa7c74e1',1,'entt::RuntimeView::iterator_type()']]] ]; diff --git a/search/all_a.js b/search/all_a.js index cb2ea0b8a..3b0cca4e0 100644 --- a/search/all_a.js +++ b/search/all_a.js @@ -1,5 +1,6 @@ var searchData= [ ['map',['map',['../classentt_1_1ContinuousLoader.html#a63d6f733d8651a19b7ea882f3615455c',1,'entt::ContinuousLoader']]], - ['move',['move',['../classentt_1_1Registry.html#ae3592a627bf35b12d51ddd0876ca6896',1,'entt::Registry']]] + ['monostate',['Monostate',['../structentt_1_1Monostate.html',1,'entt']]], + ['move',['move',['../classentt_1_1Registry.html#a459073e0dfdb4f21519792717f688173',1,'entt::Registry']]] ]; diff --git a/search/all_b.js b/search/all_b.js index 6fe0543c8..ae2385a1f 100644 --- a/search/all_b.js +++ b/search/all_b.js @@ -1,18 +1,4 @@ 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']]], - ['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_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#a9a7a40458a3999618dd95d70de024331',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_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_1Actor.html#af65a5bd2973d27a9adb1a62b746111fe',1,'entt::Actor::operator=(const Actor &)=default'],['../structentt_1_1Actor.html#adbb2c4045a701b76d5fd514ec9221c02',1,'entt::Actor::operator=(Actor &&)=default'],['../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']]], - ['operator_3d_3d',['operator==',['../classentt_1_1HashedString.html#aa5ca9b72d2fa65f2a4796a4ffae00c11',1,'entt::HashedString::operator==()'],['../classentt_1_1Delegate_3_01Ret_07Args_8_8_8_08_4.html#a7fd87003864d2a56baa7d2c8a9317509',1,'entt::Delegate< Ret(Args...)>::operator==()'],['../classentt_1_1SigH_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4.html#acd0e64abe3b6d879a27ced38fe50aa4b',1,'entt::SigH< Ret(Args...), Collector >::operator==()']]], - ['orphan',['orphan',['../classentt_1_1Registry.html#a3b4a5341ac0ef79fd2477753e857a9cb',1,'entt::Registry']]], - ['orphans',['orphans',['../classentt_1_1Registry.html#ada2900e50f66573c14821baac03bbd68',1,'entt::Registry::orphans()'],['../classentt_1_1SnapshotLoader.html#a70e3af34bfacf921a2579b1d0055ceca',1,'entt::SnapshotLoader::orphans()'],['../classentt_1_1ContinuousLoader.html#ad1f0c307283afc23e11460c9ca2037c0',1,'entt::ContinuousLoader::orphans()']]] + ['null',['null',['../namespaceentt.html#a588326af8f6f902a6c0b57d3f9fc6c17',1,'entt']]] ]; diff --git a/search/all_c.js b/search/all_c.js index cd4f0b43a..dd1fb01f3 100644 --- a/search/all_c.js +++ b/search/all_c.js @@ -1,14 +1,20 @@ var searchData= [ - ['pause',['pause',['../classentt_1_1Process.html#a1f2f865b2c4f0c7cf2d82786ecb50f5f',1,'entt::Process']]], - ['paused',['paused',['../classentt_1_1Process.html#a3e320da0927d9ac83dc829d0aee8a310',1,'entt::Process']]], - ['persistent_5ft',['persistent_t',['../structentt_1_1persistent__t.html',1,'entt']]], - ['persistentview',['PersistentView',['../classentt_1_1PersistentView.html',1,'entt']]], - ['pos_5ftype',['pos_type',['../classentt_1_1SparseSet_3_01Entity_01_4.html#a20c218a69cf339371251ffa5580d7aa0',1,'entt::SparseSet< Entity >::pos_type()'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#ad161a395ca3979154a333520662c7737',1,'entt::SparseSet< Entity, Type >::pos_type()']]], - ['prepare',['prepare',['../classentt_1_1Registry.html#ac05c9ccc5fe57df386d8104578fc9675',1,'entt::Registry']]], - ['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::ProcessAdaptor< Func, Delta >'],['../structentt_1_1ProcessAdaptor.html#a16a0964a81c537fe16b937696e47358b',1,'entt::ProcessAdaptor::ProcessAdaptor()']]], - ['prototype',['Prototype',['../classentt_1_1Prototype.html',1,'entt::Prototype< Entity >'],['../classentt_1_1Prototype.html#aa6033be234aad4d287d740c40db17fec',1,'entt::Prototype::Prototype()']]], - ['publish',['publish',['../classentt_1_1Emitter.html#ab5141fd9793f53ef83af47c8c8a74b0e',1,'entt::Emitter::publish()'],['../classentt_1_1SigH_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4.html#a5d3aaec10dba146d75672e3dc81a4274',1,'entt::SigH< Ret(Args...), Collector >::publish()']]] + ['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']]], + ['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_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']]], + ['operator_3d_3d',['operator==',['../classentt_1_1HashedString.html#aa5ca9b72d2fa65f2a4796a4ffae00c11',1,'entt::HashedString::operator==()'],['../classentt_1_1Delegate_3_01Ret_07Args_8_8_8_08_4.html#a7fd87003864d2a56baa7d2c8a9317509',1,'entt::Delegate< Ret(Args...)>::operator==()'],['../classentt_1_1SigH_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4.html#acd0e64abe3b6d879a27ced38fe50aa4b',1,'entt::SigH< Ret(Args...), Collector >::operator==()']]], + ['operator_5b_5d',['operator[]',['../classentt_1_1SparseSet_3_01Entity_01_4.html#a2de3b3dc887e30616c37dd1dbc3de46b',1,'entt::SparseSet< Entity >::operator[]()'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#a073eb76e982c1031ef0b69118764faab',1,'entt::SparseSet< Entity, Type >::operator[](const size_type pos) const ENTT_NOEXCEPT'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#a6cd7bd35b86f34191bbfe73ff922b91e',1,'entt::SparseSet< Entity, Type >::operator[](const size_type pos) ENTT_NOEXCEPT'],['../classentt_1_1PersistentView.html#a7edc6f5cbd49d978469d9384b9aca6b3',1,'entt::PersistentView::operator[]()'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a6094dd00422b07f0a9523699b9bf77aa',1,'entt::View< Entity, Component >::operator[]()'],['../classentt_1_1RawView.html#a6a8855ebc61f5ea5f4c676173e92cfcc',1,'entt::RawView::operator[](const size_type pos) const ENTT_NOEXCEPT'],['../classentt_1_1RawView.html#ac85aa3a824640eeeb45f9d1eaaaeea8d',1,'entt::RawView::operator[](const size_type pos) ENTT_NOEXCEPT']]], + ['orphan',['orphan',['../classentt_1_1Registry.html#a3b4a5341ac0ef79fd2477753e857a9cb',1,'entt::Registry']]], + ['orphans',['orphans',['../classentt_1_1Registry.html#ada2900e50f66573c14821baac03bbd68',1,'entt::Registry::orphans()'],['../classentt_1_1SnapshotLoader.html#a70e3af34bfacf921a2579b1d0055ceca',1,'entt::SnapshotLoader::orphans()'],['../classentt_1_1ContinuousLoader.html#ad1f0c307283afc23e11460c9ca2037c0',1,'entt::ContinuousLoader::orphans()']]] ]; diff --git a/search/all_d.js b/search/all_d.js index 6934c41e7..4630825ab 100644 --- a/search/all_d.js +++ b/search/all_d.js @@ -1,24 +1,13 @@ var searchData= [ - ['raw',['raw',['../classentt_1_1Registry.html#aaa4a9703f583da393101aa91604267e6',1,'entt::Registry::raw() const ENTT_NOEXCEPT'],['../classentt_1_1Registry.html#a1728046f5645bf2ff3f167c40ca29d0e',1,'entt::Registry::raw() ENTT_NOEXCEPT'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#acbad98597d305c221c90eabd67b169bc',1,'entt::SparseSet< Entity, Type >::raw() const ENTT_NOEXCEPT'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#a8bc3ff7eb8a371ad64cf16f85116946b',1,'entt::SparseSet< Entity, Type >::raw() ENTT_NOEXCEPT'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a67bdaf39828b8055069d51825192541d',1,'entt::View< Entity, Component >::raw() const ENTT_NOEXCEPT'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a07d8b7d15b93f9988f6b4fbf514a356a',1,'entt::View< Entity, Component >::raw() ENTT_NOEXCEPT'],['../classentt_1_1RawView.html#ae9909bbe3f734989b765324b8cd75332',1,'entt::RawView::raw() const ENTT_NOEXCEPT'],['../classentt_1_1RawView.html#a1cdb189f5b2bf17021cf5c53d10ec222',1,'entt::RawView::raw() ENTT_NOEXCEPT']]], - ['raw_5ft',['raw_t',['../structentt_1_1raw__t.html',1,'entt']]], - ['raw_5ftype',['raw_type',['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a8bdfb1fbdd4340131be9c70bf02671b5',1,'entt::View< Entity, Component >::raw_type()'],['../classentt_1_1RawView.html#a6a6e2cd0387a63e153a18bd60a1283a3',1,'entt::RawView::raw_type()']]], - ['rawview',['RawView',['../classentt_1_1RawView.html',1,'entt']]], - ['ref',['ref',['../structentt_1_1ServiceLocator.html#a746c27214142cdd98c650c9cc66bf165',1,'entt::ServiceLocator']]], - ['registry',['Registry',['../classentt_1_1Registry.html',1,'entt::Registry< Entity >'],['../structentt_1_1Actor.html#ab31a5da2d556ff3c01e0cea59f090956',1,'entt::Actor::registry() const ENTT_NOEXCEPT'],['../structentt_1_1Actor.html#ae914b8f7817cdfaf596983743df126fe',1,'entt::Actor::registry() ENTT_NOEXCEPT'],['../classentt_1_1Registry.html#ab5022bf3ac71d209cb9b85e686324f28',1,'entt::Registry::Registry()=default'],['../classentt_1_1Registry.html#a441dfbc29b39106fbacec0f0c7b07359',1,'entt::Registry::Registry(const Registry &)=delete'],['../classentt_1_1Registry.html#a5340b49833d3e23e28200a4069fe04b0',1,'entt::Registry::Registry(Registry &&)=default']]], - ['registry_3c_20entity_20_3e',['Registry< Entity >',['../classentt_1_1Snapshot.html#a200646cfe88496da691aab5f61c0fa69',1,'entt::Snapshot::Registry< Entity >()'],['../classentt_1_1SnapshotLoader.html#a200646cfe88496da691aab5f61c0fa69',1,'entt::SnapshotLoader::Registry< Entity >()'],['../classentt_1_1PersistentView.html#a200646cfe88496da691aab5f61c0fa69',1,'entt::PersistentView::Registry< Entity >()'],['../classentt_1_1View.html#a200646cfe88496da691aab5f61c0fa69',1,'entt::View::Registry< Entity >()'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a200646cfe88496da691aab5f61c0fa69',1,'entt::View< Entity, Component >::Registry< Entity >()'],['../classentt_1_1RawView.html#a200646cfe88496da691aab5f61c0fa69',1,'entt::RawView::Registry< Entity >()']]], - ['registry_5ftype',['registry_type',['../structentt_1_1Actor.html#a59ce601affb52396d2cacdc3ffd14928',1,'entt::Actor::registry_type()'],['../classentt_1_1Prototype.html#a8e4a91009c1cbb0bfaadf4e95178eaec',1,'entt::Prototype::registry_type()']]], - ['rejected',['rejected',['../classentt_1_1Process.html#aa4e618f12f5cf18d978557ea793b697d',1,'entt::Process']]], - ['reload',['reload',['../classentt_1_1ResourceCache.html#afaa3e5a964e1f04ea0c2c86adb7b4fbd',1,'entt::ResourceCache']]], - ['remove',['remove',['../structentt_1_1Actor.html#a4c805918eeb0f01c86529a3c9b4e9b13',1,'entt::Actor::remove(tag_t)'],['../structentt_1_1Actor.html#a2a647927841d9c2440cfb664f371bf09',1,'entt::Actor::remove()'],['../classentt_1_1Registry.html#a957bcbdbf082f9767e5474a73be6ece4',1,'entt::Registry::remove()'],['../classentt_1_1Registry.html#a113ff63724bdb90344984d5dd16995f2',1,'entt::Registry::remove(const entity_type entity)']]], - ['replace',['replace',['../classentt_1_1Registry.html#a39b071aa110b8ea38fb71ca471d371b5',1,'entt::Registry::replace(tag_t, Args &&... args)'],['../classentt_1_1Registry.html#a2482e363a9b4ff9b6a4a0e1385c7b6e1',1,'entt::Registry::replace(const entity_type entity, Args &&... args)']]], - ['reserve',['reserve',['../classentt_1_1Registry.html#a6d57a57e13ca236a215e332b94852147',1,'entt::Registry::reserve(const size_type cap)'],['../classentt_1_1Registry.html#aa927ac552b42e2a0fcc8de08f56510c7',1,'entt::Registry::reserve(const size_type cap)'],['../classentt_1_1SparseSet_3_01Entity_01_4.html#a19fd8be1b2cad2a4ca01c88225b0a379',1,'entt::SparseSet< Entity >::reserve()'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#a9b7168661765b86a7c24500a03115197',1,'entt::SparseSet< Entity, Type >::reserve()']]], - ['reset',['reset',['../classentt_1_1Registry.html#af406e83980abc792905ff4a0626b3d02',1,'entt::Registry::reset(const entity_type entity)'],['../classentt_1_1Registry.html#a613333e0a4acb227d08938ccc594e064',1,'entt::Registry::reset()'],['../classentt_1_1Registry.html#a1b6ec743e9a62389cf2bba9a25ee09d7',1,'entt::Registry::reset()'],['../classentt_1_1SparseSet_3_01Entity_01_4.html#ad1c62c65aeb0112e688f05d8f641cdab',1,'entt::SparseSet< Entity >::reset()'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#a3b138c121f11592a3f9e9f2fc2bb67fe',1,'entt::SparseSet< Entity, Type >::reset()'],['../structentt_1_1ServiceLocator.html#ac52892a5692c15c8b230a5020adb0847',1,'entt::ServiceLocator::reset()'],['../classentt_1_1Delegate_3_01Ret_07Args_8_8_8_08_4.html#a77c5b9a98a0636391955de940dad0b4f',1,'entt::Delegate< Ret(Args...)>::reset()']]], - ['resource_5ftype',['resource_type',['../classentt_1_1ResourceCache.html#a4936da93a62827d8c5fc04ac444e5456',1,'entt::ResourceCache']]], - ['resourcecache',['ResourceCache',['../classentt_1_1ResourceCache.html',1,'entt::ResourceCache< Resource >'],['../classentt_1_1ResourceCache.html#aaeb4613b842a5d0861585e024af0a41d',1,'entt::ResourceCache::ResourceCache()=default'],['../classentt_1_1ResourceCache.html#a4dbd37c3c1a703b684b6122a59a0b3a7',1,'entt::ResourceCache::ResourceCache(const ResourceCache &) ENTT_NOEXCEPT=delete'],['../classentt_1_1ResourceCache.html#a86dde6d7190adbb13d8472424f6e8bca',1,'entt::ResourceCache::ResourceCache(ResourceCache &&) ENTT_NOEXCEPT=default']]], - ['resourcecache_3c_20resource_20_3e',['ResourceCache< Resource >',['../classentt_1_1ResourceHandle.html#a302c9d1bd54cf8e7e958d5e505773b23',1,'entt::ResourceHandle::ResourceCache< Resource >()'],['../classentt_1_1ResourceLoader.html#a302c9d1bd54cf8e7e958d5e505773b23',1,'entt::ResourceLoader::ResourceCache< Resource >()']]], - ['resourcehandle',['ResourceHandle',['../classentt_1_1ResourceHandle.html',1,'entt::ResourceHandle< Resource >'],['../classentt_1_1ResourceHandle.html#a7b267f802e92b57dcc750f824fd5e3df',1,'entt::ResourceHandle::ResourceHandle(const ResourceHandle &) ENTT_NOEXCEPT=default'],['../classentt_1_1ResourceHandle.html#a4d5c929ea7f0bd8860d7188aa6fb76a8',1,'entt::ResourceHandle::ResourceHandle(ResourceHandle &&) ENTT_NOEXCEPT=default']]], - ['resourceloader',['ResourceLoader',['../classentt_1_1ResourceLoader.html',1,'entt']]], - ['respect',['respect',['../classentt_1_1SparseSet_3_01Entity_01_4.html#a17422401f952b58be5113ff88e302c0e',1,'entt::SparseSet< Entity >::respect()'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#a605545f8f99a7bb1f92d1dfc3ed438f3',1,'entt::SparseSet< Entity, Type >::respect()']]], - ['restore',['restore',['../classentt_1_1Registry.html#a925e91c4f1904d5104a0c5e9e9f70223',1,'entt::Registry']]] + ['pause',['pause',['../classentt_1_1Process.html#a1f2f865b2c4f0c7cf2d82786ecb50f5f',1,'entt::Process']]], + ['paused',['paused',['../classentt_1_1Process.html#a3e320da0927d9ac83dc829d0aee8a310',1,'entt::Process']]], + ['persistent_5ft',['persistent_t',['../structentt_1_1persistent__t.html',1,'entt']]], + ['persistentview',['PersistentView',['../classentt_1_1PersistentView.html',1,'entt']]], + ['prepare',['prepare',['../classentt_1_1Registry.html#ac05c9ccc5fe57df386d8104578fc9675',1,'entt::Registry']]], + ['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::ProcessAdaptor< Func, Delta >'],['../structentt_1_1ProcessAdaptor.html#a16a0964a81c537fe16b937696e47358b',1,'entt::ProcessAdaptor::ProcessAdaptor()']]], + ['prototype',['Prototype',['../classentt_1_1Prototype.html',1,'entt::Prototype< Entity >'],['../classentt_1_1Prototype.html#aa6033be234aad4d287d740c40db17fec',1,'entt::Prototype::Prototype(Registry< Entity > &registry)'],['../classentt_1_1Prototype.html#a6f3d7431f85160da0e255b279c4b5291',1,'entt::Prototype::Prototype(const Prototype &)=delete'],['../classentt_1_1Prototype.html#ad4900c4a27f506b5d2b9db54aba9d224',1,'entt::Prototype::Prototype(Prototype &&other)']]], + ['publish',['publish',['../classentt_1_1Emitter.html#ab5141fd9793f53ef83af47c8c8a74b0e',1,'entt::Emitter::publish()'],['../classentt_1_1SigH_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4.html#a5d3aaec10dba146d75672e3dc81a4274',1,'entt::SigH< Ret(Args...), Collector >::publish()']]] ]; diff --git a/search/all_e.js b/search/all_e.js index bdf4ceb62..eb8344b6a 100644 --- a/search/all_e.js +++ b/search/all_e.js @@ -1,25 +1,25 @@ var searchData= [ - ['scheduler',['Scheduler',['../classentt_1_1Scheduler.html',1,'entt::Scheduler< Delta >'],['../classentt_1_1Scheduler.html#a9c8baf08ea6f2869432cb13d870481c3',1,'entt::Scheduler::Scheduler() ENTT_NOEXCEPT=default'],['../classentt_1_1Scheduler.html#a4527dc6d1aedb50126e522ae7c8de5a1',1,'entt::Scheduler::Scheduler(const Scheduler &)=delete'],['../classentt_1_1Scheduler.html#ab3a3ca9fa457fd48873c6d0d700a6f6c',1,'entt::Scheduler::Scheduler(Scheduler &&)=default']]], - ['service_5ftype',['service_type',['../structentt_1_1ServiceLocator.html#a0631b136adf579365fb444bc5e8f1416',1,'entt::ServiceLocator']]], - ['servicelocator',['ServiceLocator',['../structentt_1_1ServiceLocator.html',1,'entt::ServiceLocator< Service >'],['../structentt_1_1ServiceLocator.html#a9806fa1d96f6edfb5b946b11acabc0da',1,'entt::ServiceLocator::ServiceLocator()']]], - ['set',['set',['../classentt_1_1Prototype.html#abf665ce59c8f43c4eff3ce77a21c5cfb',1,'entt::Prototype::set()'],['../structentt_1_1ServiceLocator.html#abf8d8b8d70ed082d54516def7500ec5c',1,'entt::ServiceLocator::set(Args &&... args)'],['../structentt_1_1ServiceLocator.html#ad913de8d4a2dcf39b925773e42cbfff5',1,'entt::ServiceLocator::set(std::shared_ptr< Service > ptr)']]], - ['shrink',['shrink',['../classentt_1_1ContinuousLoader.html#a959dc40d6285e8175e95c3679c6698d6',1,'entt::ContinuousLoader']]], - ['sigh',['SigH',['../classentt_1_1SigH.html',1,'entt::SigH< Function, Collector >'],['../classentt_1_1Sink_3_01Ret_07Args_8_8_8_08_4.html#a06123dbbb14806c157626a76c2a2da01',1,'entt::Sink< Ret(Args...)>::SigH()']]], - ['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< Function >'],['../classentt_1_1Dispatcher.html#a091aa6ab261f34eee355c2b7180f709b',1,'entt::Dispatcher::sink()'],['../classentt_1_1SigH_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4.html#aa525ade53e40ebc5fbee9c8704d555ce',1,'entt::SigH< Ret(Args...), Collector >::sink()']]], - ['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']]], - ['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_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_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_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#a69bdf0c5645f2049e8dee9e0c4de53ca',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#af97db8232b2b26604adb5f10ded70f11',1,'entt::Registry::sort(Compare compare, Sort sort=Sort{})'],['../classentt_1_1Registry.html#aa3abb830a7ba342266b62ff1a2965754',1,'entt::Registry::sort()'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#a0bb1bb7e7660c279558e94efd917b7db',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']]], - ['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']]], - ['succeed',['succeed',['../classentt_1_1Process.html#ae90a29bf2afabf6a14aec0e1d3809a0f',1,'entt::Process']]], - ['swap',['swap',['../classentt_1_1SparseSet_3_01Entity_01_4.html#a271e5e6736388ca8bf350187da2a0d8f',1,'entt::SparseSet< Entity >::swap()'],['../classentt_1_1SigH_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4.html#a77dd7bf9e63e5457c080416f31bb232b',1,'entt::SigH< Ret(Args...), Collector >::swap()']]] + ['raw',['raw',['../classentt_1_1Registry.html#aaa4a9703f583da393101aa91604267e6',1,'entt::Registry::raw() const ENTT_NOEXCEPT'],['../classentt_1_1Registry.html#a1728046f5645bf2ff3f167c40ca29d0e',1,'entt::Registry::raw() ENTT_NOEXCEPT'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#acbad98597d305c221c90eabd67b169bc',1,'entt::SparseSet< Entity, Type >::raw() const ENTT_NOEXCEPT'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#a8bc3ff7eb8a371ad64cf16f85116946b',1,'entt::SparseSet< Entity, Type >::raw() ENTT_NOEXCEPT'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a67bdaf39828b8055069d51825192541d',1,'entt::View< Entity, Component >::raw() const ENTT_NOEXCEPT'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a07d8b7d15b93f9988f6b4fbf514a356a',1,'entt::View< Entity, Component >::raw() ENTT_NOEXCEPT'],['../classentt_1_1RawView.html#ae9909bbe3f734989b765324b8cd75332',1,'entt::RawView::raw() const ENTT_NOEXCEPT'],['../classentt_1_1RawView.html#a1cdb189f5b2bf17021cf5c53d10ec222',1,'entt::RawView::raw() ENTT_NOEXCEPT']]], + ['raw_5ft',['raw_t',['../structentt_1_1raw__t.html',1,'entt']]], + ['raw_5ftype',['raw_type',['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a8bdfb1fbdd4340131be9c70bf02671b5',1,'entt::View< Entity, Component >::raw_type()'],['../classentt_1_1RawView.html#a6a6e2cd0387a63e153a18bd60a1283a3',1,'entt::RawView::raw_type()']]], + ['rawview',['RawView',['../classentt_1_1RawView.html',1,'entt']]], + ['ref',['ref',['../structentt_1_1ServiceLocator.html#a746c27214142cdd98c650c9cc66bf165',1,'entt::ServiceLocator']]], + ['registry',['Registry',['../classentt_1_1Registry.html',1,'entt::Registry< Entity >'],['../structentt_1_1Actor.html#ab31a5da2d556ff3c01e0cea59f090956',1,'entt::Actor::registry() const ENTT_NOEXCEPT'],['../structentt_1_1Actor.html#ae914b8f7817cdfaf596983743df126fe',1,'entt::Actor::registry() ENTT_NOEXCEPT'],['../classentt_1_1Registry.html#ab5022bf3ac71d209cb9b85e686324f28',1,'entt::Registry::Registry()=default'],['../classentt_1_1Registry.html#a441dfbc29b39106fbacec0f0c7b07359',1,'entt::Registry::Registry(const Registry &)=delete'],['../classentt_1_1Registry.html#a5340b49833d3e23e28200a4069fe04b0',1,'entt::Registry::Registry(Registry &&)=default']]], + ['registry_3c_20entity_20_3e',['Registry< Entity >',['../classentt_1_1Snapshot.html#a200646cfe88496da691aab5f61c0fa69',1,'entt::Snapshot::Registry< Entity >()'],['../classentt_1_1SnapshotLoader.html#a200646cfe88496da691aab5f61c0fa69',1,'entt::SnapshotLoader::Registry< Entity >()'],['../classentt_1_1PersistentView.html#a200646cfe88496da691aab5f61c0fa69',1,'entt::PersistentView::Registry< Entity >()'],['../classentt_1_1View.html#a200646cfe88496da691aab5f61c0fa69',1,'entt::View::Registry< Entity >()'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a200646cfe88496da691aab5f61c0fa69',1,'entt::View< Entity, Component >::Registry< Entity >()'],['../classentt_1_1RawView.html#a200646cfe88496da691aab5f61c0fa69',1,'entt::RawView::Registry< Entity >()'],['../classentt_1_1RuntimeView.html#a200646cfe88496da691aab5f61c0fa69',1,'entt::RuntimeView::Registry< Entity >()']]], + ['registry_5ftype',['registry_type',['../structentt_1_1Actor.html#a59ce601affb52396d2cacdc3ffd14928',1,'entt::Actor::registry_type()'],['../classentt_1_1Prototype.html#a8e4a91009c1cbb0bfaadf4e95178eaec',1,'entt::Prototype::registry_type()']]], + ['rejected',['rejected',['../classentt_1_1Process.html#aa4e618f12f5cf18d978557ea793b697d',1,'entt::Process']]], + ['reload',['reload',['../classentt_1_1ResourceCache.html#afaa3e5a964e1f04ea0c2c86adb7b4fbd',1,'entt::ResourceCache']]], + ['remove',['remove',['../structentt_1_1Actor.html#a4c805918eeb0f01c86529a3c9b4e9b13',1,'entt::Actor::remove(tag_t)'],['../structentt_1_1Actor.html#a2a647927841d9c2440cfb664f371bf09',1,'entt::Actor::remove()'],['../classentt_1_1Registry.html#a957bcbdbf082f9767e5474a73be6ece4',1,'entt::Registry::remove()'],['../classentt_1_1Registry.html#a113ff63724bdb90344984d5dd16995f2',1,'entt::Registry::remove(const entity_type entity)']]], + ['replace',['replace',['../classentt_1_1Registry.html#a39b071aa110b8ea38fb71ca471d371b5',1,'entt::Registry::replace(tag_t, Args &&... args)'],['../classentt_1_1Registry.html#a2482e363a9b4ff9b6a4a0e1385c7b6e1',1,'entt::Registry::replace(const entity_type entity, Args &&... args)']]], + ['reserve',['reserve',['../classentt_1_1Registry.html#a6d57a57e13ca236a215e332b94852147',1,'entt::Registry::reserve(const size_type cap)'],['../classentt_1_1Registry.html#aa927ac552b42e2a0fcc8de08f56510c7',1,'entt::Registry::reserve(const size_type cap)'],['../classentt_1_1SparseSet_3_01Entity_01_4.html#a19fd8be1b2cad2a4ca01c88225b0a379',1,'entt::SparseSet< Entity >::reserve()'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#a9b7168661765b86a7c24500a03115197',1,'entt::SparseSet< Entity, Type >::reserve()']]], + ['reset',['reset',['../classentt_1_1Registry.html#af406e83980abc792905ff4a0626b3d02',1,'entt::Registry::reset(const entity_type entity)'],['../classentt_1_1Registry.html#a613333e0a4acb227d08938ccc594e064',1,'entt::Registry::reset()'],['../classentt_1_1Registry.html#a1b6ec743e9a62389cf2bba9a25ee09d7',1,'entt::Registry::reset()'],['../classentt_1_1SparseSet_3_01Entity_01_4.html#ad1c62c65aeb0112e688f05d8f641cdab',1,'entt::SparseSet< Entity >::reset()'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#a3b138c121f11592a3f9e9f2fc2bb67fe',1,'entt::SparseSet< Entity, Type >::reset()'],['../structentt_1_1ServiceLocator.html#ac52892a5692c15c8b230a5020adb0847',1,'entt::ServiceLocator::reset()'],['../classentt_1_1Delegate_3_01Ret_07Args_8_8_8_08_4.html#a77c5b9a98a0636391955de940dad0b4f',1,'entt::Delegate< Ret(Args...)>::reset()']]], + ['resource_5ftype',['resource_type',['../classentt_1_1ResourceCache.html#a4936da93a62827d8c5fc04ac444e5456',1,'entt::ResourceCache']]], + ['resourcecache',['ResourceCache',['../classentt_1_1ResourceCache.html',1,'entt::ResourceCache< Resource >'],['../classentt_1_1ResourceCache.html#aaeb4613b842a5d0861585e024af0a41d',1,'entt::ResourceCache::ResourceCache()=default'],['../classentt_1_1ResourceCache.html#a4dbd37c3c1a703b684b6122a59a0b3a7',1,'entt::ResourceCache::ResourceCache(const ResourceCache &) ENTT_NOEXCEPT=delete'],['../classentt_1_1ResourceCache.html#a86dde6d7190adbb13d8472424f6e8bca',1,'entt::ResourceCache::ResourceCache(ResourceCache &&) ENTT_NOEXCEPT=default']]], + ['resourcecache_3c_20resource_20_3e',['ResourceCache< Resource >',['../classentt_1_1ResourceHandle.html#a302c9d1bd54cf8e7e958d5e505773b23',1,'entt::ResourceHandle::ResourceCache< Resource >()'],['../classentt_1_1ResourceLoader.html#a302c9d1bd54cf8e7e958d5e505773b23',1,'entt::ResourceLoader::ResourceCache< Resource >()']]], + ['resourcehandle',['ResourceHandle',['../classentt_1_1ResourceHandle.html',1,'entt::ResourceHandle< Resource >'],['../classentt_1_1ResourceHandle.html#a7b267f802e92b57dcc750f824fd5e3df',1,'entt::ResourceHandle::ResourceHandle(const ResourceHandle &) ENTT_NOEXCEPT=default'],['../classentt_1_1ResourceHandle.html#a4d5c929ea7f0bd8860d7188aa6fb76a8',1,'entt::ResourceHandle::ResourceHandle(ResourceHandle &&) ENTT_NOEXCEPT=default']]], + ['resourceloader',['ResourceLoader',['../classentt_1_1ResourceLoader.html',1,'entt']]], + ['respect',['respect',['../classentt_1_1SparseSet_3_01Entity_01_4.html#a17422401f952b58be5113ff88e302c0e',1,'entt::SparseSet< Entity >::respect()'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#a605545f8f99a7bb1f92d1dfc3ed438f3',1,'entt::SparseSet< Entity, Type >::respect()']]], + ['restore',['restore',['../classentt_1_1Registry.html#a37b755b43c7067658d2b4129baa403cf',1,'entt::Registry']]], + ['runtimeview',['RuntimeView',['../classentt_1_1RuntimeView.html',1,'entt']]] ]; diff --git a/search/all_f.js b/search/all_f.js index 1af19899d..e7ec18d78 100644 --- a/search/all_f.js +++ b/search/all_f.js @@ -1,10 +1,25 @@ var searchData= [ - ['tag',['tag',['../classentt_1_1Snapshot.html#ac13d5fe79511e27f7b935e84c112e051',1,'entt::Snapshot::tag(Archive &archive) const'],['../classentt_1_1Snapshot.html#a960471c2f13bc1c693a9c58396e63b93',1,'entt::Snapshot::tag(Archive &archive) const'],['../classentt_1_1SnapshotLoader.html#afc4964c76a8fc7a8a1c6a435babc796f',1,'entt::SnapshotLoader::tag()'],['../classentt_1_1ContinuousLoader.html#a8d50d3f90d95b370305561da67da6c3b',1,'entt::ContinuousLoader::tag()']]], - ['tag_5ft',['tag_t',['../structentt_1_1tag__t.html',1,'entt']]], - ['tag_5ftype',['tag_type',['../classentt_1_1Registry.html#a357cfdc1b3c5abc7a36e8eddbd6ce5c7',1,'entt::Registry']]], - ['temp',['temp',['../classentt_1_1ResourceCache.html#a00ad6d9478d2f6721f0a846b49adec07',1,'entt::ResourceCache']]], - ['tick',['tick',['../classentt_1_1Process.html#a9298c55069b27d4ffa005f4345be4d59',1,'entt::Process']]], - ['trigger',['trigger',['../classentt_1_1Dispatcher.html#a89d44e6fa992fba9ba927f4b1492f66f',1,'entt::Dispatcher']]], - ['type',['type',['../classentt_1_1Family.html#aa5ce983dfef17bf0df6a608308193f6d',1,'entt::Family::type()'],['../classentt_1_1Registry.html#a682552d500d7768b5d9d4e5f547cdfaf',1,'entt::Registry::type(tag_t) ENTT_NOEXCEPT'],['../classentt_1_1Registry.html#a484018ca7d1898708ea17a651eddc7e4',1,'entt::Registry::type() ENTT_NOEXCEPT']]] + ['scheduler',['Scheduler',['../classentt_1_1Scheduler.html',1,'entt::Scheduler< Delta >'],['../classentt_1_1Scheduler.html#a9c8baf08ea6f2869432cb13d870481c3',1,'entt::Scheduler::Scheduler() ENTT_NOEXCEPT=default'],['../classentt_1_1Scheduler.html#a4527dc6d1aedb50126e522ae7c8de5a1',1,'entt::Scheduler::Scheduler(const Scheduler &)=delete'],['../classentt_1_1Scheduler.html#ab3a3ca9fa457fd48873c6d0d700a6f6c',1,'entt::Scheduler::Scheduler(Scheduler &&)=default']]], + ['service_5ftype',['service_type',['../structentt_1_1ServiceLocator.html#a0631b136adf579365fb444bc5e8f1416',1,'entt::ServiceLocator']]], + ['servicelocator',['ServiceLocator',['../structentt_1_1ServiceLocator.html',1,'entt::ServiceLocator< Service >'],['../structentt_1_1ServiceLocator.html#a9806fa1d96f6edfb5b946b11acabc0da',1,'entt::ServiceLocator::ServiceLocator()']]], + ['set',['set',['../classentt_1_1Prototype.html#abf665ce59c8f43c4eff3ce77a21c5cfb',1,'entt::Prototype::set()'],['../structentt_1_1ServiceLocator.html#abf8d8b8d70ed082d54516def7500ec5c',1,'entt::ServiceLocator::set(Args &&... args)'],['../structentt_1_1ServiceLocator.html#ad913de8d4a2dcf39b925773e42cbfff5',1,'entt::ServiceLocator::set(std::shared_ptr< Service > ptr)']]], + ['shrink',['shrink',['../classentt_1_1ContinuousLoader.html#a959dc40d6285e8175e95c3679c6698d6',1,'entt::ContinuousLoader']]], + ['sigh',['SigH',['../classentt_1_1SigH.html',1,'entt::SigH< Function, Collector >'],['../classentt_1_1Sink_3_01Ret_07Args_8_8_8_08_4.html#a06123dbbb14806c157626a76c2a2da01',1,'entt::Sink< Ret(Args...)>::SigH()']]], + ['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< Function >'],['../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()']]], + ['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']]], + ['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']]], + ['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']]], + ['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']]], + ['succeed',['succeed',['../classentt_1_1Process.html#ae90a29bf2afabf6a14aec0e1d3809a0f',1,'entt::Process']]], + ['swap',['swap',['../classentt_1_1SparseSet_3_01Entity_01_4.html#ace9db01fbfd9f1b8afa4a6f43d42390e',1,'entt::SparseSet< Entity >::swap()'],['../classentt_1_1SigH_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4.html#a77dd7bf9e63e5457c080416f31bb232b',1,'entt::SigH< Ret(Args...), Collector >::swap()']]] ]; diff --git a/search/classes_7.js b/search/classes_7.js index d1fbf88ac..b153b39ae 100644 --- a/search/classes_7.js +++ b/search/classes_7.js @@ -1,4 +1,5 @@ var searchData= [ + ['identifier',['Identifier',['../classentt_1_1Identifier.html',1,'entt']]], ['insertionsort',['InsertionSort',['../structentt_1_1InsertionSort.html',1,'entt']]] ]; diff --git a/search/classes_8.js b/search/classes_8.js index 3820dea84..15cc5ce97 100644 --- a/search/classes_8.js +++ b/search/classes_8.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']]] + ['monostate',['Monostate',['../structentt_1_1Monostate.html',1,'entt']]] ]; diff --git a/search/classes_9.js b/search/classes_9.js index 5b2e40023..3820dea84 100644 --- a/search/classes_9.js +++ b/search/classes_9.js @@ -1,9 +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']]] + ['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_a.js b/search/classes_a.js index 260c5e21d..6154b5021 100644 --- a/search/classes_a.js +++ b/search/classes_a.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_b.js b/search/classes_b.js index 467e6c4c1..260c5e21d 100644 --- a/search/classes_b.js +++ b/search/classes_b.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_c.js b/search/classes_c.js index adad9ed1c..467e6c4c1 100644 --- a/search/classes_c.js +++ b/search/classes_c.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_d.html b/search/classes_d.html new file mode 100644 index 000000000..d4a7ed7ad --- /dev/null +++ b/search/classes_d.html @@ -0,0 +1,26 @@ + + + + + + + + + +
    +
    Loading...
    +
    + +
    Searching...
    +
    No Matches
    + +
    + + diff --git a/search/classes_d.js b/search/classes_d.js new file mode 100644 index 000000000..adad9ed1c --- /dev/null +++ b/search/classes_d.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_1.js b/search/functions_1.js index 34f9640ae..59542535f 100644 --- a/search/functions_1.js +++ b/search/functions_1.js @@ -1,4 +1,4 @@ var searchData= [ - ['begin',['begin',['../classentt_1_1SparseSet_3_01Entity_01_4.html#aebd9c479dc54907cf42a4423f34edeb2',1,'entt::SparseSet< Entity >::begin() const ENTT_NOEXCEPT'],['../classentt_1_1SparseSet_3_01Entity_01_4.html#a6b33b62684d62255ca53a371cfbe1d28',1,'entt::SparseSet< Entity >::begin() ENTT_NOEXCEPT'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#a6f177729ba483b37119881db872b7736',1,'entt::SparseSet< Entity, Type >::begin() const ENTT_NOEXCEPT'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#aef10db6199e31f72c14c4be9347b0822',1,'entt::SparseSet< Entity, Type >::begin() ENTT_NOEXCEPT'],['../classentt_1_1PersistentView.html#af1469f9dd45ebc68729e88e741c465a4',1,'entt::PersistentView::begin() const ENTT_NOEXCEPT'],['../classentt_1_1PersistentView.html#a6bb6ca7b9dbbbf6da3f2cf7250a61075',1,'entt::PersistentView::begin() ENTT_NOEXCEPT'],['../classentt_1_1View.html#a7c59406241bd142289a0d618a33f98d3',1,'entt::View::begin() const ENTT_NOEXCEPT'],['../classentt_1_1View.html#a5d4b1ac137a2dd3ac7f8f91a40b6eb0e',1,'entt::View::begin() ENTT_NOEXCEPT'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a7c59406241bd142289a0d618a33f98d3',1,'entt::View< Entity, Component >::begin() const ENTT_NOEXCEPT'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a5d4b1ac137a2dd3ac7f8f91a40b6eb0e',1,'entt::View< Entity, Component >::begin() ENTT_NOEXCEPT'],['../classentt_1_1RawView.html#a564cc60d60b8d80aefca967eea79031f',1,'entt::RawView::begin() const ENTT_NOEXCEPT'],['../classentt_1_1RawView.html#a195eb860ca3f49f72fc08e4505431286',1,'entt::RawView::begin() ENTT_NOEXCEPT']]] + ['begin',['begin',['../classentt_1_1SparseSet_3_01Entity_01_4.html#aebd9c479dc54907cf42a4423f34edeb2',1,'entt::SparseSet< Entity >::begin() const ENTT_NOEXCEPT'],['../classentt_1_1SparseSet_3_01Entity_01_4.html#a6b33b62684d62255ca53a371cfbe1d28',1,'entt::SparseSet< Entity >::begin() ENTT_NOEXCEPT'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#a6f177729ba483b37119881db872b7736',1,'entt::SparseSet< Entity, Type >::begin() const ENTT_NOEXCEPT'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#aef10db6199e31f72c14c4be9347b0822',1,'entt::SparseSet< Entity, Type >::begin() ENTT_NOEXCEPT'],['../classentt_1_1PersistentView.html#af1469f9dd45ebc68729e88e741c465a4',1,'entt::PersistentView::begin() const ENTT_NOEXCEPT'],['../classentt_1_1PersistentView.html#a6bb6ca7b9dbbbf6da3f2cf7250a61075',1,'entt::PersistentView::begin() ENTT_NOEXCEPT'],['../classentt_1_1View.html#a7c59406241bd142289a0d618a33f98d3',1,'entt::View::begin() const ENTT_NOEXCEPT'],['../classentt_1_1View.html#a5d4b1ac137a2dd3ac7f8f91a40b6eb0e',1,'entt::View::begin() ENTT_NOEXCEPT'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a7c59406241bd142289a0d618a33f98d3',1,'entt::View< Entity, Component >::begin() const ENTT_NOEXCEPT'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a5d4b1ac137a2dd3ac7f8f91a40b6eb0e',1,'entt::View< Entity, Component >::begin() ENTT_NOEXCEPT'],['../classentt_1_1RawView.html#a564cc60d60b8d80aefca967eea79031f',1,'entt::RawView::begin() const ENTT_NOEXCEPT'],['../classentt_1_1RawView.html#a195eb860ca3f49f72fc08e4505431286',1,'entt::RawView::begin() ENTT_NOEXCEPT'],['../classentt_1_1RuntimeView.html#af1fb74dd84e6ffd0f8626b8f0f55af91',1,'entt::RuntimeView::begin() const ENTT_NOEXCEPT'],['../classentt_1_1RuntimeView.html#a8b424a07dd1fdca3a11103dbc6ad76ac',1,'entt::RuntimeView::begin() ENTT_NOEXCEPT']]] ]; diff --git a/search/functions_10.js b/search/functions_10.js index 6da7468ed..adef06239 100644 --- a/search/functions_10.js +++ b/search/functions_10.js @@ -2,5 +2,5 @@ var searchData= [ ['valid',['valid',['../classentt_1_1Registry.html#aaba72db4ebf99a911b58327063ec8ad9',1,'entt::Registry']]], ['version',['version',['../classentt_1_1Registry.html#ad7467ac1c8a7657062b1b4386dded54e',1,'entt::Registry']]], - ['view',['view',['../classentt_1_1Registry.html#aed83d4c8f80ae647ee73f2a8440fa09d',1,'entt::Registry::view()'],['../classentt_1_1Registry.html#abb1eb5f1a2ec31d14b5b98271ff78f1e',1,'entt::Registry::view(persistent_t)'],['../classentt_1_1Registry.html#aedc2a2344c5d13a0483608d48189a92a',1,'entt::Registry::view(raw_t)']]] + ['view',['view',['../classentt_1_1Registry.html#aed83d4c8f80ae647ee73f2a8440fa09d',1,'entt::Registry::view()'],['../classentt_1_1Registry.html#abb1eb5f1a2ec31d14b5b98271ff78f1e',1,'entt::Registry::view(persistent_t)'],['../classentt_1_1Registry.html#aedc2a2344c5d13a0483608d48189a92a',1,'entt::Registry::view(raw_t)'],['../classentt_1_1Registry.html#a4a157973e57670b5df3eedc8d137de7e',1,'entt::Registry::view(It first, It last)']]] ]; diff --git a/search/functions_2.js b/search/functions_2.js index 04e7efca6..87cc85f8a 100644 --- a/search/functions_2.js +++ b/search/functions_2.js @@ -1,8 +1,8 @@ var searchData= [ - ['capacity',['capacity',['../classentt_1_1Registry.html#aefe4ec26db45257de26da19147a9e3f3',1,'entt::Registry']]], - ['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()']]], - ['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()']]], + ['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()']]], ['clear',['clear',['../classentt_1_1Scheduler.html#a2fd48cfd2ce32308f5e7bb8bafd5cda2',1,'entt::Scheduler::clear()'],['../classentt_1_1ResourceCache.html#a9ab70500ad42f8bd565ce1c379f472b4',1,'entt::ResourceCache::clear()'],['../classentt_1_1Emitter.html#a4e722d57776f3185e39386e6f252c56b',1,'entt::Emitter::clear() ENTT_NOEXCEPT'],['../classentt_1_1Emitter.html#a12ce32d79978c671a4d72532cd8e33f7',1,'entt::Emitter::clear() ENTT_NOEXCEPT']]], ['collect',['collect',['../classentt_1_1SigH_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4.html#af50a728e8b61c75af4286132e1312c77',1,'entt::SigH< Ret(Args...), Collector >']]], ['component',['component',['../classentt_1_1Snapshot.html#a336288f5faaeb5f49831e3a0b4445bb0',1,'entt::Snapshot::component(Archive &archive) const'],['../classentt_1_1Snapshot.html#a4aa8df6d1e59c4f441e472f63f5ee580',1,'entt::Snapshot::component(Archive &archive) const'],['../classentt_1_1Snapshot.html#a98433fc64a9935e744a4c1b1f5d6e630',1,'entt::Snapshot::component(Archive &archive, It first, It last) const'],['../classentt_1_1SnapshotLoader.html#a03f291aa5216eab207780f785a75bbba',1,'entt::SnapshotLoader::component()'],['../classentt_1_1ContinuousLoader.html#a9c185ecae861f074afb1d2a14cf4f0f2',1,'entt::ContinuousLoader::component()']]], @@ -10,8 +10,8 @@ var searchData= ['connection',['Connection',['../structentt_1_1Emitter_1_1Connection.html#a1091537202d401609a73f0ee3fcc9ea6',1,'entt::Emitter::Connection::Connection() ENTT_NOEXCEPT=default'],['../structentt_1_1Emitter_1_1Connection.html#af059ef0d0aa727ea11e6873144fcbc1b',1,'entt::Emitter::Connection::Connection(typename Handler< Event >::connection_type conn)'],['../structentt_1_1Emitter_1_1Connection.html#a1ccd273683a9fb65a7a4d0c9bf7d0543',1,'entt::Emitter::Connection::Connection(const Connection &)=default'],['../structentt_1_1Emitter_1_1Connection.html#a0c5020d2127d9d0e45abd7e9c08c65c3',1,'entt::Emitter::Connection::Connection(Connection &&)=default']]], ['construct',['construct',['../classentt_1_1SparseSet_3_01Entity_01_4.html#a47dad39fa63ac4be07dcd9234c8a57c7',1,'entt::SparseSet< Entity >::construct()'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#acf06fa56b6b0880d546dd3bc0ddc087f',1,'entt::SparseSet< Entity, Type >::construct(const entity_type entity, Args &&... args)'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#aded5c64ff04ee1a78e7e238208923d58',1,'entt::SparseSet< Entity, Type >::construct(const entity_type entity, Args &&... args)']]], ['construction',['construction',['../classentt_1_1Registry.html#a6f6b29268ba11a8526fa3f9d3bdb58e5',1,'entt::Registry::construction(tag_t) ENTT_NOEXCEPT'],['../classentt_1_1Registry.html#af43b25946f4cbdec633df25317edc020',1,'entt::Registry::construction() ENTT_NOEXCEPT']]], - ['contains',['contains',['../classentt_1_1Registry.html#a67a9d1a75fa1f8e29091f1127c0f3a70',1,'entt::Registry::contains()'],['../classentt_1_1PersistentView.html#af98a61a6ac04e08b6b46e4163ad3d415',1,'entt::PersistentView::contains()'],['../classentt_1_1View.html#abbc407e2fecdbcf97c129ade5db185e8',1,'entt::View::contains()'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#abbc407e2fecdbcf97c129ade5db185e8',1,'entt::View< Entity, Component >::contains()'],['../classentt_1_1ResourceCache.html#aa133ec347db1ee8fab5d757b8b24a185',1,'entt::ResourceCache::contains()']]], + ['contains',['contains',['../classentt_1_1Registry.html#a67a9d1a75fa1f8e29091f1127c0f3a70',1,'entt::Registry::contains()'],['../classentt_1_1PersistentView.html#af98a61a6ac04e08b6b46e4163ad3d415',1,'entt::PersistentView::contains()'],['../classentt_1_1View.html#abbc407e2fecdbcf97c129ade5db185e8',1,'entt::View::contains()'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#abbc407e2fecdbcf97c129ade5db185e8',1,'entt::View< Entity, Component >::contains()'],['../classentt_1_1RuntimeView.html#a903cb93104fba0816f71f8851c6ff162',1,'entt::RuntimeView::contains()'],['../classentt_1_1ResourceCache.html#aa133ec347db1ee8fab5d757b8b24a185',1,'entt::ResourceCache::contains()']]], ['continuousloader',['ContinuousLoader',['../classentt_1_1ContinuousLoader.html#a26ccd96f9ee4219ad7e3d1b8138ade37',1,'entt::ContinuousLoader::ContinuousLoader(Registry< entity_type > &registry) ENTT_NOEXCEPT'],['../classentt_1_1ContinuousLoader.html#a4d7cdac6b296eedb3dffd7ad0f182e3a',1,'entt::ContinuousLoader::ContinuousLoader(const ContinuousLoader &)=delete'],['../classentt_1_1ContinuousLoader.html#a4ba9abb1659a78f2ba4e12f86da68402',1,'entt::ContinuousLoader::ContinuousLoader(ContinuousLoader &&)=default']]], - ['create',['create',['../classentt_1_1Prototype.html#a434b43ae5f761093a0c9e74da0802523',1,'entt::Prototype::create(registry_type &other) const'],['../classentt_1_1Prototype.html#a5a659d7582d8fb52c5be59b0a319e2ec',1,'entt::Prototype::create() const'],['../classentt_1_1Registry.html#a10de276e8fc78fe205907c808ddb8d9a',1,'entt::Registry::create()']]], + ['create',['create',['../classentt_1_1Prototype.html#a434b43ae5f761093a0c9e74da0802523',1,'entt::Prototype::create(registry_type &other) const'],['../classentt_1_1Prototype.html#a5a659d7582d8fb52c5be59b0a319e2ec',1,'entt::Prototype::create() const'],['../classentt_1_1Registry.html#a433ac3fc8ea49347f691dd4ad1ccb58b',1,'entt::Registry::create()']]], ['current',['current',['../classentt_1_1Registry.html#a9e79305f5a066bdc2b272181a08b17ac',1,'entt::Registry']]] ]; diff --git a/search/functions_3.js b/search/functions_3.js index 644651c82..c3533cc0d 100644 --- a/search/functions_3.js +++ b/search/functions_3.js @@ -4,7 +4,7 @@ var searchData= ['dead',['dead',['../classentt_1_1Process.html#a08265296592bcc0e5a6632b7067329b9',1,'entt::Process']]], ['delegate',['Delegate',['../classentt_1_1Delegate_3_01Ret_07Args_8_8_8_08_4.html#a57a011f4b42c3358ee5219f63997e00b',1,'entt::Delegate< Ret(Args...)>']]], ['dependency',['dependency',['../namespaceentt.html#ab9d53b0eb1c6fb4d7636d4ab451b615d',1,'entt::dependency(Registry< Entity > &registry, const Entity entity)'],['../namespaceentt.html#a693c0ab0c40b622dbc76350a316368b8',1,'entt::dependency(Sink< void(Registry< Entity > &, const Entity)> sink)'],['../namespaceentt.html#a76885d90dfdc0d66f1b505fbf3be4768',1,'entt::dependency(break_t, Sink< void(Registry< Entity > &, const Entity)> sink)']]], - ['destroy',['destroy',['../classentt_1_1Registry.html#a197afcc6da68df6eb87575284232a3ff',1,'entt::Registry::destroy()'],['../classentt_1_1SparseSet_3_01Entity_01_4.html#a7bd15b00eb2ce0e52d3d957673b4dd97',1,'entt::SparseSet< Entity >::destroy()'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#ae763b848ccde63e554f5b3f04b9dcdea',1,'entt::SparseSet< Entity, Type >::destroy()']]], + ['destroy',['destroy',['../classentt_1_1Registry.html#a140dfdb699d360b7c0e066ae298aab5e',1,'entt::Registry::destroy(tag_t)'],['../classentt_1_1Registry.html#a197afcc6da68df6eb87575284232a3ff',1,'entt::Registry::destroy(const entity_type entity)'],['../classentt_1_1Registry.html#a8169422afda942f5915ee68b46636c3b',1,'entt::Registry::destroy(Type...)'],['../classentt_1_1SparseSet_3_01Entity_01_4.html#a7bd15b00eb2ce0e52d3d957673b4dd97',1,'entt::SparseSet< Entity >::destroy()'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#ae763b848ccde63e554f5b3f04b9dcdea',1,'entt::SparseSet< Entity, Type >::destroy()']]], ['destroyed',['destroyed',['../classentt_1_1Snapshot.html#ac7d571f0901df2476451e2fd26d9dab9',1,'entt::Snapshot::destroyed()'],['../classentt_1_1SnapshotLoader.html#a094ec796643b2c7422533c24e80963f3',1,'entt::SnapshotLoader::destroyed()'],['../classentt_1_1ContinuousLoader.html#a8aa96c02f3fa734078b4e77198665c91',1,'entt::ContinuousLoader::destroyed()']]], ['destruction',['destruction',['../classentt_1_1Registry.html#a89df80b61b83bc3c4c3ed6d9324aa8b4',1,'entt::Registry::destruction(tag_t) ENTT_NOEXCEPT'],['../classentt_1_1Registry.html#aaa38dca5bb6875370d50a923cf52fcfb',1,'entt::Registry::destruction() ENTT_NOEXCEPT']]], ['discard',['discard',['../classentt_1_1Registry.html#a9289a7c5d8bed1ba59948311f8fcd3f4',1,'entt::Registry::discard()'],['../classentt_1_1ResourceCache.html#a771ee2c8c203eb018731e7914afbe5fa',1,'entt::ResourceCache::discard()']]], diff --git a/search/functions_4.js b/search/functions_4.js index a1047d76c..7bbcc3ee0 100644 --- a/search/functions_4.js +++ b/search/functions_4.js @@ -1,9 +1,9 @@ var searchData= [ - ['each',['each',['../classentt_1_1Registry.html#a1d7547f6d8503265480d235fe48dfb1d',1,'entt::Registry::each()'],['../classentt_1_1PersistentView.html#abaf27560862f9b514695e61fa6a8c6e6',1,'entt::PersistentView::each(Func func) const'],['../classentt_1_1PersistentView.html#aa71f689a8ac192907617a4316492f03c',1,'entt::PersistentView::each(Func func)'],['../classentt_1_1View.html#a85eea1ef9655368de8da355019fbeaa0',1,'entt::View::each(Func func) const'],['../classentt_1_1View.html#a6c540ac6937e6e9cf931cccaabcec745',1,'entt::View::each(Func func)'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a85eea1ef9655368de8da355019fbeaa0',1,'entt::View< Entity, Component >::each(Func func) const'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a6c540ac6937e6e9cf931cccaabcec745',1,'entt::View< Entity, Component >::each(Func func)'],['../classentt_1_1RawView.html#a2f88d86e1ad74bb558df47e7507612b1',1,'entt::RawView::each(Func func) const'],['../classentt_1_1RawView.html#ad54a334bfbd407df75b93e428117d598',1,'entt::RawView::each(Func func)']]], + ['each',['each',['../classentt_1_1Registry.html#a1d7547f6d8503265480d235fe48dfb1d',1,'entt::Registry::each()'],['../classentt_1_1PersistentView.html#abaf27560862f9b514695e61fa6a8c6e6',1,'entt::PersistentView::each(Func func) const'],['../classentt_1_1PersistentView.html#aa71f689a8ac192907617a4316492f03c',1,'entt::PersistentView::each(Func func)'],['../classentt_1_1View.html#a85eea1ef9655368de8da355019fbeaa0',1,'entt::View::each(Func func) const'],['../classentt_1_1View.html#a6c540ac6937e6e9cf931cccaabcec745',1,'entt::View::each(Func func)'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a85eea1ef9655368de8da355019fbeaa0',1,'entt::View< Entity, Component >::each(Func func) const'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a6c540ac6937e6e9cf931cccaabcec745',1,'entt::View< Entity, Component >::each(Func func)'],['../classentt_1_1RawView.html#a2f88d86e1ad74bb558df47e7507612b1',1,'entt::RawView::each(Func func) const'],['../classentt_1_1RawView.html#ad54a334bfbd407df75b93e428117d598',1,'entt::RawView::each(Func func)'],['../classentt_1_1RuntimeView.html#aa67ccd106835ddc0cc8c10bbdbcdd4e4',1,'entt::RuntimeView::each()']]], ['emitter',['Emitter',['../classentt_1_1Emitter.html#a69aedf4db58a11af9eb6c36859e951c8',1,'entt::Emitter::Emitter() ENTT_NOEXCEPT=default'],['../classentt_1_1Emitter.html#ab4ee1e31a476217c9c8c5a9b9dfe856b',1,'entt::Emitter::Emitter(const Emitter &)=delete'],['../classentt_1_1Emitter.html#aef84a369260e86a006c151ab4a9041a8',1,'entt::Emitter::Emitter(Emitter &&)=default']]], - ['empty',['empty',['../classentt_1_1Registry.html#a57193f01b75256867ba34342cd46ec13',1,'entt::Registry::empty() const ENTT_NOEXCEPT'],['../classentt_1_1Registry.html#a8735df0baab2fea088e6946e2811e29b',1,'entt::Registry::empty() const ENTT_NOEXCEPT'],['../classentt_1_1SparseSet_3_01Entity_01_4.html#a62f5ebeb316c3d52877c6eca45c652ce',1,'entt::SparseSet< Entity >::empty()'],['../classentt_1_1PersistentView.html#a25cf198e023b229190aa6d62852f4d10',1,'entt::PersistentView::empty()'],['../classentt_1_1View.html#aee65a80863abccbe3117e60b22695dc4',1,'entt::View::empty()'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#aee65a80863abccbe3117e60b22695dc4',1,'entt::View< Entity, Component >::empty()'],['../classentt_1_1RawView.html#abf0001549a9555166c532405bd3b647d',1,'entt::RawView::empty()'],['../structentt_1_1ServiceLocator.html#afb0038914d828b6b3483484cc906ec44',1,'entt::ServiceLocator::empty()'],['../classentt_1_1Scheduler.html#aba0da7c946d76561a8694ecf7c5b29e3',1,'entt::Scheduler::empty()'],['../classentt_1_1ResourceCache.html#a03f2f3c02e84ec7f5825fe415c3f1cdb',1,'entt::ResourceCache::empty()'],['../classentt_1_1Emitter.html#a4c54c5f15827be561e2912f7e91d1a6f',1,'entt::Emitter::empty() const ENTT_NOEXCEPT'],['../classentt_1_1Emitter.html#a733f11dc3c15aa910e3f2e6f167b62fd',1,'entt::Emitter::empty() const ENTT_NOEXCEPT'],['../classentt_1_1SigH_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4.html#a6b35b22faefe41acd8c1426a1bdcd149',1,'entt::SigH< Ret(Args...), Collector >::empty()']]], - ['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']]], + ['empty',['empty',['../classentt_1_1Registry.html#a57193f01b75256867ba34342cd46ec13',1,'entt::Registry::empty() const ENTT_NOEXCEPT'],['../classentt_1_1Registry.html#a8735df0baab2fea088e6946e2811e29b',1,'entt::Registry::empty() const ENTT_NOEXCEPT'],['../classentt_1_1SparseSet_3_01Entity_01_4.html#a62f5ebeb316c3d52877c6eca45c652ce',1,'entt::SparseSet< Entity >::empty()'],['../classentt_1_1PersistentView.html#a25cf198e023b229190aa6d62852f4d10',1,'entt::PersistentView::empty()'],['../classentt_1_1View.html#aee65a80863abccbe3117e60b22695dc4',1,'entt::View::empty()'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#aee65a80863abccbe3117e60b22695dc4',1,'entt::View< Entity, Component >::empty()'],['../classentt_1_1RawView.html#abf0001549a9555166c532405bd3b647d',1,'entt::RawView::empty()'],['../classentt_1_1RuntimeView.html#ab08f06a99381e857657b2875e23c90a4',1,'entt::RuntimeView::empty()'],['../structentt_1_1ServiceLocator.html#afb0038914d828b6b3483484cc906ec44',1,'entt::ServiceLocator::empty()'],['../classentt_1_1Scheduler.html#aba0da7c946d76561a8694ecf7c5b29e3',1,'entt::Scheduler::empty()'],['../classentt_1_1ResourceCache.html#a03f2f3c02e84ec7f5825fe415c3f1cdb',1,'entt::ResourceCache::empty()'],['../classentt_1_1Delegate_3_01Ret_07Args_8_8_8_08_4.html#ab776848ee5ece9b92740d8a2ad0b84a8',1,'entt::Delegate< Ret(Args...)>::empty()'],['../classentt_1_1Emitter.html#a4c54c5f15827be561e2912f7e91d1a6f',1,'entt::Emitter::empty() const ENTT_NOEXCEPT'],['../classentt_1_1Emitter.html#a733f11dc3c15aa910e3f2e6f167b62fd',1,'entt::Emitter::empty() const ENTT_NOEXCEPT'],['../classentt_1_1SigH_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4.html#a6b35b22faefe41acd8c1426a1bdcd149',1,'entt::SigH< Ret(Args...), Collector >::empty()']]], + ['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']]], diff --git a/search/functions_6.js b/search/functions_6.js index 7364835aa..d41d5d94e 100644 --- a/search/functions_6.js +++ b/search/functions_6.js @@ -1,4 +1,4 @@ var searchData= [ - ['get',['get',['../structentt_1_1Actor.html#ae6a07d30d0aca366d5b1eb3e839e36bc',1,'entt::Actor::get(tag_t) const ENTT_NOEXCEPT'],['../structentt_1_1Actor.html#ae3ef92c5829b365871bb9fffb013d825',1,'entt::Actor::get(tag_t) ENTT_NOEXCEPT'],['../structentt_1_1Actor.html#acd9d53518e387076d89df97767fee4f1',1,'entt::Actor::get() const ENTT_NOEXCEPT'],['../structentt_1_1Actor.html#a636b3ba19d4762b9b616a5e47e959b08',1,'entt::Actor::get() ENTT_NOEXCEPT'],['../classentt_1_1Prototype.html#a0d23c82dcf122123ee29ffd3254b4b84',1,'entt::Prototype::get() const ENTT_NOEXCEPT'],['../classentt_1_1Prototype.html#a4069701eaf29716ed9bbb404da5f1b59',1,'entt::Prototype::get() ENTT_NOEXCEPT'],['../classentt_1_1Prototype.html#ae52596223d2a61e52c41979b1e76d68f',1,'entt::Prototype::get() const ENTT_NOEXCEPT'],['../classentt_1_1Prototype.html#a35fcf29a4c01caa611cffa9f73cbe535',1,'entt::Prototype::get() ENTT_NOEXCEPT'],['../classentt_1_1Registry.html#a2079fb67093feb86b75e9dede6bb6c4d',1,'entt::Registry::get() const ENTT_NOEXCEPT'],['../classentt_1_1Registry.html#a3c71607135bee449a486c8a5241dc70d',1,'entt::Registry::get() ENTT_NOEXCEPT'],['../classentt_1_1Registry.html#aa40aa6a87415b2e88c67b8b9f895bfe8',1,'entt::Registry::get(const entity_type entity) const ENTT_NOEXCEPT'],['../classentt_1_1Registry.html#aefa861cd4cd2750ddb43f587fc756531',1,'entt::Registry::get(const entity_type entity) ENTT_NOEXCEPT'],['../classentt_1_1Registry.html#a19e0832f4aceb58f1be1e7540313cec0',1,'entt::Registry::get(const entity_type entity) const ENTT_NOEXCEPT'],['../classentt_1_1Registry.html#a73f3a68af4e73a74a273cca9ceab68a2',1,'entt::Registry::get(const entity_type entity) ENTT_NOEXCEPT'],['../classentt_1_1SparseSet_3_01Entity_01_4.html#a15ae580507381985e2bf3e4098d71f6c',1,'entt::SparseSet< Entity >::get()'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#a00ef6f3c6da43a1ef864a5252bc9b0a6',1,'entt::SparseSet< Entity, Type >::get(const entity_type entity) const ENTT_NOEXCEPT'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#ab0a6f42129ec08ab607545712e67ce92',1,'entt::SparseSet< Entity, Type >::get(const entity_type entity) ENTT_NOEXCEPT'],['../classentt_1_1PersistentView.html#a51452939486c5e98036b60838f69a32d',1,'entt::PersistentView::get(const entity_type entity) const ENTT_NOEXCEPT'],['../classentt_1_1PersistentView.html#a0a088e6e40be777f9834c1c3fc6d1b15',1,'entt::PersistentView::get(const entity_type entity) ENTT_NOEXCEPT'],['../classentt_1_1PersistentView.html#af6931b058d6009776cc19082eb9a512f',1,'entt::PersistentView::get(const entity_type entity) const ENTT_NOEXCEPT'],['../classentt_1_1PersistentView.html#ad2e8b8cf33831f8ea2caf1bd9a0474b6',1,'entt::PersistentView::get(const entity_type entity) ENTT_NOEXCEPT'],['../classentt_1_1View.html#a8f2e5fc95bb71c698b8ce61b9b4a8a5e',1,'entt::View::get(const entity_type entity) const ENTT_NOEXCEPT'],['../classentt_1_1View.html#ade86403331b51e25fae9238dd8997de0',1,'entt::View::get(const entity_type entity) ENTT_NOEXCEPT'],['../classentt_1_1View.html#a9fb10d57d05afa48c0f25ea0b475c81f',1,'entt::View::get(const entity_type entity) const ENTT_NOEXCEPT'],['../classentt_1_1View.html#ac5b199f031c48da2393eb56fea35b83e',1,'entt::View::get(const entity_type entity) ENTT_NOEXCEPT'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a51d497700a0322a130022eea97643d0f',1,'entt::View< Entity, Component >::get(const entity_type entity) const ENTT_NOEXCEPT'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a269fac4009da89c9743202b16dcd6d87',1,'entt::View< Entity, Component >::get(const entity_type entity) ENTT_NOEXCEPT'],['../structentt_1_1ServiceLocator.html#a87a0d27f2ce4ac8a94229e32853503ca',1,'entt::ServiceLocator::get()'],['../classentt_1_1ResourceHandle.html#a32e791c4556d040273643ca5f42755a9',1,'entt::ResourceHandle::get()']]] + ['get',['get',['../classentt_1_1Identifier.html#aed05b85b75f2b0646e007f156e43ca6a',1,'entt::Identifier::get()'],['../structentt_1_1Actor.html#ae6a07d30d0aca366d5b1eb3e839e36bc',1,'entt::Actor::get(tag_t) const ENTT_NOEXCEPT'],['../structentt_1_1Actor.html#ae3ef92c5829b365871bb9fffb013d825',1,'entt::Actor::get(tag_t) ENTT_NOEXCEPT'],['../structentt_1_1Actor.html#acd9d53518e387076d89df97767fee4f1',1,'entt::Actor::get() const ENTT_NOEXCEPT'],['../structentt_1_1Actor.html#a636b3ba19d4762b9b616a5e47e959b08',1,'entt::Actor::get() ENTT_NOEXCEPT'],['../classentt_1_1Prototype.html#a0d23c82dcf122123ee29ffd3254b4b84',1,'entt::Prototype::get() const ENTT_NOEXCEPT'],['../classentt_1_1Prototype.html#a4069701eaf29716ed9bbb404da5f1b59',1,'entt::Prototype::get() ENTT_NOEXCEPT'],['../classentt_1_1Prototype.html#ae52596223d2a61e52c41979b1e76d68f',1,'entt::Prototype::get() const ENTT_NOEXCEPT'],['../classentt_1_1Prototype.html#a35fcf29a4c01caa611cffa9f73cbe535',1,'entt::Prototype::get() ENTT_NOEXCEPT'],['../classentt_1_1Registry.html#a2079fb67093feb86b75e9dede6bb6c4d',1,'entt::Registry::get() const ENTT_NOEXCEPT'],['../classentt_1_1Registry.html#a3c71607135bee449a486c8a5241dc70d',1,'entt::Registry::get() ENTT_NOEXCEPT'],['../classentt_1_1Registry.html#aa40aa6a87415b2e88c67b8b9f895bfe8',1,'entt::Registry::get(const entity_type entity) const ENTT_NOEXCEPT'],['../classentt_1_1Registry.html#aefa861cd4cd2750ddb43f587fc756531',1,'entt::Registry::get(const entity_type entity) ENTT_NOEXCEPT'],['../classentt_1_1Registry.html#a19e0832f4aceb58f1be1e7540313cec0',1,'entt::Registry::get(const entity_type entity) const ENTT_NOEXCEPT'],['../classentt_1_1Registry.html#a73f3a68af4e73a74a273cca9ceab68a2',1,'entt::Registry::get(const entity_type entity) ENTT_NOEXCEPT'],['../classentt_1_1SparseSet_3_01Entity_01_4.html#aa7893474e3b47da7c2568a0dc4ab4bcf',1,'entt::SparseSet< Entity >::get()'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#a00ef6f3c6da43a1ef864a5252bc9b0a6',1,'entt::SparseSet< Entity, Type >::get(const entity_type entity) const ENTT_NOEXCEPT'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#ab0a6f42129ec08ab607545712e67ce92',1,'entt::SparseSet< Entity, Type >::get(const entity_type entity) ENTT_NOEXCEPT'],['../classentt_1_1PersistentView.html#a51452939486c5e98036b60838f69a32d',1,'entt::PersistentView::get(const entity_type entity) const ENTT_NOEXCEPT'],['../classentt_1_1PersistentView.html#a0a088e6e40be777f9834c1c3fc6d1b15',1,'entt::PersistentView::get(const entity_type entity) ENTT_NOEXCEPT'],['../classentt_1_1PersistentView.html#af6931b058d6009776cc19082eb9a512f',1,'entt::PersistentView::get(const entity_type entity) const ENTT_NOEXCEPT'],['../classentt_1_1PersistentView.html#ad2e8b8cf33831f8ea2caf1bd9a0474b6',1,'entt::PersistentView::get(const entity_type entity) ENTT_NOEXCEPT'],['../classentt_1_1View.html#a8f2e5fc95bb71c698b8ce61b9b4a8a5e',1,'entt::View::get(const entity_type entity) const ENTT_NOEXCEPT'],['../classentt_1_1View.html#ade86403331b51e25fae9238dd8997de0',1,'entt::View::get(const entity_type entity) ENTT_NOEXCEPT'],['../classentt_1_1View.html#a9fb10d57d05afa48c0f25ea0b475c81f',1,'entt::View::get(const entity_type entity) const ENTT_NOEXCEPT'],['../classentt_1_1View.html#ac5b199f031c48da2393eb56fea35b83e',1,'entt::View::get(const entity_type entity) ENTT_NOEXCEPT'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a51d497700a0322a130022eea97643d0f',1,'entt::View< Entity, Component >::get(const entity_type entity) const ENTT_NOEXCEPT'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a269fac4009da89c9743202b16dcd6d87',1,'entt::View< Entity, Component >::get(const entity_type entity) ENTT_NOEXCEPT'],['../structentt_1_1ServiceLocator.html#a87a0d27f2ce4ac8a94229e32853503ca',1,'entt::ServiceLocator::get()'],['../classentt_1_1ResourceHandle.html#a32e791c4556d040273643ca5f42755a9',1,'entt::ResourceHandle::get()']]] ]; diff --git a/search/functions_9.js b/search/functions_9.js index cb2ea0b8a..3f4b3de52 100644 --- a/search/functions_9.js +++ b/search/functions_9.js @@ -1,5 +1,5 @@ var searchData= [ ['map',['map',['../classentt_1_1ContinuousLoader.html#a63d6f733d8651a19b7ea882f3615455c',1,'entt::ContinuousLoader']]], - ['move',['move',['../classentt_1_1Registry.html#ae3592a627bf35b12d51ddd0876ca6896',1,'entt::Registry']]] + ['move',['move',['../classentt_1_1Registry.html#a459073e0dfdb4f21519792717f688173',1,'entt::Registry']]] ]; diff --git a/search/functions_a.js b/search/functions_a.js index 8033f888b..150b65aab 100644 --- a/search/functions_a.js +++ b/search/functions_a.js @@ -6,12 +6,14 @@ var searchData= ['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#a9a7a40458a3999618dd95d70de024331',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()()'],['../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_1Actor.html#af65a5bd2973d27a9adb1a62b746111fe',1,'entt::Actor::operator=(const Actor &)=default'],['../structentt_1_1Actor.html#adbb2c4045a701b76d5fd514ec9221c02',1,'entt::Actor::operator=(Actor &&)=default'],['../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']]], + ['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']]], ['operator_3d_3d',['operator==',['../classentt_1_1HashedString.html#aa5ca9b72d2fa65f2a4796a4ffae00c11',1,'entt::HashedString::operator==()'],['../classentt_1_1Delegate_3_01Ret_07Args_8_8_8_08_4.html#a7fd87003864d2a56baa7d2c8a9317509',1,'entt::Delegate< Ret(Args...)>::operator==()'],['../classentt_1_1SigH_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4.html#acd0e64abe3b6d879a27ced38fe50aa4b',1,'entt::SigH< Ret(Args...), Collector >::operator==()']]], + ['operator_5b_5d',['operator[]',['../classentt_1_1SparseSet_3_01Entity_01_4.html#a2de3b3dc887e30616c37dd1dbc3de46b',1,'entt::SparseSet< Entity >::operator[]()'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#a073eb76e982c1031ef0b69118764faab',1,'entt::SparseSet< Entity, Type >::operator[](const size_type pos) const ENTT_NOEXCEPT'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#a6cd7bd35b86f34191bbfe73ff922b91e',1,'entt::SparseSet< Entity, Type >::operator[](const size_type pos) ENTT_NOEXCEPT'],['../classentt_1_1PersistentView.html#a7edc6f5cbd49d978469d9384b9aca6b3',1,'entt::PersistentView::operator[]()'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a6094dd00422b07f0a9523699b9bf77aa',1,'entt::View< Entity, Component >::operator[]()'],['../classentt_1_1RawView.html#a6a8855ebc61f5ea5f4c676173e92cfcc',1,'entt::RawView::operator[](const size_type pos) const ENTT_NOEXCEPT'],['../classentt_1_1RawView.html#ac85aa3a824640eeeb45f9d1eaaaeea8d',1,'entt::RawView::operator[](const size_type pos) ENTT_NOEXCEPT']]], ['orphan',['orphan',['../classentt_1_1Registry.html#a3b4a5341ac0ef79fd2477753e857a9cb',1,'entt::Registry']]], ['orphans',['orphans',['../classentt_1_1Registry.html#ada2900e50f66573c14821baac03bbd68',1,'entt::Registry::orphans()'],['../classentt_1_1SnapshotLoader.html#a70e3af34bfacf921a2579b1d0055ceca',1,'entt::SnapshotLoader::orphans()'],['../classentt_1_1ContinuousLoader.html#ad1f0c307283afc23e11460c9ca2037c0',1,'entt::ContinuousLoader::orphans()']]] ]; diff --git a/search/functions_b.js b/search/functions_b.js index 686c18499..9a2306819 100644 --- a/search/functions_b.js +++ b/search/functions_b.js @@ -4,6 +4,6 @@ var searchData= ['paused',['paused',['../classentt_1_1Process.html#a3e320da0927d9ac83dc829d0aee8a310',1,'entt::Process']]], ['prepare',['prepare',['../classentt_1_1Registry.html#ac05c9ccc5fe57df386d8104578fc9675',1,'entt::Registry']]], ['processadaptor',['ProcessAdaptor',['../structentt_1_1ProcessAdaptor.html#a16a0964a81c537fe16b937696e47358b',1,'entt::ProcessAdaptor']]], - ['prototype',['Prototype',['../classentt_1_1Prototype.html#aa6033be234aad4d287d740c40db17fec',1,'entt::Prototype']]], + ['prototype',['Prototype',['../classentt_1_1Prototype.html#aa6033be234aad4d287d740c40db17fec',1,'entt::Prototype::Prototype(Registry< Entity > &registry)'],['../classentt_1_1Prototype.html#a6f3d7431f85160da0e255b279c4b5291',1,'entt::Prototype::Prototype(const Prototype &)=delete'],['../classentt_1_1Prototype.html#ad4900c4a27f506b5d2b9db54aba9d224',1,'entt::Prototype::Prototype(Prototype &&other)']]], ['publish',['publish',['../classentt_1_1Emitter.html#ab5141fd9793f53ef83af47c8c8a74b0e',1,'entt::Emitter::publish()'],['../classentt_1_1SigH_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4.html#a5d3aaec10dba146d75672e3dc81a4274',1,'entt::SigH< Ret(Args...), Collector >::publish()']]] ]; diff --git a/search/functions_c.js b/search/functions_c.js index f606bdcab..3076e9f45 100644 --- a/search/functions_c.js +++ b/search/functions_c.js @@ -12,5 +12,5 @@ var searchData= ['resourcecache',['ResourceCache',['../classentt_1_1ResourceCache.html#aaeb4613b842a5d0861585e024af0a41d',1,'entt::ResourceCache::ResourceCache()=default'],['../classentt_1_1ResourceCache.html#a4dbd37c3c1a703b684b6122a59a0b3a7',1,'entt::ResourceCache::ResourceCache(const ResourceCache &) ENTT_NOEXCEPT=delete'],['../classentt_1_1ResourceCache.html#a86dde6d7190adbb13d8472424f6e8bca',1,'entt::ResourceCache::ResourceCache(ResourceCache &&) ENTT_NOEXCEPT=default']]], ['resourcehandle',['ResourceHandle',['../classentt_1_1ResourceHandle.html#a7b267f802e92b57dcc750f824fd5e3df',1,'entt::ResourceHandle::ResourceHandle(const ResourceHandle &) ENTT_NOEXCEPT=default'],['../classentt_1_1ResourceHandle.html#a4d5c929ea7f0bd8860d7188aa6fb76a8',1,'entt::ResourceHandle::ResourceHandle(ResourceHandle &&) ENTT_NOEXCEPT=default']]], ['respect',['respect',['../classentt_1_1SparseSet_3_01Entity_01_4.html#a17422401f952b58be5113ff88e302c0e',1,'entt::SparseSet< Entity >::respect()'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#a605545f8f99a7bb1f92d1dfc3ed438f3',1,'entt::SparseSet< Entity, Type >::respect()']]], - ['restore',['restore',['../classentt_1_1Registry.html#a925e91c4f1904d5104a0c5e9e9f70223',1,'entt::Registry']]] + ['restore',['restore',['../classentt_1_1Registry.html#a37b755b43c7067658d2b4129baa403cf',1,'entt::Registry']]] ]; diff --git a/search/functions_d.js b/search/functions_d.js index 9a969551d..734821b54 100644 --- a/search/functions_d.js +++ b/search/functions_d.js @@ -4,12 +4,12 @@ var searchData= ['servicelocator',['ServiceLocator',['../structentt_1_1ServiceLocator.html#a9806fa1d96f6edfb5b946b11acabc0da',1,'entt::ServiceLocator']]], ['set',['set',['../classentt_1_1Prototype.html#abf665ce59c8f43c4eff3ce77a21c5cfb',1,'entt::Prototype::set()'],['../structentt_1_1ServiceLocator.html#abf8d8b8d70ed082d54516def7500ec5c',1,'entt::ServiceLocator::set(Args &&... args)'],['../structentt_1_1ServiceLocator.html#ad913de8d4a2dcf39b925773e42cbfff5',1,'entt::ServiceLocator::set(std::shared_ptr< Service > ptr)']]], ['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#aa525ade53e40ebc5fbee9c8704d555ce',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_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_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#a69bdf0c5645f2049e8dee9e0c4de53ca',1,'entt::Registry::snapshot()']]], + ['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']]], ['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#af97db8232b2b26604adb5f10ded70f11',1,'entt::Registry::sort(Compare compare, Sort sort=Sort{})'],['../classentt_1_1Registry.html#aa3abb830a7ba342266b62ff1a2965754',1,'entt::Registry::sort()'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#a0bb1bb7e7660c279558e94efd917b7db',1,'entt::SparseSet< Entity, Type >::sort()'],['../classentt_1_1PersistentView.html#accde3d4b4a904e79c832f6b05f324b05',1,'entt::PersistentView::sort()']]], + ['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']]], ['succeed',['succeed',['../classentt_1_1Process.html#ae90a29bf2afabf6a14aec0e1d3809a0f',1,'entt::Process']]], - ['swap',['swap',['../classentt_1_1SparseSet_3_01Entity_01_4.html#a271e5e6736388ca8bf350187da2a0d8f',1,'entt::SparseSet< Entity >']]] + ['swap',['swap',['../classentt_1_1SparseSet_3_01Entity_01_4.html#ace9db01fbfd9f1b8afa4a6f43d42390e',1,'entt::SparseSet< Entity >']]] ]; diff --git a/search/related_1.js b/search/related_1.js index 31182a5c4..0a3b45193 100644 --- a/search/related_1.js +++ b/search/related_1.js @@ -1,5 +1,5 @@ var searchData= [ - ['registry_3c_20entity_20_3e',['Registry< Entity >',['../classentt_1_1Snapshot.html#a200646cfe88496da691aab5f61c0fa69',1,'entt::Snapshot::Registry< Entity >()'],['../classentt_1_1SnapshotLoader.html#a200646cfe88496da691aab5f61c0fa69',1,'entt::SnapshotLoader::Registry< Entity >()'],['../classentt_1_1PersistentView.html#a200646cfe88496da691aab5f61c0fa69',1,'entt::PersistentView::Registry< Entity >()'],['../classentt_1_1View.html#a200646cfe88496da691aab5f61c0fa69',1,'entt::View::Registry< Entity >()'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a200646cfe88496da691aab5f61c0fa69',1,'entt::View< Entity, Component >::Registry< Entity >()'],['../classentt_1_1RawView.html#a200646cfe88496da691aab5f61c0fa69',1,'entt::RawView::Registry< Entity >()']]], + ['registry_3c_20entity_20_3e',['Registry< Entity >',['../classentt_1_1Snapshot.html#a200646cfe88496da691aab5f61c0fa69',1,'entt::Snapshot::Registry< Entity >()'],['../classentt_1_1SnapshotLoader.html#a200646cfe88496da691aab5f61c0fa69',1,'entt::SnapshotLoader::Registry< Entity >()'],['../classentt_1_1PersistentView.html#a200646cfe88496da691aab5f61c0fa69',1,'entt::PersistentView::Registry< Entity >()'],['../classentt_1_1View.html#a200646cfe88496da691aab5f61c0fa69',1,'entt::View::Registry< Entity >()'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a200646cfe88496da691aab5f61c0fa69',1,'entt::View< Entity, Component >::Registry< Entity >()'],['../classentt_1_1RawView.html#a200646cfe88496da691aab5f61c0fa69',1,'entt::RawView::Registry< Entity >()'],['../classentt_1_1RuntimeView.html#a200646cfe88496da691aab5f61c0fa69',1,'entt::RuntimeView::Registry< Entity >()']]], ['resourcecache_3c_20resource_20_3e',['ResourceCache< Resource >',['../classentt_1_1ResourceHandle.html#a302c9d1bd54cf8e7e958d5e505773b23',1,'entt::ResourceHandle::ResourceCache< Resource >()'],['../classentt_1_1ResourceLoader.html#a302c9d1bd54cf8e7e958d5e505773b23',1,'entt::ResourceLoader::ResourceCache< Resource >()']]] ]; diff --git a/search/searchdata.js b/search/searchdata.js index 84ab42dc9..3aeb28f67 100644 --- a/search/searchdata.js +++ b/search/searchdata.js @@ -1,11 +1,11 @@ var indexSectionsWithContent = { - 0: "abcdefghilmoprstuv~", - 1: "abcdefhiprstv", + 0: "abcdefghilmnoprstuv~", + 1: "abcdefhimprstv", 2: "e", 3: "abcdefghlmoprstuv~", - 4: "eiv", - 5: "cdefhiloprstv", + 4: "env", + 5: "cdefhilorstv", 6: "ers", 7: "e" }; diff --git a/search/typedefs_0.js b/search/typedefs_0.js index 4bb0fa174..91753c24d 100644 --- a/search/typedefs_0.js +++ b/search/typedefs_0.js @@ -2,5 +2,5 @@ var searchData= [ ['collector_5ftype',['collector_type',['../classentt_1_1SigH_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4.html#ad0e4e34e41daec83437b1c607855079a',1,'entt::SigH< Ret(Args...), Collector >']]], ['component_5ftype',['component_type',['../classentt_1_1Registry.html#aefd07a0cdff88ebf1e35e531d58c3077',1,'entt::Registry']]], - ['const_5fiterator_5ftype',['const_iterator_type',['../classentt_1_1SparseSet_3_01Entity_01_4.html#aba42055f0c8a43cae63d443a17f6a5e2',1,'entt::SparseSet< Entity >::const_iterator_type()'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#a947d3fd0440167f469331a31b1d8d782',1,'entt::SparseSet< Entity, Type >::const_iterator_type()'],['../classentt_1_1PersistentView.html#a260bd2740fb90caf984ce62c26bb887b',1,'entt::PersistentView::const_iterator_type()'],['../classentt_1_1View.html#a81b76e0389ffeb60195a3391c4c5ce3a',1,'entt::View::const_iterator_type()'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a79316bcf7c15b52712689653fff419c3',1,'entt::View< Entity, Component >::const_iterator_type()'],['../classentt_1_1RawView.html#a5fa9cd28fb18ccfe01fd0eb3ea6e3dc7',1,'entt::RawView::const_iterator_type()']]] + ['const_5fiterator_5ftype',['const_iterator_type',['../classentt_1_1SparseSet_3_01Entity_01_4.html#aba42055f0c8a43cae63d443a17f6a5e2',1,'entt::SparseSet< Entity >::const_iterator_type()'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#a947d3fd0440167f469331a31b1d8d782',1,'entt::SparseSet< Entity, Type >::const_iterator_type()'],['../classentt_1_1PersistentView.html#a260bd2740fb90caf984ce62c26bb887b',1,'entt::PersistentView::const_iterator_type()'],['../classentt_1_1View.html#a81b76e0389ffeb60195a3391c4c5ce3a',1,'entt::View::const_iterator_type()'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a79316bcf7c15b52712689653fff419c3',1,'entt::View< Entity, Component >::const_iterator_type()'],['../classentt_1_1RawView.html#a5fa9cd28fb18ccfe01fd0eb3ea6e3dc7',1,'entt::RawView::const_iterator_type()'],['../classentt_1_1RuntimeView.html#acf976983924a5e0194a19a9b98fdc249',1,'entt::RuntimeView::const_iterator_type()']]] ]; diff --git a/search/typedefs_1.js b/search/typedefs_1.js index addd92a4f..cd708185d 100644 --- a/search/typedefs_1.js +++ b/search/typedefs_1.js @@ -1,7 +1,8 @@ var searchData= [ ['defaultactor',['DefaultActor',['../namespaceentt.html#a0790fdd772249d8b22f1cf2d5e2403d4',1,'entt']]], - ['defaultprototype',['DefaultPrototype',['../namespaceentt.html#a0d57efa94559b7bae0129ca483ae8927',1,'entt']]], + ['defaultprototype',['DefaultPrototype',['../namespaceentt.html#a94d8a4552b7bd5a3543c2ffc6eaf878c',1,'entt']]], ['defaultregistry',['DefaultRegistry',['../namespaceentt.html#aa56ef01a9c62f21d68dd60f005296b23',1,'entt']]], - ['delta_5ftype',['delta_type',['../classentt_1_1Process.html#aaa304f69a0344fffd3a53daa922284ad',1,'entt::Process']]] + ['delta_5ftype',['delta_type',['../classentt_1_1Process.html#aaa304f69a0344fffd3a53daa922284ad',1,'entt::Process']]], + ['difference_5ftype',['difference_type',['../structentt_1_1entt__traits_3_01std_1_1uint16__t_01_4.html#ac16a602de26d43d316b497cb11b7c6b2',1,'entt::entt_traits< std::uint16_t >::difference_type()'],['../structentt_1_1entt__traits_3_01std_1_1uint32__t_01_4.html#a9809b457e16f4a071a91530b23c930d6',1,'entt::entt_traits< std::uint32_t >::difference_type()'],['../structentt_1_1entt__traits_3_01std_1_1uint64__t_01_4.html#afba2f77f80b0bf89a208f6876ab67271',1,'entt::entt_traits< std::uint64_t >::difference_type()']]] ]; diff --git a/search/typedefs_2.js b/search/typedefs_2.js index e766c11d9..285b738a5 100644 --- a/search/typedefs_2.js +++ b/search/typedefs_2.js @@ -1,4 +1,4 @@ var searchData= [ - ['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()']]] + ['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()']]] ]; diff --git a/search/typedefs_5.js b/search/typedefs_5.js index 696673e24..35223a241 100644 --- a/search/typedefs_5.js +++ b/search/typedefs_5.js @@ -1,5 +1,6 @@ var searchData= [ + ['identifier_5ftype',['identifier_type',['../classentt_1_1Identifier.html#a80c4fd9773928949e788790fac671169',1,'entt::Identifier']]], ['instance_5ftype',['instance_type',['../classentt_1_1SigH_3_01Ret_07Args_8_8_8_08_00_01Collector_01_4.html#aad306ac41adf5562740f5528bed80014',1,'entt::SigH< Ret(Args...), Collector >']]], - ['iterator_5ftype',['iterator_type',['../classentt_1_1SparseSet_3_01Entity_01_4.html#a1ad77aed1e49af60b61044c996969b9a',1,'entt::SparseSet< Entity >::iterator_type()'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#a7ff4726f5e0ae6698cb8e3f039289b52',1,'entt::SparseSet< Entity, Type >::iterator_type()'],['../classentt_1_1PersistentView.html#ae563ed31a62fd9f33f93767f0ecdfff5',1,'entt::PersistentView::iterator_type()'],['../classentt_1_1View.html#a738fb04a466b1f858a1eb5d7bc8fd668',1,'entt::View::iterator_type()'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a791a1288db896fda8e77acad396aa513',1,'entt::View< Entity, Component >::iterator_type()'],['../classentt_1_1RawView.html#ab34740dea79327742888e84ba5c14328',1,'entt::RawView::iterator_type()']]] + ['iterator_5ftype',['iterator_type',['../classentt_1_1SparseSet_3_01Entity_01_4.html#a1ad77aed1e49af60b61044c996969b9a',1,'entt::SparseSet< Entity >::iterator_type()'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#a7ff4726f5e0ae6698cb8e3f039289b52',1,'entt::SparseSet< Entity, Type >::iterator_type()'],['../classentt_1_1PersistentView.html#ae563ed31a62fd9f33f93767f0ecdfff5',1,'entt::PersistentView::iterator_type()'],['../classentt_1_1View.html#a738fb04a466b1f858a1eb5d7bc8fd668',1,'entt::View::iterator_type()'],['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a791a1288db896fda8e77acad396aa513',1,'entt::View< Entity, Component >::iterator_type()'],['../classentt_1_1RawView.html#ab34740dea79327742888e84ba5c14328',1,'entt::RawView::iterator_type()'],['../classentt_1_1RuntimeView.html#a59c6645fb86e079986d04887aa7c74e1',1,'entt::RuntimeView::iterator_type()']]] ]; diff --git a/search/typedefs_8.js b/search/typedefs_8.js index a145aa69c..df5c8744d 100644 --- a/search/typedefs_8.js +++ b/search/typedefs_8.js @@ -1,4 +1,6 @@ var searchData= [ - ['pos_5ftype',['pos_type',['../classentt_1_1SparseSet_3_01Entity_01_4.html#a20c218a69cf339371251ffa5580d7aa0',1,'entt::SparseSet< Entity >::pos_type()'],['../classentt_1_1SparseSet_3_01Entity_00_01Type_01_4.html#ad161a395ca3979154a333520662c7737',1,'entt::SparseSet< Entity, Type >::pos_type()']]] + ['raw_5ftype',['raw_type',['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a8bdfb1fbdd4340131be9c70bf02671b5',1,'entt::View< Entity, Component >::raw_type()'],['../classentt_1_1RawView.html#a6a6e2cd0387a63e153a18bd60a1283a3',1,'entt::RawView::raw_type()']]], + ['registry_5ftype',['registry_type',['../structentt_1_1Actor.html#a59ce601affb52396d2cacdc3ffd14928',1,'entt::Actor::registry_type()'],['../classentt_1_1Prototype.html#a8e4a91009c1cbb0bfaadf4e95178eaec',1,'entt::Prototype::registry_type()']]], + ['resource_5ftype',['resource_type',['../classentt_1_1ResourceCache.html#a4936da93a62827d8c5fc04ac444e5456',1,'entt::ResourceCache']]] ]; diff --git a/search/typedefs_9.js b/search/typedefs_9.js index df5c8744d..848e40efc 100644 --- a/search/typedefs_9.js +++ b/search/typedefs_9.js @@ -1,6 +1,6 @@ var searchData= [ - ['raw_5ftype',['raw_type',['../classentt_1_1View_3_01Entity_00_01Component_01_4.html#a8bdfb1fbdd4340131be9c70bf02671b5',1,'entt::View< Entity, Component >::raw_type()'],['../classentt_1_1RawView.html#a6a6e2cd0387a63e153a18bd60a1283a3',1,'entt::RawView::raw_type()']]], - ['registry_5ftype',['registry_type',['../structentt_1_1Actor.html#a59ce601affb52396d2cacdc3ffd14928',1,'entt::Actor::registry_type()'],['../classentt_1_1Prototype.html#a8e4a91009c1cbb0bfaadf4e95178eaec',1,'entt::Prototype::registry_type()']]], - ['resource_5ftype',['resource_type',['../classentt_1_1ResourceCache.html#a4936da93a62827d8c5fc04ac444e5456',1,'entt::ResourceCache']]] + ['service_5ftype',['service_type',['../structentt_1_1ServiceLocator.html#a0631b136adf579365fb444bc5e8f1416',1,'entt::ServiceLocator']]], + ['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_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()']]] ]; diff --git a/search/typedefs_a.js b/search/typedefs_a.js index a730caa1b..8616bb777 100644 --- a/search/typedefs_a.js +++ b/search/typedefs_a.js @@ -1,6 +1,4 @@ var searchData= [ - ['service_5ftype',['service_type',['../structentt_1_1ServiceLocator.html#a0631b136adf579365fb444bc5e8f1416',1,'entt::ServiceLocator']]], - ['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_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_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()']]] + ['tag_5ftype',['tag_type',['../classentt_1_1Registry.html#a357cfdc1b3c5abc7a36e8eddbd6ce5c7',1,'entt::Registry']]] ]; diff --git a/search/typedefs_b.js b/search/typedefs_b.js index 8616bb777..b8dd61089 100644 --- a/search/typedefs_b.js +++ b/search/typedefs_b.js @@ -1,4 +1,4 @@ var searchData= [ - ['tag_5ftype',['tag_type',['../classentt_1_1Registry.html#a357cfdc1b3c5abc7a36e8eddbd6ce5c7',1,'entt::Registry']]] + ['version_5ftype',['version_type',['../structentt_1_1entt__traits_3_01std_1_1uint16__t_01_4.html#ab37d10c3be3d59159a63c0bd1e9e2924',1,'entt::entt_traits< std::uint16_t >::version_type()'],['../structentt_1_1entt__traits_3_01std_1_1uint32__t_01_4.html#aee59dc7455ea0be015e699c3e46a22d1',1,'entt::entt_traits< std::uint32_t >::version_type()'],['../structentt_1_1entt__traits_3_01std_1_1uint64__t_01_4.html#aeac4d9172940a9dec0682860ac176725',1,'entt::entt_traits< std::uint64_t >::version_type()'],['../classentt_1_1Registry.html#a82c8996277034df5e72b5f30a70ebb2d',1,'entt::Registry::version_type()']]] ]; diff --git a/search/typedefs_c.js b/search/typedefs_c.js deleted file mode 100644 index b8dd61089..000000000 --- a/search/typedefs_c.js +++ /dev/null @@ -1,4 +0,0 @@ -var searchData= -[ - ['version_5ftype',['version_type',['../structentt_1_1entt__traits_3_01std_1_1uint16__t_01_4.html#ab37d10c3be3d59159a63c0bd1e9e2924',1,'entt::entt_traits< std::uint16_t >::version_type()'],['../structentt_1_1entt__traits_3_01std_1_1uint32__t_01_4.html#aee59dc7455ea0be015e699c3e46a22d1',1,'entt::entt_traits< std::uint32_t >::version_type()'],['../structentt_1_1entt__traits_3_01std_1_1uint64__t_01_4.html#aeac4d9172940a9dec0682860ac176725',1,'entt::entt_traits< std::uint64_t >::version_type()'],['../classentt_1_1Registry.html#a82c8996277034df5e72b5f30a70ebb2d',1,'entt::Registry::version_type()']]] -]; diff --git a/search/variables_1.js b/search/variables_1.js index 1853ddac5..ae2385a1f 100644 --- a/search/variables_1.js +++ b/search/variables_1.js @@ -1,4 +1,4 @@ var searchData= [ - ['ident',['ident',['../namespaceentt.html#a02c0c4d37a2cdf573029814c1903de3c',1,'entt']]] + ['null',['null',['../namespaceentt.html#a588326af8f6f902a6c0b57d3f9fc6c17',1,'entt']]] ]; diff --git a/sigh_8hpp_source.html b/sigh_8hpp_source.html index 2a568baec..2a5659399 100644 --- a/sigh_8hpp_source.html +++ b/sigh_8hpp_source.html @@ -67,7 +67,7 @@ $(function() {
    sigh.hpp
    -
    1 #ifndef ENTT_SIGNAL_SIGH_HPP
    2 #define ENTT_SIGNAL_SIGH_HPP
    3 
    4 
    5 #include <algorithm>
    6 #include <utility>
    7 #include <vector>
    8 #include "../config/config.h"
    9 
    10 
    11 namespace entt {
    12 
    13 
    14 namespace internal {
    15 
    16 
    23 template<typename, typename>
    24 struct Invoker;
    25 
    26 
    27 template<typename Ret, typename... Args, typename Collector>
    28 struct Invoker<Ret(Args...), Collector> {
    29  using proto_type = Ret(*)(void *, Args...);
    30  using call_type = std::pair<void *, proto_type>;
    31 
    32  virtual ~Invoker() = default;
    33 
    34  bool invoke(Collector &collector, proto_type proto, void *instance, Args... args) const {
    35  return collector(proto(instance, args...));
    36  }
    37 };
    38 
    39 
    40 template<typename... Args, typename Collector>
    41 struct Invoker<void(Args...), Collector> {
    42  using proto_type = void(*)(void *, Args...);
    43  using call_type = std::pair<void *, proto_type>;
    44 
    45  virtual ~Invoker() = default;
    46 
    47  bool invoke(Collector &, proto_type proto, void *instance, Args... args) const {
    48  return (proto(instance, args...), true);
    49  }
    50 };
    51 
    52 
    53 template<typename Ret>
    54 struct NullCollector final {
    55  using result_type = Ret;
    56  bool operator()(result_type) const ENTT_NOEXCEPT { return true; }
    57 };
    58 
    59 
    60 template<>
    61 struct NullCollector<void> final {
    62  using result_type = void;
    63  bool operator()() const ENTT_NOEXCEPT { return true; }
    64 };
    65 
    66 
    67 template<typename>
    68 struct DefaultCollector;
    69 
    70 
    71 template<typename Ret, typename... Args>
    72 struct DefaultCollector<Ret(Args...)> final {
    73  using collector_type = NullCollector<Ret>;
    74 };
    75 
    76 
    77 template<typename Function>
    78 using DefaultCollectorType = typename DefaultCollector<Function>::collector_type;
    79 
    80 
    87 }
    88 
    89 
    98 template<typename Function>
    99 class Sink;
    100 
    101 
    111 template<typename Function, typename Collector = internal::DefaultCollectorType<Function>>
    112 class SigH;
    113 
    114 
    129 template<typename Ret, typename... Args>
    130 class Sink<Ret(Args...)> final {
    132  template<typename, typename>
    133  friend class SigH;
    134 
    135  using proto_type = Ret(*)(void *, Args...);
    136  using call_type = std::pair<void *, proto_type>;
    137 
    138  template<Ret(*Function)(Args...)>
    139  static Ret proto(void *, Args... args) {
    140  return (Function)(args...);
    141  }
    142 
    143  template<typename Class, Ret(Class:: *Member)(Args... args)>
    144  static Ret proto(void *instance, Args... args) {
    145  return (static_cast<Class *>(instance)->*Member)(args...);
    146  }
    147 
    148  Sink(std::vector<call_type> &calls)
    149  : calls{calls}
    150  {}
    151 
    152 public:
    161  template<Ret(*Function)(Args...)>
    162  void connect() {
    163  disconnect<Function>();
    164  calls.emplace_back(nullptr, &proto<Function>);
    165  }
    166 
    180  template <typename Class, Ret(Class:: *Member)(Args...) = &Class::receive>
    181  void connect(Class *instance) {
    182  disconnect<Class, Member>(instance);
    183  calls.emplace_back(instance, &proto<Class, Member>);
    184  }
    185 
    190  template<Ret(*Function)(Args...)>
    191  void disconnect() {
    192  call_type target{nullptr, &proto<Function>};
    193  calls.erase(std::remove(calls.begin(), calls.end(), std::move(target)), calls.end());
    194  }
    195 
    202  template<typename Class, Ret(Class:: *Member)(Args...)>
    203  void disconnect(Class *instance) {
    204  call_type target{instance, &proto<Class, Member>};
    205  calls.erase(std::remove(calls.begin(), calls.end(), std::move(target)), calls.end());
    206  }
    207 
    213  template<typename Class>
    214  void disconnect(Class *instance) {
    215  auto func = [instance](const call_type &call) { return call.first == instance; };
    216  calls.erase(std::remove_if(calls.begin(), calls.end(), std::move(func)), calls.end());
    217  }
    218 
    222  void disconnect() {
    223  calls.clear();
    224  }
    225 
    226 private:
    227  std::vector<call_type> &calls;
    228 };
    229 
    230 
    254 template<typename Ret, typename... Args, typename Collector>
    255 class SigH<Ret(Args...), Collector> final: private internal::Invoker<Ret(Args...), Collector> {
    256  using call_type = typename internal::Invoker<Ret(Args...), Collector>::call_type;
    257 
    258 public:
    260  using size_type = typename std::vector<call_type>::size_type;
    262  using collector_type = Collector;
    264  using sink_type = Sink<Ret(Args...)>;
    265 
    270  template<typename Class>
    271  using instance_type = Class *;
    272 
    277  size_type size() const ENTT_NOEXCEPT {
    278  return calls.size();
    279  }
    280 
    285  bool empty() const ENTT_NOEXCEPT {
    286  return calls.empty();
    287  }
    288 
    298  sink_type sink() {
    299  return { calls };
    300  }
    301 
    309  void publish(Args... args) const {
    310  for(auto pos = calls.size(); pos; --pos) {
    311  auto &call = calls[pos-1];
    312  call.second(call.first, args...);
    313  }
    314  }
    315 
    321  collector_type collect(Args... args) const {
    322  collector_type collector;
    323 
    324  for(auto &&call: calls) {
    325  if(!this->invoke(collector, call.second, call.first, args...)) {
    326  break;
    327  }
    328  }
    329 
    330  return collector;
    331  }
    332 
    338  friend void swap(SigH &lhs, SigH &rhs) {
    339  using std::swap;
    340  swap(lhs.calls, rhs.calls);
    341  }
    342 
    352  bool operator==(const SigH &other) const ENTT_NOEXCEPT {
    353  return std::equal(calls.cbegin(), calls.cend(), other.calls.cbegin(), other.calls.cend());
    354  }
    355 
    356 private:
    357  std::vector<call_type> calls;
    358 };
    359 
    360 
    373 template<typename Ret, typename... Args>
    374 bool operator!=(const SigH<Ret(Args...)> &lhs, const SigH<Ret(Args...)> &rhs) ENTT_NOEXCEPT {
    375  return !(lhs == rhs);
    376 }
    377 
    378 
    379 }
    380 
    381 
    382 #endif // ENTT_SIGNAL_SIGH_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_SIGNAL_SIGH_HPP
    2 #define ENTT_SIGNAL_SIGH_HPP
    3 
    4 
    5 #include <algorithm>
    6 #include <utility>
    7 #include <vector>
    8 #include "../config/config.h"
    9 
    10 
    11 namespace entt {
    12 
    13 
    14 namespace internal {
    15 
    16 
    23 template<typename, typename>
    24 struct Invoker;
    25 
    26 
    27 template<typename Ret, typename... Args, typename Collector>
    28 struct Invoker<Ret(Args...), Collector> {
    29  using proto_fn_type = Ret(void *, Args...);
    30  using call_type = std::pair<void *, proto_fn_type *>;
    31 
    32  virtual ~Invoker() = default;
    33 
    34  bool invoke(Collector &collector, proto_fn_type *proto, void *instance, Args... args) const {
    35  return collector(proto(instance, args...));
    36  }
    37 };
    38 
    39 
    40 template<typename... Args, typename Collector>
    41 struct Invoker<void(Args...), Collector> {
    42  using proto_fn_type = void(void *, Args...);
    43  using call_type = std::pair<void *, proto_fn_type *>;
    44 
    45  virtual ~Invoker() = default;
    46 
    47  bool invoke(Collector &, proto_fn_type *proto, void *instance, Args... args) const {
    48  return (proto(instance, args...), true);
    49  }
    50 };
    51 
    52 
    53 template<typename Ret>
    54 struct NullCollector final {
    55  using result_type = Ret;
    56  bool operator()(result_type) const ENTT_NOEXCEPT { return true; }
    57 };
    58 
    59 
    60 template<>
    61 struct NullCollector<void> final {
    62  using result_type = void;
    63  bool operator()() const ENTT_NOEXCEPT { return true; }
    64 };
    65 
    66 
    67 template<typename>
    68 struct DefaultCollector;
    69 
    70 
    71 template<typename Ret, typename... Args>
    72 struct DefaultCollector<Ret(Args...)> final {
    73  using collector_type = NullCollector<Ret>;
    74 };
    75 
    76 
    77 template<typename Function>
    78 using DefaultCollectorType = typename DefaultCollector<Function>::collector_type;
    79 
    80 
    87 }
    88 
    89 
    98 template<typename Function>
    99 class Sink;
    100 
    101 
    111 template<typename Function, typename Collector = internal::DefaultCollectorType<Function>>
    112 class SigH;
    113 
    114 
    129 template<typename Ret, typename... Args>
    130 class Sink<Ret(Args...)> final {
    132  template<typename, typename>
    133  friend class SigH;
    134 
    135  using proto_fn_type = Ret(void *, Args...);
    136  using call_type = std::pair<void *, proto_fn_type *>;
    137 
    138  template<Ret(*Function)(Args...)>
    139  static Ret proto(void *, Args... args) {
    140  return (Function)(args...);
    141  }
    142 
    143  template<typename Class, Ret(Class:: *Member)(Args... args)>
    144  static Ret proto(void *instance, Args... args) {
    145  return (static_cast<Class *>(instance)->*Member)(args...);
    146  }
    147 
    148  Sink(std::vector<call_type> &calls) ENTT_NOEXCEPT
    149  : calls{calls}
    150  {}
    151 
    152 public:
    161  template<Ret(*Function)(Args...)>
    162  void connect() {
    163  disconnect<Function>();
    164  calls.emplace_back(nullptr, &proto<Function>);
    165  }
    166 
    180  template <typename Class, Ret(Class:: *Member)(Args...) = &Class::receive>
    181  void connect(Class *instance) {
    182  disconnect<Class, Member>(instance);
    183  calls.emplace_back(instance, &proto<Class, Member>);
    184  }
    185 
    190  template<Ret(*Function)(Args...)>
    191  void disconnect() {
    192  call_type target{nullptr, &proto<Function>};
    193  calls.erase(std::remove(calls.begin(), calls.end(), std::move(target)), calls.end());
    194  }
    195 
    202  template<typename Class, Ret(Class:: *Member)(Args...)>
    203  void disconnect(Class *instance) {
    204  call_type target{instance, &proto<Class, Member>};
    205  calls.erase(std::remove(calls.begin(), calls.end(), std::move(target)), calls.end());
    206  }
    207 
    213  template<typename Class>
    214  void disconnect(Class *instance) {
    215  auto func = [instance](const call_type &call) { return call.first == instance; };
    216  calls.erase(std::remove_if(calls.begin(), calls.end(), std::move(func)), calls.end());
    217  }
    218 
    222  void disconnect() {
    223  calls.clear();
    224  }
    225 
    226 private:
    227  std::vector<call_type> &calls;
    228 };
    229 
    230 
    254 template<typename Ret, typename... Args, typename Collector>
    255 class SigH<Ret(Args...), Collector> final: private internal::Invoker<Ret(Args...), Collector> {
    256  using call_type = typename internal::Invoker<Ret(Args...), Collector>::call_type;
    257 
    258 public:
    260  using size_type = typename std::vector<call_type>::size_type;
    262  using collector_type = Collector;
    264  using sink_type = Sink<Ret(Args...)>;
    265 
    270  template<typename Class>
    271  using instance_type = Class *;
    272 
    277  size_type size() const ENTT_NOEXCEPT {
    278  return calls.size();
    279  }
    280 
    285  bool empty() const ENTT_NOEXCEPT {
    286  return calls.empty();
    287  }
    288 
    298  sink_type sink() ENTT_NOEXCEPT {
    299  return { calls };
    300  }
    301 
    309  void publish(Args... args) const {
    310  for(auto pos = calls.size(); pos; --pos) {
    311  auto &call = calls[pos-1];
    312  call.second(call.first, args...);
    313  }
    314  }
    315 
    321  collector_type collect(Args... args) const {
    322  collector_type collector;
    323 
    324  for(auto &&call: calls) {
    325  if(!this->invoke(collector, call.second, call.first, args...)) {
    326  break;
    327  }
    328  }
    329 
    330  return collector;
    331  }
    332 
    338  friend void swap(SigH &lhs, SigH &rhs) {
    339  using std::swap;
    340  swap(lhs.calls, rhs.calls);
    341  }
    342 
    352  bool operator==(const SigH &other) const ENTT_NOEXCEPT {
    353  return std::equal(calls.cbegin(), calls.cend(), other.calls.cbegin(), other.calls.cend());
    354  }
    355 
    356 private:
    357  std::vector<call_type> calls;
    358 };
    359 
    360 
    373 template<typename Ret, typename... Args>
    374 bool operator!=(const SigH<Ret(Args...)> &lhs, const SigH<Ret(Args...)> &rhs) ENTT_NOEXCEPT {
    375  return !(lhs == rhs);
    376 }
    377 
    378 
    379 }
    380 
    381 
    382 #endif // ENTT_SIGNAL_SIGH_HPP
    entt::operator!=
    constexpr bool operator!=(const HashedString &lhs, const HashedString &rhs) ENTT_NOEXCEPT
    Compares two hashed strings.
    Definition: hashed_string.hpp:103
    entt::Sink
    Sink implementation.
    Definition: sigh.hpp:99
    entt::SigH< Ret(Args...), Collector >::instance_type
    Class * instance_type
    Instance type when it comes to connecting member functions.
    Definition: sigh.hpp:271
    entt::SigH< Ret(Args...), Collector >::collector_type
    Collector collector_type
    Collector type.
    Definition: sigh.hpp:262
    @@ -77,6 +77,7 @@ $(function() {
    entt::Sink< Ret(Args...)>::connect
    void connect(Class *instance)
    Connects a member function for a given instance to a signal.
    Definition: sigh.hpp:181
    entt::SigH< Ret(Args...), Collector >::collect
    collector_type collect(Args... args) const
    Collects return values from the listeners.
    Definition: sigh.hpp:321
    entt::SigH< Ret(Args...), Collector >::swap
    friend void swap(SigH &lhs, SigH &rhs)
    Swaps listeners between the two signals.
    Definition: sigh.hpp:338
    +
    entt::SigH< Ret(Args...), Collector >::sink
    sink_type sink() ENTT_NOEXCEPT
    Returns a sink object for the given signal.
    Definition: sigh.hpp:298
    entt::SigH< Ret(Args...), Collector >::empty
    bool empty() const ENTT_NOEXCEPT
    Returns false if at least a listener is connected to the signal.
    Definition: sigh.hpp:285
    entt::SigH< Ret(Args...), Collector >::size_type
    typename std::vector< call_type >::size_type size_type
    Unsigned integer type.
    Definition: sigh.hpp:260
    entt::Sink< Ret(Args...)>::disconnect
    void disconnect()
    Disconnects all the listeners from a signal.
    Definition: sigh.hpp:222
    @@ -84,7 +85,6 @@ $(function() {
    entt::Sink< Ret(Args...)>::connect
    void connect()
    Connects a free function to a signal.
    Definition: sigh.hpp:162
    entt::SigH
    Unmanaged signal handler declaration.
    Definition: sigh.hpp:112
    entt::Sink< Ret(Args...)>::disconnect
    void disconnect(Class *instance)
    Disconnects the given member function from a signal.
    Definition: sigh.hpp:203
    -
    entt::SigH< Ret(Args...), Collector >::sink
    sink_type sink()
    Returns a sink object for the given signal.
    Definition: sigh.hpp:298
    entt::SigH< Ret(Args...), Collector >::size
    size_type size() const ENTT_NOEXCEPT
    Number of listeners connected to the signal.
    Definition: sigh.hpp:277
    entt::Sink< Ret(Args...)>
    Sink implementation.
    Definition: sigh.hpp:130
    entt::SigH< Ret(Args...), Collector >::publish
    void publish(Args... args) const
    Triggers a signal.
    Definition: sigh.hpp:309
    diff --git a/snapshot_8hpp_source.html b/snapshot_8hpp_source.html index 0ca12565f..d7ef2b9fe 100644 --- a/snapshot_8hpp_source.html +++ b/snapshot_8hpp_source.html @@ -67,9 +67,9 @@ $(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.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
    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:39
    +
    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
    entt::SnapshotLoader::tag
    const SnapshotLoader & tag(Archive &archive) const
    Restores tags and assigns them to the right entities.
    Definition: snapshot.hpp:382
    entt::SnapshotLoader::component
    const SnapshotLoader & component(Archive &archive) const
    Restores components and assigns them to the right entities.
    Definition: snapshot.hpp:361
    diff --git a/sparse__set_8hpp_source.html b/sparse__set_8hpp_source.html index 8d7889731..c9bf4994b 100644 --- a/sparse__set_8hpp_source.html +++ b/sparse__set_8hpp_source.html @@ -67,49 +67,53 @@ $(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 
    17 
    18 namespace entt {
    19 
    20 
    27 template<typename...>
    28 class SparseSet;
    29 
    30 
    58 template<typename Entity>
    59 class SparseSet<Entity> {
    60  using traits_type = entt_traits<Entity>;
    61 
    62  struct Iterator final {
    63  using difference_type = std::size_t;
    64  using value_type = Entity;
    65  using pointer = const value_type *;
    66  using reference = value_type;
    67  using iterator_category = std::input_iterator_tag;
    68 
    69  Iterator(pointer direct, std::size_t pos)
    70  : direct{direct}, pos{pos}
    71  {}
    72 
    73  Iterator & operator++() ENTT_NOEXCEPT {
    74  return --pos, *this;
    75  }
    76 
    77  Iterator operator++(int) ENTT_NOEXCEPT {
    78  Iterator orig = *this;
    79  return ++(*this), orig;
    80  }
    81 
    82  Iterator & operator+=(const difference_type value) ENTT_NOEXCEPT {
    83  pos -= value;
    84  return *this;
    85  }
    86 
    87  Iterator operator+(const difference_type value) const ENTT_NOEXCEPT {
    88  return Iterator{direct, pos-value};
    89  }
    90 
    91  bool operator==(const Iterator &other) const ENTT_NOEXCEPT {
    92  return other.pos == pos;
    93  }
    94 
    95  inline bool operator!=(const Iterator &other) const ENTT_NOEXCEPT {
    96  return !(*this == other);
    97  }
    98 
    99  reference operator*() const ENTT_NOEXCEPT {
    100  return direct[pos-1];
    101  }
    102 
    103  private:
    104  pointer direct;
    105  std::size_t pos;
    106  };
    107 
    108  static constexpr auto pending = ~typename traits_type::entity_type{};
    109 
    110 public:
    112  using entity_type = Entity;
    114  using pos_type = entity_type;
    116  using size_type = std::size_t;
    118  using iterator_type = Iterator;
    120  using const_iterator_type = Iterator;
    121 
    123  SparseSet() ENTT_NOEXCEPT = default;
    124 
    126  virtual ~SparseSet() ENTT_NOEXCEPT = default;
    127 
    129  SparseSet(const SparseSet &) = delete;
    131  SparseSet(SparseSet &&) = default;
    132 
    134  SparseSet & operator=(const SparseSet &) = delete;
    136  SparseSet & operator=(SparseSet &&) = default;
    137 
    146  void reserve(const size_type cap) {
    147  direct.reserve(cap);
    148  }
    149 
    160  size_type extent() const ENTT_NOEXCEPT {
    161  return reverse.size();
    162  }
    163 
    174  size_type size() const ENTT_NOEXCEPT {
    175  return direct.size();
    176  }
    177 
    182  bool empty() const ENTT_NOEXCEPT {
    183  return direct.empty();
    184  }
    185 
    201  const entity_type * data() const ENTT_NOEXCEPT {
    202  return direct.data();
    203  }
    204 
    217  const_iterator_type cbegin() const ENTT_NOEXCEPT {
    218  return const_iterator_type{direct.data(), direct.size()};
    219  }
    220 
    233  inline const_iterator_type begin() const ENTT_NOEXCEPT {
    234  return cbegin();
    235  }
    236 
    249  inline iterator_type begin() ENTT_NOEXCEPT {
    250  return cbegin();
    251  }
    252 
    266  const_iterator_type cend() const ENTT_NOEXCEPT {
    267  return const_iterator_type{direct.data(), {}};
    268  }
    269 
    283  inline const_iterator_type end() const ENTT_NOEXCEPT {
    284  return cend();
    285  }
    286 
    300  inline iterator_type end() ENTT_NOEXCEPT {
    301  return cend();
    302  }
    303 
    309  bool has(const entity_type entity) const ENTT_NOEXCEPT {
    310  const auto pos = size_type(entity & traits_type::entity_mask);
    311  // testing against pending permits to avoid accessing the direct vector
    312  return (pos < reverse.size()) && (reverse[pos] != pending);
    313  }
    314 
    332  bool fast(const entity_type entity) const ENTT_NOEXCEPT {
    333  const auto pos = size_type(entity & traits_type::entity_mask);
    334  assert(pos < reverse.size());
    335  // testing against pending permits to avoid accessing the direct vector
    336  return (reverse[pos] != pending);
    337  }
    338 
    351  pos_type get(const entity_type entity) const ENTT_NOEXCEPT {
    352  assert(has(entity));
    353  return reverse[entity & traits_type::entity_mask];
    354  }
    355 
    367  void construct(const entity_type entity) {
    368  assert(!has(entity));
    369  const auto pos = size_type(entity & traits_type::entity_mask);
    370 
    371  if(!(pos < reverse.size())) {
    372  const auto value = pending;
    373  reverse.resize(pos+1, value);
    374  }
    375 
    376  reverse[pos] = pos_type(direct.size());
    377  direct.push_back(entity);
    378  }
    379 
    391  virtual void destroy(const entity_type entity) {
    392  assert(has(entity));
    393  const auto back = direct.back();
    394  auto &candidate = reverse[entity & traits_type::entity_mask];
    395  // swapping isn't required here, we are getting rid of the last element
    396  reverse[back & traits_type::entity_mask] = candidate;
    397  direct[candidate] = back;
    398  candidate = pending;
    399  direct.pop_back();
    400  }
    401 
    417  void swap(const pos_type lhs, const pos_type rhs) ENTT_NOEXCEPT {
    418  assert(lhs < direct.size());
    419  assert(rhs < direct.size());
    420  auto &src = direct[lhs];
    421  auto &dst = direct[rhs];
    422  std::swap(reverse[src & traits_type::entity_mask], reverse[dst & traits_type::entity_mask]);
    423  std::swap(src, dst);
    424  }
    425 
    445  void respect(const SparseSet<Entity> &other) ENTT_NOEXCEPT {
    446  auto from = other.cbegin();
    447  auto to = other.cend();
    448 
    449  pos_type pos = direct.size() - 1;
    450 
    451  while(pos && from != to) {
    452  if(has(*from)) {
    453  if(*from != direct[pos]) {
    454  swap(pos, get(*from));
    455  }
    456 
    457  --pos;
    458  }
    459 
    460  ++from;
    461  }
    462  }
    463 
    467  virtual void reset() {
    468  reverse.clear();
    469  direct.clear();
    470  }
    471 
    472 private:
    473  std::vector<pos_type> reverse;
    474  std::vector<entity_type> direct;
    475 };
    476 
    477 
    500 template<typename Entity, typename Type>
    501 class SparseSet<Entity, Type>: public SparseSet<Entity> {
    502  using underlying_type = SparseSet<Entity>;
    503 
    504  template<bool Const>
    505  struct Iterator final {
    506  using difference_type = std::size_t;
    507  using value_type = std::conditional_t<Const, const Type, Type>;
    508  using pointer = value_type *;
    509  using reference = value_type &;
    510  using iterator_category = std::input_iterator_tag;
    511 
    512  Iterator(pointer instances, std::size_t pos)
    513  : instances{instances}, pos{pos}
    514  {}
    515 
    516  Iterator & operator++() ENTT_NOEXCEPT {
    517  return --pos, *this;
    518  }
    519 
    520  Iterator operator++(int) ENTT_NOEXCEPT {
    521  Iterator orig = *this;
    522  return ++(*this), orig;
    523  }
    524 
    525  Iterator & operator+=(const difference_type value) ENTT_NOEXCEPT {
    526  pos -= value;
    527  return *this;
    528  }
    529 
    530  Iterator operator+(const difference_type value) const ENTT_NOEXCEPT {
    531  return Iterator{instances, pos-value};
    532  }
    533 
    534  bool operator==(const Iterator &other) const ENTT_NOEXCEPT {
    535  return other.pos == pos;
    536  }
    537 
    538  inline bool operator!=(const Iterator &other) const ENTT_NOEXCEPT {
    539  return !(*this == other);
    540  }
    541 
    542  reference operator*() const ENTT_NOEXCEPT {
    543  return instances[pos-1];
    544  }
    545 
    546  pointer operator->() const ENTT_NOEXCEPT {
    547  return (instances+pos-1);
    548  }
    549 
    550  private:
    551  pointer instances;
    552  std::size_t pos;
    553  };
    554 
    555 public:
    557  using object_type = Type;
    559  using entity_type = typename underlying_type::entity_type;
    561  using pos_type = typename underlying_type::pos_type;
    563  using size_type = typename underlying_type::size_type;
    565  using iterator_type = Iterator<false>;
    567  using const_iterator_type = Iterator<true>;
    568 
    570  SparseSet() ENTT_NOEXCEPT = default;
    571 
    573  SparseSet(const SparseSet &) = delete;
    575  SparseSet(SparseSet &&) = default;
    576 
    578  SparseSet & operator=(const SparseSet &) = delete;
    580  SparseSet & operator=(SparseSet &&) = default;
    581 
    590  void reserve(const size_type cap) {
    591  underlying_type::reserve(cap);
    592  instances.reserve(cap);
    593  }
    594 
    610  const object_type * raw() const ENTT_NOEXCEPT {
    611  return instances.data();
    612  }
    613 
    629  object_type * raw() ENTT_NOEXCEPT {
    630  return instances.data();
    631  }
    632 
    645  const_iterator_type cbegin() const ENTT_NOEXCEPT {
    646  return const_iterator_type{instances.data(), instances.size()};
    647  }
    648 
    661  inline const_iterator_type begin() const ENTT_NOEXCEPT {
    662  return cbegin();
    663  }
    664 
    677  iterator_type begin() ENTT_NOEXCEPT {
    678  return iterator_type{instances.data(), instances.size()};
    679  }
    680 
    695  const_iterator_type cend() const ENTT_NOEXCEPT {
    696  return const_iterator_type{instances.data(), {}};
    697  }
    698 
    713  inline const_iterator_type end() const ENTT_NOEXCEPT {
    714  return cend();
    715  }
    716 
    731  iterator_type end() ENTT_NOEXCEPT {
    732  return iterator_type{instances.data(), {}};
    733  }
    734 
    747  const object_type & get(const entity_type entity) const ENTT_NOEXCEPT {
    748  return instances[underlying_type::get(entity)];
    749  }
    750 
    763  inline object_type & get(const entity_type entity) ENTT_NOEXCEPT {
    764  return const_cast<object_type &>(const_cast<const SparseSet *>(this)->get(entity));
    765  }
    766 
    787  template<typename... Args>
    788  std::enable_if_t<std::is_constructible<Type, Args...>::value, object_type &>
    789  construct(const entity_type entity, Args &&... args) {
    790  underlying_type::construct(entity);
    791  instances.emplace_back(std::forward<Args>(args)...);
    792  return instances.back();
    793  }
    794 
    815  template<typename... Args>
    816  std::enable_if_t<!std::is_constructible<Type, Args...>::value, object_type &>
    817  construct(const entity_type entity, Args &&... args) {
    818  underlying_type::construct(entity);
    819  instances.emplace_back(Type{std::forward<Args>(args)...});
    820  return instances.back();
    821  }
    822 
    834  void destroy(const entity_type entity) override {
    835  // swapping isn't required here, we are getting rid of the last element
    836  // however, we must protect ourselves from self assignments (see #37)
    837  auto tmp = std::move(instances.back());
    838  instances[underlying_type::get(entity)] = std::move(tmp);
    839  instances.pop_back();
    840  underlying_type::destroy(entity);
    841  }
    842 
    882  template<typename Compare, typename Sort = StdSort>
    883  void sort(Compare compare, Sort sort = Sort{}) {
    884  std::vector<pos_type> copy(instances.size());
    885  std::iota(copy.begin(), copy.end(), 0);
    886 
    887  sort(copy.begin(), copy.end(), [this, compare = std::move(compare)](const auto lhs, const auto rhs) {
    888  return compare(const_cast<const object_type &>(instances[rhs]), const_cast<const object_type &>(instances[lhs]));
    889  });
    890 
    891  for(pos_type pos = 0, last = copy.size(); pos < last; ++pos) {
    892  auto curr = pos;
    893  auto next = copy[curr];
    894 
    895  while(curr != next) {
    896  const auto lhs = copy[curr];
    897  const auto rhs = copy[next];
    898  std::swap(instances[lhs], instances[rhs]);
    899  underlying_type::swap(lhs, rhs);
    900  copy[curr] = curr;
    901  curr = next;
    902  next = copy[curr];
    903  }
    904  }
    905  }
    906 
    930  void respect(const SparseSet<Entity> &other) ENTT_NOEXCEPT {
    931  auto from = other.cbegin();
    932  auto to = other.cend();
    933 
    934  pos_type pos = underlying_type::size() - 1;
    935  const auto *local = underlying_type::data();
    936 
    937  while(pos && from != to) {
    938  const auto curr = *from;
    939 
    940  if(underlying_type::has(curr)) {
    941  if(curr != *(local + pos)) {
    942  auto candidate = underlying_type::get(curr);
    943  std::swap(instances[pos], instances[candidate]);
    944  underlying_type::swap(pos, candidate);
    945  }
    946 
    947  --pos;
    948  }
    949 
    950  ++from;
    951  }
    952  }
    953 
    957  void reset() override {
    958  underlying_type::reset();
    959  instances.clear();
    960  }
    961 
    962 private:
    963  std::vector<object_type> instances;
    964 };
    965 
    966 
    967 }
    968 
    969 
    970 #endif // ENTT_ENTITY_SPARSE_SET_HPP
    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:645
    -
    entt::SparseSet< Entity >::empty
    bool empty() const ENTT_NOEXCEPT
    Checks whether a sparse set is empty.
    Definition: sparse_set.hpp:182
    -
    entt::SparseSet< Entity, Type >::construct
    std::enable_if_t<!std::is_constructible< Type, Args... >::value, object_type & > construct(const entity_type entity, Args &&... args)
    Assigns an entity to a sparse set and constructs its object.
    Definition: sparse_set.hpp:817
    -
    entt::SparseSet< Entity >::fast
    bool fast(const entity_type entity) const ENTT_NOEXCEPT
    Checks if a sparse set contains an entity (unsafe).
    Definition: sparse_set.hpp:332
    -
    entt::SparseSet< Entity >::reset
    virtual void reset()
    Resets a sparse set.
    Definition: sparse_set.hpp:467
    +
    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
    +
    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
    +
    entt::SparseSet< Entity, Type >::operator[]
    object_type & operator[](const size_type pos) ENTT_NOEXCEPT
    Returns a reference to the element at the given position.
    Definition: sparse_set.hpp:874
    +
    entt::SparseSet< Entity >::empty
    bool empty() const ENTT_NOEXCEPT
    Checks whether a sparse set is empty.
    Definition: sparse_set.hpp:244
    +
    entt::SparseSet< Entity, Type >::construct
    std::enable_if_t<!std::is_constructible< Type, Args... >::value, object_type & > construct(const entity_type entity, Args &&... args)
    Assigns an entity to a sparse set and constructs its object.
    Definition: sparse_set.hpp:960
    +
    entt::SparseSet< Entity >::fast
    bool fast(const entity_type entity) const ENTT_NOEXCEPT
    Checks if a sparse set contains an entity (unsafe).
    Definition: sparse_set.hpp:404
    +
    entt::SparseSet< Entity >::reset
    virtual void reset()
    Resets a sparse set.
    Definition: sparse_set.hpp:539
    entt
    EnTT default namespace.
    Definition: algorithm.hpp:10
    -
    entt::SparseSet< Entity, Type >::raw
    const object_type * raw() const ENTT_NOEXCEPT
    Direct access to the array of objects.
    Definition: sparse_set.hpp:610
    -
    entt::SparseSet< Entity, Type >::reset
    void reset() override
    Resets a sparse set.
    Definition: sparse_set.hpp:957
    -
    entt::SparseSet< Entity, Type >::cend
    const_iterator_type cend() const ENTT_NOEXCEPT
    Returns an iterator to the end.
    Definition: sparse_set.hpp:695
    -
    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:309
    -
    entt::SparseSet< Entity, Type >::sort
    void sort(Compare compare, Sort sort=Sort{})
    Sort components according to the given comparison function.
    Definition: sparse_set.hpp:883
    -
    entt::SparseSet< Entity >::begin
    const_iterator_type begin() const ENTT_NOEXCEPT
    Returns an iterator to the beginning.
    Definition: sparse_set.hpp:233
    -
    entt::SparseSet< Entity, Type >::destroy
    void destroy(const entity_type entity) override
    Removes an entity from a sparse set and destroies its object.
    Definition: sparse_set.hpp:834
    -
    entt::SparseSet< Entity, Type >::begin
    const_iterator_type begin() const ENTT_NOEXCEPT
    Returns an iterator to the beginning.
    Definition: sparse_set.hpp:661
    -
    entt::SparseSet
    Sparse set.
    Definition: sparse_set.hpp:28
    -
    entt::SparseSet< Entity, Type >::construct
    std::enable_if_t< std::is_constructible< Type, Args... >::value, object_type & > construct(const entity_type entity, Args &&... args)
    Assigns an entity to a sparse set and constructs its object.
    Definition: sparse_set.hpp:789
    -
    entt::SparseSet< Entity >::size_type
    std::size_t size_type
    Unsigned integer type.
    Definition: sparse_set.hpp:116
    -
    entt::SparseSet< Entity >::extent
    size_type extent() const ENTT_NOEXCEPT
    Returns the extent of a sparse set.
    Definition: sparse_set.hpp:160
    -
    entt::SparseSet< Entity, Type >::begin
    iterator_type begin() ENTT_NOEXCEPT
    Returns an iterator to the beginning.
    Definition: sparse_set.hpp:677
    -
    entt::SparseSet< Entity, Type >
    Extended sparse set implementation.
    Definition: sparse_set.hpp:501
    -
    entt::SparseSet< Entity >::end
    iterator_type end() ENTT_NOEXCEPT
    Returns an iterator to the end.
    Definition: sparse_set.hpp:300
    -
    entt::SparseSet< Entity, Type >::end
    iterator_type end() ENTT_NOEXCEPT
    Returns an iterator to the end.
    Definition: sparse_set.hpp:731
    -
    entt::SparseSet< Entity >::entity_type
    Entity entity_type
    Underlying entity identifier.
    Definition: sparse_set.hpp:112
    -
    entt::SparseSet< Entity >::iterator_type
    Iterator iterator_type
    Input iterator type.
    Definition: sparse_set.hpp:118
    -
    entt::SparseSet< Entity >
    Basic sparse set implementation.
    Definition: sparse_set.hpp:59
    -
    entt::SparseSet< Entity, Type >::respect
    void respect(const SparseSet< Entity > &other) ENTT_NOEXCEPT
    Sort components according to the order of the entities in another sparse set.
    Definition: sparse_set.hpp:930
    -
    entt::SparseSet< Entity >::const_iterator_type
    Iterator const_iterator_type
    Constant input iterator type.
    Definition: sparse_set.hpp:120
    -
    entt::SparseSet< Entity >::pos_type
    entity_type pos_type
    Entity dependent position type.
    Definition: sparse_set.hpp:114
    -
    entt::SparseSet< Entity, Type >::object_type
    Type object_type
    Type of the objects associated to the entities.
    Definition: sparse_set.hpp:557
    -
    entt::SparseSet< Entity >::size
    size_type size() const ENTT_NOEXCEPT
    Returns the number of elements in a sparse set.
    Definition: sparse_set.hpp:174
    -
    entt::SparseSet< Entity >::cend
    const_iterator_type cend() const ENTT_NOEXCEPT
    Returns an iterator to the end.
    Definition: sparse_set.hpp:266
    -
    entt::SparseSet< Entity, Type >::end
    const_iterator_type end() const ENTT_NOEXCEPT
    Returns an iterator to the end.
    Definition: sparse_set.hpp:713
    -
    entt::SparseSet< Entity >::destroy
    virtual void destroy(const entity_type entity)
    Removes an entity from a sparse set.
    Definition: sparse_set.hpp:391
    -
    entt::SparseSet< Entity, Type >::raw
    object_type * raw() ENTT_NOEXCEPT
    Direct access to the array of objects.
    Definition: sparse_set.hpp:629
    -
    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:445
    -
    entt::SparseSet< Entity >::begin
    iterator_type begin() ENTT_NOEXCEPT
    Returns an iterator to the beginning.
    Definition: sparse_set.hpp:249
    -
    entt::SparseSet< Entity >::data
    const entity_type * data() const ENTT_NOEXCEPT
    Direct access to the internal packed array.
    Definition: sparse_set.hpp:201
    -
    entt::SparseSet< Entity >::cbegin
    const_iterator_type cbegin() const ENTT_NOEXCEPT
    Returns an iterator to the beginning.
    Definition: sparse_set.hpp:217
    -
    entt::SparseSet< Entity >::end
    const_iterator_type end() const ENTT_NOEXCEPT
    Returns an iterator to the end.
    Definition: sparse_set.hpp:283
    -
    entt::SparseSet< Entity >::construct
    void construct(const entity_type entity)
    Assigns an entity to a sparse set.
    Definition: sparse_set.hpp:367
    +
    entt::SparseSet< Entity, Type >::raw
    const object_type * raw() const ENTT_NOEXCEPT
    Direct access to the array of objects.
    Definition: sparse_set.hpp:733
    +
    entt::SparseSet< Entity, Type >::reset
    void reset() override
    Resets a sparse set.
    Definition: sparse_set.hpp:1102
    +
    entt::SparseSet< Entity, Type >::cend
    const_iterator_type cend() const ENTT_NOEXCEPT
    Returns an iterator to the end.
    Definition: sparse_set.hpp:820
    +
    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::SparseSet< Entity >::begin
    const_iterator_type begin() const ENTT_NOEXCEPT
    Returns an iterator to the beginning.
    Definition: sparse_set.hpp:296
    +
    entt::SparseSet< Entity, Type >::destroy
    void destroy(const entity_type entity) override
    Removes an entity from a sparse set and destroies its object.
    Definition: sparse_set.hpp:977
    +
    entt::SparseSet< Entity, Type >::begin
    const_iterator_type begin() const ENTT_NOEXCEPT
    Returns an iterator to the beginning.
    Definition: sparse_set.hpp:785
    +
    entt::SparseSet
    Sparse set.
    Definition: sparse_set.hpp:29
    +
    entt::SparseSet< Entity, Type >::construct
    std::enable_if_t< std::is_constructible< Type, Args... >::value, object_type & > construct(const entity_type entity, Args &&... args)
    Assigns an entity to a sparse set and constructs its object.
    Definition: sparse_set.hpp:932
    +
    entt::null
    constexpr auto null
    Null entity.
    Definition: entity.hpp:81
    +
    entt::SparseSet< Entity >::size_type
    std::size_t size_type
    Unsigned integer type.
    Definition: sparse_set.hpp:169
    +
    entt::SparseSet< Entity >::extent
    size_type extent() const ENTT_NOEXCEPT
    Returns the extent of a sparse set.
    Definition: sparse_set.hpp:222
    +
    entt::SparseSet< Entity, Type >::begin
    iterator_type begin() ENTT_NOEXCEPT
    Returns an iterator to the beginning.
    Definition: sparse_set.hpp:801
    +
    entt::SparseSet< Entity, Type >::sort
    void sort(Compare compare, Sort sort=Sort{}, Args &&... args)
    Sort components according to the given comparison function.
    Definition: sparse_set.hpp:1028
    +
    entt::SparseSet< Entity >::end
    iterator_type end() ENTT_NOEXCEPT
    Returns an iterator to the end.
    Definition: sparse_set.hpp:363
    +
    entt::SparseSet< Entity, Type >::end
    iterator_type end() ENTT_NOEXCEPT
    Returns an iterator to the end.
    Definition: sparse_set.hpp:856
    +
    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::SparseSet< Entity >
    Basic sparse set implementation.
    Definition: sparse_set.hpp:60
    +
    entt::SparseSet< Entity, Type >::respect
    void respect(const SparseSet< Entity > &other) ENTT_NOEXCEPT
    Sort components according to the order of the entities in another sparse set.
    Definition: sparse_set.hpp:1075
    +
    entt::SparseSet< Entity >::const_iterator_type
    Iterator const_iterator_type
    Constant input iterator type.
    Definition: sparse_set.hpp:173
    +
    entt::SparseSet< Entity, Type >::object_type
    Type object_type
    Type of the objects associated to the entities.
    Definition: sparse_set.hpp:682
    +
    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::SparseSet< Entity >::cend
    const_iterator_type cend() const ENTT_NOEXCEPT
    Returns an iterator to the end.
    Definition: sparse_set.hpp:329
    +
    entt::SparseSet< Entity, Type >::end
    const_iterator_type end() const ENTT_NOEXCEPT
    Returns an iterator to the end.
    Definition: sparse_set.hpp:838
    +
    entt::StdSort
    Function object to wrap std::sort in a class type.
    Definition: algorithm.hpp:21
    +
    entt::SparseSet< Entity >::destroy
    virtual void destroy(const entity_type entity)
    Removes an entity from a sparse set.
    Definition: sparse_set.hpp:463
    +
    entt::SparseSet< Entity, Type >::raw
    object_type * raw() ENTT_NOEXCEPT
    Direct access to the array of objects.
    Definition: sparse_set.hpp:752
    +
    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::SparseSet< Entity >::begin
    iterator_type begin() ENTT_NOEXCEPT
    Returns an iterator to the beginning.
    Definition: sparse_set.hpp:312
    +
    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::SparseSet< Entity >::end
    const_iterator_type end() const ENTT_NOEXCEPT
    Returns an iterator to the end.
    Definition: sparse_set.hpp:346
    +
    entt::SparseSet< Entity >::construct
    void construct(const entity_type entity)
    Assigns an entity to a sparse set.
    Definition: sparse_set.hpp:439
    +
    entt::SparseSet< Entity >::operator[]
    const entity_type & operator[](const size_type pos) const ENTT_NOEXCEPT
    Returns a reference to the element at the given position.
    Definition: sparse_set.hpp:372
    +
    entt::SparseSet< Entity, Type >::operator[]
    const object_type & operator[](const size_type pos) const ENTT_NOEXCEPT
    Returns a reference to the element at the given position.
    Definition: sparse_set.hpp:865
    entt::entt_traits
    Entity traits.
    Definition: entt_traits.hpp:18
    -
    entt::SparseSet< Entity >::swap
    void swap(const pos_type lhs, const pos_type rhs) ENTT_NOEXCEPT
    Swaps the position of two entities in the internal packed array.
    Definition: sparse_set.hpp:417
    diff --git a/structentt_1_1InsertionSort.html b/structentt_1_1InsertionSort.html index eb9b73bb7..5607fa5a6 100644 --- a/structentt_1_1InsertionSort.html +++ b/structentt_1_1InsertionSort.html @@ -86,7 +86,7 @@ Public Member Functions

    Detailed Description

    Function object for performing insertion sort.

    -

    Definition at line 41 of file algorithm.hpp.

    +

    Definition at line 43 of file algorithm.hpp.

    Member Function Documentation

    ◆ operator()()

    @@ -148,7 +148,7 @@ template<typename It , typename Compare = std::less<>>
    -

    Definition at line 54 of file algorithm.hpp.

    +

    Definition at line 56 of file algorithm.hpp.

    diff --git a/structentt_1_1Monostate-members.html b/structentt_1_1Monostate-members.html new file mode 100644 index 000000000..614cce470 --- /dev/null +++ b/structentt_1_1Monostate-members.html @@ -0,0 +1,83 @@ + + + + + + + +entt: Member List + + + + + + + + + +
    +
    + + + + + + +
    +
    entt +  2.6.1 +
    +
    +
    + + + + + + + + +
    +
    + + +
    + +
    + + +
    +
    +
    +
    entt::Monostate< hash_type > Member List
    +
    +
    + +

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

    + + + +
    operator Type() const ENTT_NOEXCEPTentt::Monostate< hash_type >inline
    operator=(Type val) const ENTT_NOEXCEPTentt::Monostate< hash_type >inline
    + +
    +Generated by   +doxygen + 1.8.13 +
    + + diff --git a/structentt_1_1Monostate.html b/structentt_1_1Monostate.html new file mode 100644 index 000000000..d35b2ad74 --- /dev/null +++ b/structentt_1_1Monostate.html @@ -0,0 +1,197 @@ + + + + + + + +entt: entt::Monostate< hash_type > Struct Template Reference + + + + + + + + + +
    +
    + + + + + + +
    +
    entt +  2.6.1 +
    +
    +
    + + + + + + + + +
    +
    + + +
    + +
    + + +
    +
    +
    +Public Member Functions | +List of all members
    +
    +
    entt::Monostate< hash_type > Struct Template Reference
    +
    +
    + +

    Minimal implementation of the monostate pattern. + More...

    + +

    #include <monostate.hpp>

    + + + + + + + + + + +

    +Public Member Functions

    template<typename Type >
    void operator= (Type val) const ENTT_NOEXCEPT
     Assigns a value of a specific type to a given key. More...
     
    template<typename Type >
     operator Type () const ENTT_NOEXCEPT
     Gets a value of a specific type for a given key. More...
     
    +

    Detailed Description

    +

    template<HashedString::hash_type>
    +struct entt::Monostate< hash_type >

    + +

    Minimal implementation of the monostate pattern.

    +

    A minimal, yet complete configuration system built on top of the monostate pattern. Thread safe by design, it works only with basic types like ints or bools.
    + Multiple types and therefore more than one value can be associated with a single key. 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 can incur in unexpected results.

    + +

    Definition at line 26 of file monostate.hpp.

    +

    Member Function Documentation

    + +

    ◆ operator Type()

    + +
    +
    +
    +template<HashedString::hash_type >
    +
    +template<typename Type >
    + + + + + +
    + + + + + + + +
    entt::Monostate< hash_type >::operator Type () const
    +     		+inline
    +
    + +

    Gets a value of a specific type for a given key.

    +
    Template Parameters
    + + +
    TypeType of the value to get.
    +
    +
    +
    Returns
    Stored value, if any.
    + +

    Definition at line 43 of file monostate.hpp.

    + +
    +
    + +

    ◆ operator=()

    + +
    +
    +
    +template<HashedString::hash_type >
    +
    +template<typename Type >
    + + + + + +
    + + + + + + + + +
    void entt::Monostate< hash_type >::operator= (Type val) const
    +     		+inline
    +
    + +

    Assigns a value of a specific type to a given key.

    +
    Template Parameters
    + + +
    TypeType of the value to assign.
    +
    +
    +
    Parameters
    + + +
    valUser data to assign to the given key.
    +
    +
    + +

    Definition at line 33 of file monostate.hpp.

    + +
    +
    +
    The documentation for this struct was generated from the following file: +
    + +
    +Generated by   +doxygen + 1.8.13 +
    + + diff --git a/structentt_1_1StdSort-members.html b/structentt_1_1StdSort-members.html index 9efa4da30..c95666276 100644 --- a/structentt_1_1StdSort-members.html +++ b/structentt_1_1StdSort-members.html @@ -70,7 +70,7 @@ $(function() {

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

    - +
    operator()(It first, It last, Compare compare=Compare{}) constentt::StdSortinline
    operator()(It first, It last, Compare compare=Compare{}, Args &&... args) constentt::StdSortinline
    diff --git a/structentt_1_1StdSort.html b/structentt_1_1StdSort.html index b0b6bdb0f..6f45fb737 100644 --- a/structentt_1_1StdSort.html +++ b/structentt_1_1StdSort.html @@ -78,10 +78,10 @@ $(function() { - - - - + + + +

    Public Member Functions

    template<typename It , typename Compare = std::less<>>
    void operator() (It first, It last, Compare compare=Compare{}) const
     Sorts the element in a range. More...
     
    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...
     

    Detailed Description

    Function object to wrap std::sort in a class type.

    @@ -90,13 +90,13 @@ Public Member Functions

    Definition at line 21 of file algorithm.hpp.

    Member Function Documentation

    - -

    ◆ operator()()

    + +

    ◆ operator()()

    -template<typename It , typename Compare = std::less<>>
    +template<typename It , typename Compare = std::less<>, typename... Args>
    - + + + + + + + @@ -138,6 +144,7 @@ template<typename It , typename Compare = std::less<>>
    @@ -117,7 +117,13 @@ template<typename It , typename Compare = std::less<>> Compare compare = Compare{} compare = Compare{},
    Args &&... args 
    +
    ItType of random access iterator.
    CompareType of comparison function object.
    ArgsTypes of arguments to forward to the sort function.
    @@ -146,11 +153,12 @@ template<typename It , typename Compare = std::less<>>
    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. + argsArguments to forward to the sort function, if any. -

    Definition at line 34 of file algorithm.hpp.

    +

    Definition at line 36 of file algorithm.hpp.

    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 00626919c..69c1e1d5a 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 @@ -70,11 +70,12 @@ $(function() {

    This is the complete list of members for entt::entt_traits< std::uint16_t >, including all inherited members.

    - - - - - + + + + + +
    entity_maskentt::entt_traits< std::uint16_t >static
    entity_shiftentt::entt_traits< std::uint16_t >static
    entity_type typedefentt::entt_traits< std::uint16_t >
    version_maskentt::entt_traits< std::uint16_t >static
    version_type typedefentt::entt_traits< std::uint16_t >
    difference_type typedefentt::entt_traits< std::uint16_t >
    entity_maskentt::entt_traits< std::uint16_t >static
    entity_shiftentt::entt_traits< std::uint16_t >static
    entity_type typedefentt::entt_traits< std::uint16_t >
    version_maskentt::entt_traits< std::uint16_t >static
    version_type typedefentt::entt_traits< std::uint16_t >
    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 e57a2c823..5bda1daed 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 @@ -87,6 +87,10 @@ using version_type = std::uint8_t  Underlying version type.
      + +using difference_type = std::int32_t + Difference type.
    +  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 b3814112b..6626c74bd 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 @@ -70,11 +70,12 @@ $(function() {

    This is the complete list of members for entt::entt_traits< std::uint32_t >, including all inherited members.

    Static Public Attributes

    - - - - - + + + + + +
    entity_maskentt::entt_traits< std::uint32_t >static
    entity_shiftentt::entt_traits< std::uint32_t >static
    entity_type typedefentt::entt_traits< std::uint32_t >
    version_maskentt::entt_traits< std::uint32_t >static
    version_type typedefentt::entt_traits< std::uint32_t >
    difference_type typedefentt::entt_traits< std::uint32_t >
    entity_maskentt::entt_traits< std::uint32_t >static
    entity_shiftentt::entt_traits< std::uint32_t >static
    entity_type typedefentt::entt_traits< std::uint32_t >
    version_maskentt::entt_traits< std::uint32_t >static
    version_type typedefentt::entt_traits< std::uint32_t >
    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 b1b13c9f1..808a42873 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 @@ -87,6 +87,10 @@ using version_type = std::uint16_t  Underlying version type.
      + +using difference_type = std::int64_t + Difference type.
    +  @@ -110,11 +114,11 @@ struct entt::entt_traits< std::uint32_t >

    Entity traits for a 32 bits entity identifier.

    A 32 bits entity identifier guarantees:

      -
    • 24 bits for the entity number (suitable for almost all the games).
      • -
    • 8 bit for the version (resets in [0-255]).
      • +
    • 20 bits for the entity number (suitable for almost all the games).
      • +
    • 12 bit for the version (resets in [0-4095]).
    -

    Definition at line 54 of file entt_traits.hpp.

    +

    Definition at line 56 of file entt_traits.hpp.

    The documentation for this struct was generated from the following file: diff --git a/structentt_1_1entt__traits_3_01std_1_1uint64__t_01_4-members.html b/structentt_1_1entt__traits_3_01std_1_1uint64__t_01_4-members.html index aa93c41d2..90e0af965 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 @@ -70,11 +70,12 @@ $(function() {

    This is the complete list of members for entt::entt_traits< std::uint64_t >, including all inherited members.

    Static Public Attributes

    - - - - - + + + + + +
    entity_maskentt::entt_traits< std::uint64_t >static
    entity_shiftentt::entt_traits< std::uint64_t >static
    entity_type typedefentt::entt_traits< std::uint64_t >
    version_maskentt::entt_traits< std::uint64_t >static
    version_type typedefentt::entt_traits< std::uint64_t >
    difference_type typedefentt::entt_traits< std::uint64_t >
    entity_maskentt::entt_traits< std::uint64_t >static
    entity_shiftentt::entt_traits< std::uint64_t >static
    entity_type typedefentt::entt_traits< std::uint64_t >
    version_maskentt::entt_traits< std::uint64_t >static
    version_type typedefentt::entt_traits< std::uint64_t >
    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 c563528e8..8f0b26f0f 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 @@ -87,19 +87,23 @@ using version_type = std::uint32_t  Underlying version type.
      + +using difference_type = std::int64_t + Difference type.
    +  +static constexpr auto  +static constexpr auto  +static constexpr auto 

    Static Public Attributes

    -static constexpr auto entity_mask = 0xFFFFFFFFFF
    entity_mask = 0xFFFFFFFF
     Mask to use to get the entity number out of an identifier.
     
    -static constexpr auto version_mask = 0xFFFFFF
    version_mask = 0xFFFFFFFF
     Mask to use to get the version out of an identifier.
     
    -static constexpr auto entity_shift = 40
    entity_shift = 32
     Extent of the entity number within an identifier.
     
    @@ -110,11 +114,11 @@ struct entt::entt_traits< std::uint64_t >

    Entity traits for a 64 bits entity identifier.

    A 64 bits entity identifier guarantees:

      -
    • 40 bits for the entity number (an indecently large number).
      • -
    • 24 bit for the version (an indecently large number).
      • +
    • 32 bits for the entity number (an indecently large number).
      • +
    • 32 bit for the version (an indecently large number).
    -

    Definition at line 78 of file entt_traits.hpp.

    +

    Definition at line 82 of file entt_traits.hpp.

    The documentation for this struct was generated from the following file: diff --git a/view_8hpp_source.html b/view_8hpp_source.html index 7f0f3de6b..c5482ef04 100644 --- a/view_8hpp_source.html +++ b/view_8hpp_source.html @@ -67,98 +67,117 @@ $(function() {
    view.hpp
    -
    1 #ifndef ENTT_ENTITY_VIEW_HPP
    2 #define ENTT_ENTITY_VIEW_HPP
    3 
    4 
    5 #include <cassert>
    6 #include <array>
    7 #include <tuple>
    8 #include <utility>
    9 #include <algorithm>
    10 #include <type_traits>
    11 #include "../config/config.h"
    12 #include "entt_traits.hpp"
    13 #include "sparse_set.hpp"
    14 
    15 
    16 namespace entt {
    17 
    18 
    22 template<typename>
    23 class Registry;
    24 
    25 
    67 template<typename Entity, typename... Component>
    68 class PersistentView final {
    69  static_assert(sizeof...(Component) > 1, "!");
    70 
    72  friend class Registry<Entity>;
    73 
    74  template<typename Comp>
    75  using pool_type = SparseSet<Entity, Comp>;
    76 
    77  using view_type = SparseSet<Entity>;
    78  using pattern_type = std::tuple<pool_type<Component> &...>;
    79 
    80  PersistentView(view_type &view, pool_type<Component> &... pools) ENTT_NOEXCEPT
    81  : view{view}, pools{pools...}
    82  {}
    83 
    84 public:
    86  using iterator_type = typename view_type::iterator_type;
    88  using const_iterator_type = typename view_type::const_iterator_type;
    90  using entity_type = typename view_type::entity_type;
    92  using size_type = typename view_type::size_type;
    93 
    98  size_type size() const ENTT_NOEXCEPT {
    99  return view.size();
    100  }
    101 
    106  bool empty() const ENTT_NOEXCEPT {
    107  return view.empty();
    108  }
    109 
    122  const entity_type * data() const ENTT_NOEXCEPT {
    123  return view.data();
    124  }
    125 
    140  const_iterator_type cbegin() const ENTT_NOEXCEPT {
    141  return view.cbegin();
    142  }
    143 
    158  inline const_iterator_type begin() const ENTT_NOEXCEPT {
    159  return cbegin();
    160  }
    161 
    176  iterator_type begin() ENTT_NOEXCEPT {
    177  return view.begin();
    178  }
    179 
    195  const_iterator_type cend() const ENTT_NOEXCEPT {
    196  return view.cend();
    197  }
    198 
    214  inline const_iterator_type end() const ENTT_NOEXCEPT {
    215  return cend();
    216  }
    217 
    233  iterator_type end() ENTT_NOEXCEPT {
    234  return view.end();
    235  }
    236 
    242  bool contains(const entity_type entity) const ENTT_NOEXCEPT {
    243  return view.has(entity) && (view.data()[view.get(entity)] == entity);
    244  }
    245 
    263  template<typename Comp>
    264  const Comp & get(const entity_type entity) const ENTT_NOEXCEPT {
    265  assert(contains(entity));
    266  return std::get<pool_type<Comp> &>(pools).get(entity);
    267  }
    268 
    286  template<typename Comp>
    287  inline Comp & get(const entity_type entity) ENTT_NOEXCEPT {
    288  return const_cast<Comp &>(const_cast<const PersistentView *>(this)->get<Comp>(entity));
    289  }
    290 
    308  template<typename... Comp>
    309  inline std::enable_if_t<(sizeof...(Comp) > 1), std::tuple<const Comp &...>>
    310  get(const entity_type entity) const ENTT_NOEXCEPT {
    311  assert(contains(entity));
    312  return std::tuple<const Comp &...>{get<Comp>(entity)...};
    313  }
    314 
    332  template<typename... Comp>
    333  inline std::enable_if_t<(sizeof...(Comp) > 1), std::tuple<Comp &...>>
    334  get(const entity_type entity) ENTT_NOEXCEPT {
    335  assert(contains(entity));
    336  return std::tuple<Comp &...>{get<Comp>(entity)...};
    337  }
    338 
    355  template<typename Func>
    356  void each(Func func) const {
    357  std::for_each(view.cbegin(), view.cend(), [&func, this](const auto entity) {
    358  func(entity, std::get<pool_type<Component> &>(pools).get(entity)...);
    359  });
    360  }
    361 
    378  template<typename Func>
    379  inline void each(Func func) {
    380  const_cast<const PersistentView *>(this)->each([&func](const entity_type entity, const Component &... component) {
    381  func(entity, const_cast<Component &>(component)...);
    382  });
    383  }
    384 
    401  template<typename Comp>
    402  void sort() {
    403  view.respect(std::get<pool_type<Comp> &>(pools));
    404  }
    405 
    406 private:
    407  view_type &view;
    408  const pattern_type pools;
    409 };
    410 
    411 
    452 template<typename Entity, typename... Component>
    453 class View final {
    454  static_assert(sizeof...(Component) > 1, "!");
    455 
    457  friend class Registry<Entity>;
    458 
    459  template<typename Comp>
    460  using pool_type = SparseSet<Entity, Comp>;
    461 
    462  template<typename Comp>
    463  using component_iterator_type = typename pool_type<Comp>::const_iterator_type;
    464 
    465  using view_type = SparseSet<Entity>;
    466  using underlying_iterator_type = typename view_type::const_iterator_type;
    467  using unchecked_type = std::array<const view_type *, (sizeof...(Component) - 1)>;
    468  using pattern_type = std::tuple<pool_type<Component> &...>;
    469  using traits_type = entt_traits<Entity>;
    470 
    471  class Iterator {
    472  using size_type = typename view_type::size_type;
    473 
    474  bool valid() const ENTT_NOEXCEPT {
    475  const auto entity = *begin;
    476  const auto sz = size_type(entity & traits_type::entity_mask);
    477 
    478  return sz < extent && std::all_of(unchecked.cbegin(), unchecked.cend(), [entity](const view_type *view) {
    479  return view->fast(entity);
    480  });
    481  }
    482 
    483  public:
    484  using difference_type = typename underlying_iterator_type::difference_type;
    485  using value_type = typename underlying_iterator_type::value_type;
    486  using pointer = typename underlying_iterator_type::pointer;
    487  using reference = typename underlying_iterator_type::reference;
    488  using iterator_category = typename underlying_iterator_type::iterator_category;
    489 
    490  Iterator(unchecked_type unchecked, size_type extent, underlying_iterator_type begin, underlying_iterator_type end) ENTT_NOEXCEPT
    491  : unchecked{unchecked},
    492  extent{extent},
    493  begin{begin},
    494  end{end}
    495  {
    496  if(begin != end && !valid()) {
    497  ++(*this);
    498  }
    499  }
    500 
    501  Iterator & operator++() ENTT_NOEXCEPT {
    502  return (++begin != end && !valid()) ? ++(*this) : *this;
    503  }
    504 
    505  Iterator operator++(int) ENTT_NOEXCEPT {
    506  Iterator orig = *this;
    507  return ++(*this), orig;
    508  }
    509 
    510  Iterator & operator+=(const difference_type value) ENTT_NOEXCEPT {
    511  return ((begin += value) != end && !valid()) ? ++(*this) : *this;
    512  }
    513 
    514  Iterator operator+(const difference_type value) const ENTT_NOEXCEPT {
    515  return Iterator{unchecked, extent, begin+value, end};
    516  }
    517 
    518  bool operator==(const Iterator &other) const ENTT_NOEXCEPT {
    519  return other.begin == begin;
    520  }
    521 
    522  inline bool operator!=(const Iterator &other) const ENTT_NOEXCEPT {
    523  return !(*this == other);
    524  }
    525 
    526  value_type operator*() const ENTT_NOEXCEPT {
    527  return *begin;
    528  }
    529 
    530  private:
    531  const unchecked_type unchecked;
    532  const size_type extent;
    533  underlying_iterator_type begin;
    534  underlying_iterator_type end;
    535  };
    536 
    537  View(pool_type<Component> &... pools) ENTT_NOEXCEPT
    538  : pools{pools...}
    539  {}
    540 
    541  template<typename Comp>
    542  const pool_type<Comp> & pool() const ENTT_NOEXCEPT {
    543  return std::get<pool_type<Comp> &>(pools);
    544  }
    545 
    546  template<typename Comp>
    547  inline pool_type<Comp> & pool() ENTT_NOEXCEPT {
    548  return const_cast<pool_type<Comp> &>(const_cast<const View *>(this)->pool<Comp>());
    549  }
    550 
    551  const view_type * candidate() const ENTT_NOEXCEPT {
    552  return std::min({ static_cast<const view_type *>(&pool<Component>())... }, [](const auto *lhs, const auto *rhs) {
    553  return lhs->size() < rhs->size();
    554  });
    555  }
    556 
    557  unchecked_type unchecked(const view_type *view) const ENTT_NOEXCEPT {
    558  unchecked_type other{};
    559  std::size_t pos{};
    560  using accumulator_type = const view_type *[];
    561  accumulator_type accumulator = { (&pool<Component>() == view ? view : other[pos++] = &pool<Component>())... };
    562  (void)accumulator;
    563  return other;
    564  }
    565 
    566  typename view_type::size_type extent() const ENTT_NOEXCEPT {
    567  return std::min({ pool<Component>().extent()... });
    568  }
    569 
    570  template<typename Comp, typename Other>
    571  inline std::enable_if_t<std::is_same<Comp, Other>::value, const Other &>
    572  get(const component_iterator_type<Comp> &it, const Entity) const ENTT_NOEXCEPT { return *it; }
    573 
    574  template<typename Comp, typename Other>
    575  inline std::enable_if_t<!std::is_same<Comp, Other>::value, const Other &>
    576  get(const component_iterator_type<Comp> &, const Entity entity) const ENTT_NOEXCEPT { return pool<Other>().get(entity); }
    577 
    578  template<typename Comp, typename Func, std::size_t... Indexes>
    579  void each(const pool_type<Comp> &cpool, Func func, std::index_sequence<Indexes...>) const {
    580  const auto other = unchecked(&cpool);
    581  std::array<underlying_iterator_type, sizeof...(Component)> data{{cpool.view_type::cbegin(), std::get<Indexes>(other)->cbegin()...}};
    582  auto raw = std::make_tuple(pool<Component>().cbegin()...);
    583  const auto end = cpool.view_type::cend();
    584  std::size_t pos{};
    585 
    586  // we can directly use the raw iterators if pools are ordered
    587  while(!pos && data[0] != end) {
    588  for(pos = data.size() - 1; pos && *(data[pos]++) == *data[pos-1]; --pos);
    589 
    590  if(!pos) {
    591  func(*(data[0]++), *(std::get<component_iterator_type<Component>>(raw)++)...);
    592  }
    593  }
    594 
    595  auto it = std::get<component_iterator_type<Comp>>(raw);
    596  const auto ext = extent();
    597 
    598  // fallback to visit what remains using indirections
    599  for(; data[0] != end; ++data[0], ++it) {
    600  const auto entity = *data[0];
    601  const auto sz = size_type(entity & traits_type::entity_mask);
    602 
    603  if(sz < ext && std::all_of(other.cbegin(), other.cend(), [entity](const view_type *view) { return view->fast(entity); })) {
    604  // avoided at least the indirection due to the sparse set for the pivot type (see get for more details)
    605  func(entity, get<Comp, Component>(it, entity)...);
    606  }
    607  }
    608  }
    609 
    610 public:
    612  using iterator_type = Iterator;
    614  using const_iterator_type = Iterator;
    616  using entity_type = typename view_type::entity_type;
    618  using size_type = typename view_type::size_type;
    619 
    624  size_type size() const ENTT_NOEXCEPT {
    625  return std::min({ pool<Component>().size()... });
    626  }
    627 
    632  bool empty() const ENTT_NOEXCEPT {
    633  return std::max({ pool<Component>().empty()... });
    634  }
    635 
    650  const_iterator_type cbegin() const ENTT_NOEXCEPT {
    651  const auto *view = candidate();
    652  return iterator_type{ unchecked(view), extent(), view->cbegin(), view->cend() };
    653  }
    654 
    669  inline const_iterator_type begin() const ENTT_NOEXCEPT {
    670  return cbegin();
    671  }
    672 
    687  inline iterator_type begin() ENTT_NOEXCEPT {
    688  return cbegin();
    689  }
    690 
    706  const_iterator_type cend() const ENTT_NOEXCEPT {
    707  const auto *view = candidate();
    708  return iterator_type{ unchecked(view), extent(), view->cend(), view->cend() };
    709  }
    710 
    726  inline const_iterator_type end() const ENTT_NOEXCEPT {
    727  return cend();
    728  }
    729 
    745  inline iterator_type end() ENTT_NOEXCEPT {
    746  return cend();
    747  }
    748 
    754  bool contains(const entity_type entity) const ENTT_NOEXCEPT {
    755  const auto sz = size_type(entity & traits_type::entity_mask);
    756  return sz < extent() && std::min({ (pool<Component>().has(entity) && (pool<Component>().data()[pool<Component>().view_type::get(entity)] == entity))... });
    757  }
    758 
    776  template<typename Comp>
    777  const Comp & get(const entity_type entity) const ENTT_NOEXCEPT {
    778  assert(contains(entity));
    779  return pool<Comp>().get(entity);
    780  }
    781 
    799  template<typename Comp>
    800  inline Comp & get(const entity_type entity) ENTT_NOEXCEPT {
    801  return const_cast<Comp &>(const_cast<const View *>(this)->get<Comp>(entity));
    802  }
    803 
    821  template<typename... Comp>
    822  inline std::enable_if_t<(sizeof...(Comp) > 1), std::tuple<const Comp &...>>
    823  get(const entity_type entity) const ENTT_NOEXCEPT {
    824  assert(contains(entity));
    825  return std::tuple<const Comp &...>{get<Comp>(entity)...};
    826  }
    827 
    845  template<typename... Comp>
    846  inline std::enable_if_t<(sizeof...(Comp) > 1), std::tuple<Comp &...>>
    847  get(const entity_type entity) ENTT_NOEXCEPT {
    848  assert(contains(entity));
    849  return std::tuple<Comp &...>{get<Comp>(entity)...};
    850  }
    851 
    868  template<typename Func>
    869  void each(Func func) const {
    870  const auto *view = candidate();
    871  using accumulator_type = int[];
    872  accumulator_type accumulator = { (&pool<Component>() == view ? (each(pool<Component>(), std::move(func), std::make_index_sequence<sizeof...(Component)-1>{}), 0) : 0)... };
    873  (void)accumulator;
    874  }
    875 
    892  template<typename Func>
    893  inline void each(Func func) {
    894  const_cast<const View *>(this)->each([&func](const entity_type entity, const Component &... component) {
    895  func(entity, const_cast<Component &>(component)...);
    896  });
    897  }
    898 
    899 private:
    900  const pattern_type pools;
    901 };
    902 
    903 
    941 template<typename Entity, typename Component>
    942 class View<Entity, Component> final {
    944  friend class Registry<Entity>;
    945 
    946  using view_type = SparseSet<Entity>;
    947  using pool_type = SparseSet<Entity, Component>;
    948 
    949  View(pool_type &pool) ENTT_NOEXCEPT
    950  : pool{pool}
    951  {}
    952 
    953 public:
    955  using iterator_type = typename view_type::iterator_type;
    957  using const_iterator_type = typename view_type::const_iterator_type;
    959  using entity_type = typename pool_type::entity_type;
    961  using size_type = typename pool_type::size_type;
    963  using raw_type = typename pool_type::object_type;
    964 
    969  size_type size() const ENTT_NOEXCEPT {
    970  return pool.size();
    971  }
    972 
    977  bool empty() const ENTT_NOEXCEPT {
    978  return pool.empty();
    979  }
    980 
    993  const raw_type * raw() const ENTT_NOEXCEPT {
    994  return pool.raw();
    995  }
    996 
    1009  inline raw_type * raw() ENTT_NOEXCEPT {
    1010  return const_cast<raw_type *>(const_cast<const View *>(this)->raw());
    1011  }
    1012 
    1025  const entity_type * data() const ENTT_NOEXCEPT {
    1026  return pool.data();
    1027  }
    1028 
    1043  const_iterator_type cbegin() const ENTT_NOEXCEPT {
    1044  return pool.view_type::cbegin();
    1045  }
    1046 
    1061  inline const_iterator_type begin() const ENTT_NOEXCEPT {
    1062  return cbegin();
    1063  }
    1064 
    1079  iterator_type begin() ENTT_NOEXCEPT {
    1080  return pool.view_type::begin();
    1081  }
    1082 
    1098  const_iterator_type cend() const ENTT_NOEXCEPT {
    1099  return pool.view_type::cend();
    1100  }
    1101 
    1117  inline const_iterator_type end() const ENTT_NOEXCEPT {
    1118  return cend();
    1119  }
    1120 
    1136  iterator_type end() ENTT_NOEXCEPT {
    1137  return pool.view_type::end();
    1138  }
    1139 
    1145  bool contains(const entity_type entity) const ENTT_NOEXCEPT {
    1146  return pool.has(entity) && (pool.data()[pool.view_type::get(entity)] == entity);
    1147  }
    1148 
    1164  const Component & get(const entity_type entity) const ENTT_NOEXCEPT {
    1165  assert(contains(entity));
    1166  return pool.get(entity);
    1167  }
    1168 
    1184  inline Component & get(const entity_type entity) ENTT_NOEXCEPT {
    1185  return const_cast<Component &>(const_cast<const View *>(this)->get(entity));
    1186  }
    1187 
    1203  template<typename Func>
    1204  void each(Func func) const {
    1205  std::for_each(pool.view_type::cbegin(), pool.view_type::cend(), [&func, raw = pool.cbegin()](const auto entity) mutable {
    1206  func(entity, *(raw++));
    1207  });
    1208  }
    1209 
    1225  template<typename Func>
    1226  inline void each(Func func) {
    1227  const_cast<const View *>(this)->each([&func](const entity_type entity, const Component &component) {
    1228  func(entity, const_cast<Component &>(component));
    1229  });
    1230  }
    1231 
    1232 private:
    1233  pool_type &pool;
    1234 };
    1235 
    1236 
    1275 template<typename Entity, typename Component>
    1276 class RawView final {
    1278  friend class Registry<Entity>;
    1279 
    1280  using pool_type = SparseSet<Entity, Component>;
    1281 
    1282  RawView(pool_type &pool) ENTT_NOEXCEPT
    1283  : pool{pool}
    1284  {}
    1285 
    1286 public:
    1288  using iterator_type = typename pool_type::iterator_type;
    1290  using const_iterator_type = typename pool_type::const_iterator_type;
    1292  using entity_type = typename pool_type::entity_type;
    1294  using size_type = typename pool_type::size_type;
    1296  using raw_type = typename pool_type::object_type;
    1297 
    1302  size_type size() const ENTT_NOEXCEPT {
    1303  return pool.size();
    1304  }
    1305 
    1310  bool empty() const ENTT_NOEXCEPT {
    1311  return pool.empty();
    1312  }
    1313 
    1326  const raw_type * raw() const ENTT_NOEXCEPT {
    1327  return pool.raw();
    1328  }
    1329 
    1342  inline raw_type * raw() ENTT_NOEXCEPT {
    1343  return const_cast<raw_type *>(const_cast<const RawView *>(this)->raw());
    1344  }
    1345 
    1358  const entity_type * data() const ENTT_NOEXCEPT {
    1359  return pool.data();
    1360  }
    1361 
    1374  const_iterator_type cbegin() const ENTT_NOEXCEPT {
    1375  return pool.cbegin();
    1376  }
    1377 
    1390  inline const_iterator_type begin() const ENTT_NOEXCEPT {
    1391  return cbegin();
    1392  }
    1393 
    1406  iterator_type begin() ENTT_NOEXCEPT {
    1407  return pool.begin();
    1408  }
    1409 
    1425  const_iterator_type cend() const ENTT_NOEXCEPT {
    1426  return pool.cend();
    1427  }
    1428 
    1444  inline const_iterator_type end() const ENTT_NOEXCEPT {
    1445  return cend();
    1446  }
    1447 
    1463  iterator_type end() ENTT_NOEXCEPT {
    1464  return pool.end();
    1465  }
    1466 
    1481  template<typename Func>
    1482  void each(Func func) const {
    1483  std::for_each(pool.cbegin(), pool.cend(), func);
    1484  }
    1485 
    1500  template<typename Func>
    1501  void each(Func func) {
    1502  std::for_each(pool.begin(), pool.end(), func);
    1503  }
    1504 
    1505 private:
    1506  pool_type &pool;
    1507 };
    1508 
    1509 
    1510 }
    1511 
    1512 
    1513 #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:1290
    -
    entt::View< Entity, Component >::size_type
    typename pool_type::size_type size_type
    Unsigned integer type.
    Definition: view.hpp:961
    -
    entt::RawView::empty
    bool empty() const ENTT_NOEXCEPT
    Checks whether the view is empty.
    Definition: view.hpp:1310
    +
    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->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
    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:706
    -
    entt::PersistentView::const_iterator_type
    typename view_type::const_iterator_type const_iterator_type
    Constant input iterator type.
    Definition: view.hpp:88
    -
    entt::PersistentView::entity_type
    typename view_type::entity_type entity_type
    Underlying entity identifier.
    Definition: view.hpp:90
    -
    entt::RawView::begin
    iterator_type begin() ENTT_NOEXCEPT
    Returns an iterator to the first instance of the given type.
    Definition: view.hpp:1406
    -
    entt::PersistentView::size
    size_type size() const ENTT_NOEXCEPT
    Returns the number of entities that have the given components.
    Definition: view.hpp:98
    -
    entt::Registry
    Fast and reliable entity-component system.
    Definition: registry.hpp:39
    -
    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:1117
    -
    entt::SparseSet< Entity >::empty
    bool empty() const ENTT_NOEXCEPT
    Checks whether a sparse set is empty.
    Definition: sparse_set.hpp:182
    -
    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:214
    -
    entt::PersistentView::each
    void each(Func func)
    Iterates entities and components and applies the given function object to them.
    Definition: view.hpp:379
    -
    entt::View::size_type
    typename view_type::size_type size_type
    Unsigned integer type.
    Definition: view.hpp:618
    -
    entt::RawView::raw
    raw_type * raw() ENTT_NOEXCEPT
    Direct access to the list of components.
    Definition: view.hpp:1342
    -
    entt::RawView::iterator_type
    typename pool_type::iterator_type iterator_type
    Input iterator type.
    Definition: view.hpp:1288
    -
    entt::RawView
    Raw view.
    Definition: view.hpp:1276
    -
    entt::RawView::each
    void each(Func func)
    Iterates components and applies the given function object to them.
    Definition: view.hpp:1501
    -
    entt::PersistentView::empty
    bool empty() const ENTT_NOEXCEPT
    Checks whether the view is empty.
    Definition: view.hpp:106
    +
    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::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::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::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::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::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::View< Entity, Component >::contains
    bool contains(const entity_type entity) const ENTT_NOEXCEPT
    Checks if a view contains an entity.
    Definition: view.hpp:1145
    -
    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:309
    -
    entt::View< Entity, Component >::raw_type
    typename pool_type::object_type raw_type
    Type of component iterated by the view.
    Definition: view.hpp:963
    -
    entt::RawView::data
    const entity_type * data() const ENTT_NOEXCEPT
    Direct access to the list of entities.
    Definition: view.hpp:1358
    -
    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:726
    -
    entt::View< Entity, Component >::const_iterator_type
    typename view_type::const_iterator_type const_iterator_type
    Constant input iterator type.
    Definition: view.hpp:957
    -
    entt::SparseSet< Entity >::begin
    const_iterator_type begin() const ENTT_NOEXCEPT
    Returns an iterator to the beginning.
    Definition: sparse_set.hpp:233
    -
    entt::View::contains
    bool contains(const entity_type entity) const ENTT_NOEXCEPT
    Checks if a view contains an entity.
    Definition: view.hpp:754
    -
    entt::View< Entity, Component >::raw
    const raw_type * raw() const ENTT_NOEXCEPT
    Direct access to the list of components.
    Definition: view.hpp:993
    -
    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:233
    -
    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:158
    -
    entt::View::const_iterator_type
    Iterator const_iterator_type
    Constant input iterator type.
    Definition: view.hpp:614
    -
    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:1079
    -
    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:195
    -
    entt::SparseSet
    Sparse set.
    Definition: sparse_set.hpp:28
    -
    entt::RawView::cbegin
    const_iterator_type cbegin() const ENTT_NOEXCEPT
    Returns an iterator to the first instance of the given type.
    Definition: view.hpp:1374
    -
    entt::View< Entity, Component >::each
    void each(Func func)
    Iterates entities and components and applies the given function object to them.
    Definition: view.hpp:1226
    -
    entt::RawView::each
    void each(Func func) const
    Iterates components and applies the given function object to them.
    Definition: view.hpp:1482
    -
    entt::SparseSet< Entity >::size_type
    std::size_t size_type
    Unsigned integer type.
    Definition: sparse_set.hpp:116
    -
    entt::View::empty
    bool empty() const ENTT_NOEXCEPT
    Checks if the view is definitely empty.
    Definition: view.hpp:632
    -
    entt::RawView::size
    size_type size() const ENTT_NOEXCEPT
    Returns the number of instances of the given type.
    Definition: view.hpp:1302
    -
    entt::View< Entity, Component >::data
    const entity_type * data() const ENTT_NOEXCEPT
    Direct access to the list of entities.
    Definition: view.hpp:1025
    -
    entt::SparseSet< Entity >::entity_type
    Entity entity_type
    Underlying entity identifier.
    Definition: sparse_set.hpp:112
    -
    entt::SparseSet< Entity >::iterator_type
    Iterator iterator_type
    Input iterator type.
    Definition: sparse_set.hpp:118
    -
    entt::View< Entity, Component >::entity_type
    typename pool_type::entity_type entity_type
    Underlying entity identifier.
    Definition: view.hpp:959
    -
    entt::SparseSet< Entity >
    Basic sparse set implementation.
    Definition: sparse_set.hpp:59
    -
    entt::View::begin
    iterator_type begin() ENTT_NOEXCEPT
    Returns an iterator to the first entity that has the given components.
    Definition: view.hpp:687
    -
    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:1444
    -
    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:745
    -
    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:1425
    -
    entt::SparseSet< Entity >::const_iterator_type
    Iterator const_iterator_type
    Constant input iterator type.
    Definition: sparse_set.hpp:120
    -
    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:1043
    -
    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:1204
    -
    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:669
    -
    entt::View::iterator_type
    Iterator iterator_type
    Input iterator type.
    Definition: view.hpp:612
    -
    entt::View< Entity, Component >::empty
    bool empty() const ENTT_NOEXCEPT
    Checks whether the view is empty.
    Definition: view.hpp:977
    -
    entt::SparseSet< Entity >::size
    size_type size() const ENTT_NOEXCEPT
    Returns the number of elements in a sparse set.
    Definition: sparse_set.hpp:174
    -
    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:1061
    -
    entt::PersistentView::iterator_type
    typename view_type::iterator_type iterator_type
    Input iterator type.
    Definition: view.hpp:86
    -
    entt::PersistentView::sort
    void sort()
    Sort the shared pool of entities according to the given component.
    Definition: view.hpp:402
    -
    entt::View< Entity, Component >::raw
    raw_type * raw() ENTT_NOEXCEPT
    Direct access to the list of components.
    Definition: view.hpp:1009
    -
    entt::RawView::begin
    const_iterator_type begin() const ENTT_NOEXCEPT
    Returns an iterator to the first instance of the given type.
    Definition: view.hpp:1390
    -
    entt::RawView::raw_type
    typename pool_type::object_type raw_type
    Type of component iterated by the view.
    Definition: view.hpp:1296
    -
    entt::View< Entity, Component >::iterator_type
    typename view_type::iterator_type iterator_type
    Input iterator type.
    Definition: view.hpp:955
    -
    entt::View< Entity, Component >::size
    size_type size() const ENTT_NOEXCEPT
    Returns the number of entities that have the given component.
    Definition: view.hpp:969
    -
    entt::SparseSet< Entity >::cend
    const_iterator_type cend() const ENTT_NOEXCEPT
    Returns an iterator to the end.
    Definition: sparse_set.hpp:266
    -
    entt::View
    Multi component view.
    Definition: view.hpp:453
    -
    entt::PersistentView
    Persistent view.
    Definition: view.hpp:68
    -
    entt::SparseSet< Entity >::get
    pos_type get(const entity_type entity) const ENTT_NOEXCEPT
    Returns the position of an entity in a sparse set.
    Definition: sparse_set.hpp:351
    -
    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:650
    -
    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:140
    -
    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:445
    -
    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:1136
    -
    entt::View::each
    void each(Func func)
    Iterates entities and components and applies the given function object to them.
    Definition: view.hpp:893
    -
    entt::RawView::end
    iterator_type end() ENTT_NOEXCEPT
    Returns an iterator that is past the last instance of the given type.
    Definition: view.hpp:1463
    -
    entt::SparseSet< Entity >::data
    const entity_type * data() const ENTT_NOEXCEPT
    Direct access to the internal packed array.
    Definition: sparse_set.hpp:201
    -
    entt::SparseSet< Entity >::cbegin
    const_iterator_type cbegin() const ENTT_NOEXCEPT
    Returns an iterator to the beginning.
    Definition: sparse_set.hpp:217
    -
    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:1098
    -
    entt::SparseSet< Entity >::end
    const_iterator_type end() const ENTT_NOEXCEPT
    Returns an iterator to the end.
    Definition: sparse_set.hpp:283
    -
    entt::PersistentView::begin
    iterator_type begin() ENTT_NOEXCEPT
    Returns an iterator to the first entity that has the given components.
    Definition: view.hpp:176
    -
    entt::View::each
    void each(Func func) const
    Iterates entities and components and applies the given function object to them.
    Definition: view.hpp:869
    -
    entt::RawView::size_type
    typename pool_type::size_type size_type
    Unsigned integer type.
    Definition: view.hpp:1294
    -
    entt::PersistentView::data
    const entity_type * data() const ENTT_NOEXCEPT
    Direct access to the list of entities.
    Definition: view.hpp:122
    -
    entt::RawView::entity_type
    typename pool_type::entity_type entity_type
    Underlying entity identifier.
    Definition: view.hpp:1292
    -
    entt::View::entity_type
    typename view_type::entity_type entity_type
    Underlying entity identifier.
    Definition: view.hpp:616
    -
    entt::PersistentView::each
    void each(Func func) const
    Iterates entities and components and applies the given function object to them.
    Definition: view.hpp:356
    +
    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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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:1326
    -
    entt::PersistentView::size_type
    typename view_type::size_type size_type
    Unsigned integer type.
    Definition: view.hpp:92
    -
    entt::View::size
    size_type size() const ENTT_NOEXCEPT
    Estimates the number of entities that have the given components.
    Definition: view.hpp:624
    -
    entt::PersistentView::contains
    bool contains(const entity_type entity) const ENTT_NOEXCEPT
    Checks if a view contains an entity.
    Definition: view.hpp:242
    +
    entt::RawView::raw
    const raw_type * raw() const ENTT_NOEXCEPT
    Direct access to the list of components.
    Definition: view.hpp:1350
    +
    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::PersistentView::contains
    bool contains(const entity_type entity) const ENTT_NOEXCEPT
    Checks if a view contains an entity.
    Definition: view.hpp:254