1#ifndef ENTT_ENTITY_SNAPSHOT_HPP
2#define ENTT_ENTITY_SNAPSHOT_HPP
10#include "../config/config.h"
11#include "../container/dense_map.hpp"
12#include "../core/type_traits.hpp"
22template<
typename Registry>
23void orphans(Registry ®istry) {
24 auto &
storage =
registry.template storage<typename Registry::entity_type>();
46template<
typename Registry>
48 static_assert(!std::is_const_v<Registry>,
"Non-const registry type required");
49 using traits_type =
typename Registry::traits_type;
78 template<typename Type, typename Archive>
81 archive(
static_cast<typename traits_type::entity_type
>(
storage->
size()));
83 if constexpr(std::is_same_v<Type, entity_type>) {
84 archive(
static_cast<typename traits_type::entity_type
>(
storage->
free_list()));
91 std::apply([&archive](
auto &&...args) { (archive(std::forward<
decltype(args)>(args)), ...); }, elem);
95 archive(
typename traits_type::entity_type{});
113 template<
typename Type,
typename Archive,
typename It>
115 static_assert(!std::is_same_v<Type, entity_type>,
"Entity types not supported");
118 archive(
static_cast<typename traits_type::entity_type
>(std::distance(first, last)));
120 for(; first != last; ++first) {
123 std::apply([&archive](
auto &&...args) { (archive(std::forward<
decltype(args)>(args)), ...); },
storage->
get_as_tuple(
entt));
129 archive(
typename traits_type::entity_type{});
149template<
typename Registry>
151 static_assert(!std::is_const_v<Registry>,
"Non-const registry type required");
152 using traits_type =
typename Registry::traits_type;
167 ENTT_ASSERT(reg->template
storage<entity_type>().
empty() && (reg->storage().begin() == reg->storage().end()),
"Registry must be empty");
184 template<typename Type, typename Archive>
187 typename traits_type::entity_type length{};
191 if constexpr(std::is_same_v<Type, entity_type>) {
192 typename traits_type::entity_type count{};
210 ENTT_ASSERT(
entity ==
entt,
"Entity not available for use");
237 internal::orphans(*reg);
261template<
typename Registry>
263 static_assert(!std::is_const_v<Registry>,
"Non-const registry type required");
264 using traits_type =
typename Registry::traits_type;
266 void restore(
typename Registry::entity_type
entt) {
268 if(!reg->valid(remloc[
entity].second)) {
269 remloc[
entity].second = reg->create();
276 template<
typename Container>
277 auto update(
int, Container &container) ->
decltype(
typename Container::mapped_type{}, void()) {
281 for(
auto &&pair: container) {
282 using first_type = std::remove_const_t<
typename std::decay_t<
decltype(pair)>::first_type>;
283 using second_type =
typename std::decay_t<
decltype(pair)>::second_type;
285 if constexpr(std::is_same_v<first_type, entity_type> && std::is_same_v<second_type, entity_type>) {
286 other.emplace(
map(pair.first),
map(pair.second));
287 }
else if constexpr(std::is_same_v<first_type, entity_type>) {
288 other.emplace(
map(pair.first), std::move(pair.second));
290 static_assert(std::is_same_v<second_type, entity_type>,
"Neither the key nor the value are of entity type");
291 other.emplace(std::move(pair.first),
map(pair.second));
296 swap(container, other);
299 template<
typename Container>
300 auto update(
char, Container &container) ->
decltype(
typename Container::value_type{}, void()) {
302 static_assert(std::is_same_v<typename Container::value_type, entity_type>,
"Invalid value type");
304 for(
auto &&
entt: container) {
309 template<
typename Component,
typename Other,
typename Member>
310 void update([[maybe_unused]] Component &instance, [[maybe_unused]] Member Other::*member) {
311 if constexpr(!std::is_same_v<Component, Other>) {
313 }
else if constexpr(std::is_same_v<Member, entity_type>) {
314 instance.*member =
map(instance.*member);
317 update(0, instance.*member);
332 : remloc{source.get_allocator()},
355 template<
typename Type,
typename Archive>
358 typename traits_type::entity_type length{};
363 if constexpr(std::is_same_v<Type, entity_type>) {
364 typename traits_type::entity_type in_use{};
369 for(std::size_t pos{}; pos < in_use; ++pos) {
374 for(std::size_t pos = in_use; pos < length; ++pos) {
378 if(reg->valid(remloc[
entity].second)) {
379 reg->destroy(remloc[
entity].second);
386 for(
auto &&
ref: remloc) {
419 internal::orphans(*reg);
430 return it != remloc.
cend() && it->second.first ==
entt;
440 return it->second.second;
Utility class for continuous loading.
basic_continuous_loader & operator=(basic_continuous_loader &&)=default
Default move assignment operator.
basic_continuous_loader(basic_continuous_loader &&)=default
Default move constructor.
basic_continuous_loader(registry_type &source) noexcept
Constructs an instance that is bound to a given registry.
typename registry_type::entity_type entity_type
Underlying entity identifier.
bool contains(entity_type entt) const noexcept
Tests if a loader knows about a given entity.
entity_type map(entity_type entt) const noexcept
Returns the identifier to which an entity refers.
basic_continuous_loader & get(Archive &archive, const id_type id=type_hash< Type >::value())
Restores all elements of a type with associated identifiers.
basic_continuous_loader & orphans()
Destroys those entities that have no components.
Utility class to restore a snapshot as a whole.
basic_snapshot_loader(registry_type &source) noexcept
Constructs an instance that is bound to a given registry.
typename registry_type::entity_type entity_type
Underlying entity identifier.
basic_snapshot_loader(basic_snapshot_loader &&) noexcept=default
Default move constructor.
basic_snapshot_loader & orphans()
Destroys those entities that have no components.
Utility class to create snapshots from a registry.
basic_snapshot(const registry_type &source) noexcept
Constructs an instance that is bound to a given registry.
typename registry_type::entity_type entity_type
Underlying entity identifier.
const basic_snapshot & get(Archive &archive, It first, It last, const id_type id=type_hash< Type >::value()) const
Serializes all elements of a type with associated identifiers for the entities in a range.
basic_snapshot(basic_snapshot &&) noexcept=default
Default move constructor.
pointer data() const noexcept
Direct access to the internal packed array.
size_type size() const noexcept
Returns the number of elements in a sparse set.
bool contains(const entity_type entt) const noexcept
Checks if a sparse set contains an entity.
size_type free_list() const noexcept
Returns the head of the free list, if any.
bool empty() const noexcept
Checks whether a sparse set is empty.
bool remove(const entity_type entt)
Removes an entity from a sparse set if it exists.
Basic storage implementation.
reverse_iterable reach() noexcept
Returns a reverse iterable object to use to visit a storage.
void reserve(const size_type cap) override
Increases the capacity of a storage.
value_type & emplace(const entity_type entt, Args &&...args)
Assigns an entity to a storage and constructs its object.
std::tuple< const value_type & > get_as_tuple(const entity_type entt) const noexcept
Returns the object assigned to an entity as a tuple.
Associative container for key-value pairs with unique keys.
bool contains(const key_type &key) const
Checks if the container contains an element with a given key.
const_iterator cend() const noexcept
Returns an iterator to the end.
iterator find(const key_type &key)
Finds an element with a given key.
iterator erase(const_iterator pos)
Removes an element from a given position.
std::pair< iterator, bool > insert_or_assign(const key_type &key, Arg &&value)
Inserts an element into the container or assigns to the current element if the key already exists.
entity
Default entity identifier.
constexpr entt_traits< Entity >::entity_type to_entity(const Entity value) noexcept
Returns the entity part once converted to the underlying type.
std::uint32_t id_type
Alias declaration for type identifiers.
constexpr null_t null
Compile-time constant for null entities.
basic_storage< Type > storage
Alias declaration for the most common use case.
constexpr void swap(compressed_pair< First, Second > &lhs, compressed_pair< First, Second > &rhs)
Swaps two compressed pair objects.
constexpr get_t< Type... > get
Variable template for lists of observed components.
basic_registry<> registry
Alias declaration for the most common use case.
@ ref
Aliasing mode, the object points to a non-const element.