| ►Nentt | EnTT default namespace |
| Cdense_map | Associative container for key-value pairs with unique keys |
| Cdense_set | Associative container for unique objects of a given type |
| Cstd_sort | Function object to wrap std::sort in a class type |
| Cinsertion_sort | Function object for performing insertion sort |
| Cradix_sort | Function object for performing LSD radix sort |
| Cbasic_any | A SBO friendly, type-safe container for single values of any type |
| Ccompressed_pair | A compressed pair |
| Cenum_as_bitmask | Enable bitmask support for enum classes |
| Cenum_as_bitmask< Type, std::void_t< decltype(Type::_entt_enum_as_bitmask)> > | Enable bitmask support for enum classes. |
| Cfamily | Dynamic identifier generator |
| Cbasic_hashed_string | Zero overhead unique identifier |
| Cidentifier | Types identifiers |
| Cinput_iterator_pointer | Helper type to use as pointer with input iterators |
| Citerable_adaptor | Utility class to create an iterable object from a pair of iterators |
| Callocation_deleter | Deleter for allocator-aware unique pointers (waiting for C++20) |
| Cmonostate | Minimal implementation of the monostate pattern |
| Ctype_index | Type sequential identifier |
| Ctype_hash | Type hash |
| Ctype_name | Type name |
| Ctype_info | Implementation specific information about a type |
| Cchoice_t | Utility class to disambiguate overloaded functions |
| Cchoice_t< 0 > | Utility class to disambiguate overloaded functions. |
| Ctype_identity | Identity type trait |
| Csize_of | A type-only sizeof wrapper that returns 0 where sizeof complains |
| Csize_of< Type, std::void_t< decltype(sizeof(Type))> > | A type-only sizeof wrapper that returns 0 where sizeof complains. |
| Ctype_list | A class to use to push around lists of types, nothing more |
| Ctype_list_element | Primary template isn't defined on purpose |
| Ctype_list_element< Index, type_list< Type, Other... > > | Provides compile-time indexed access to the types of a type list |
| Ctype_list_element< 0u, type_list< Type, Other... > > | Provides compile-time indexed access to the types of a type list |
| Ctype_list_cat | Primary template isn't defined on purpose |
| Ctype_list_cat<> | Concatenates multiple type lists |
| Ctype_list_cat< type_list< Type... >, type_list< Other... >, List... > | Concatenates multiple type lists |
| Ctype_list_cat< type_list< Type... > > | Concatenates multiple type lists |
| Ctype_list_unique | Primary template isn't defined on purpose |
| Ctype_list_unique< type_list< Type, Other... > > | Removes duplicates types from a type list |
| Ctype_list_unique< type_list<> > | Removes duplicates types from a type list |
| Ctype_list_contains | Provides the member constant value to true if a type list contains a given type, false otherwise |
| Ctype_list_contains< type_list< Type... >, Other > | Provides the member constant value to true if a type list contains a given type, false otherwise. |
| Ctype_list_diff | Primary template isn't defined on purpose |
| Ctype_list_diff< type_list< Type... >, type_list< Other... > > | Computes the difference between two type lists |
| Cvalue_list | A class to use to push around lists of constant values, nothing more |
| Cvalue_list_element | Primary template isn't defined on purpose |
| Cvalue_list_element< Index, value_list< Value, Other... > > | Provides compile-time indexed access to the values of a value list |
| Cvalue_list_element< 0u, value_list< Value, Other... > > | Provides compile-time indexed access to the types of a type list |
| Cvalue_list_cat | Primary template isn't defined on purpose |
| Cvalue_list_cat<> | Concatenates multiple value lists |
| Cvalue_list_cat< value_list< Value... >, value_list< Other... >, List... > | Concatenates multiple value lists |
| Cvalue_list_cat< value_list< Value... > > | Concatenates multiple value lists |
| Cis_applicable | Same as std::is_invocable, but with tuples |
| Cis_applicable< Func, Tuple< Args... > > | Same as std::is_invocable, but with tuples. |
| Cis_applicable< Func, const Tuple< Args... > > | Same as std::is_invocable, but with tuples. |
| Cis_applicable_r | Same as std::is_invocable_r, but with tuples for arguments |
| Cis_applicable_r< Ret, Func, std::tuple< Args... > > | Same as std::is_invocable_r, but with tuples for arguments. |
| Cis_complete | Provides the member constant value to true if a given type is complete, false otherwise |
| Cis_complete< Type, std::void_t< decltype(sizeof(Type))> > | Provides the member constant value to true if a given type is complete, false otherwise. |
| Cis_iterator | Provides the member constant value to true if a given type is an iterator, false otherwise |
| Cis_iterator< Type, std::enable_if_t<!std::is_same_v< std::remove_const_t< std::remove_pointer_t< Type > >, void > > > | Provides the member constant value to true if a given type is an iterator, false otherwise. |
| Cis_ebco_eligible | Provides the member constant value to true if a given type is both an empty and non-final class, false otherwise |
| Cis_transparent | Provides the member constant value to true if Type::is_transparent is valid and denotes a type, false otherwise |
| Cis_transparent< Type, std::void_t< typename Type::is_transparent > > | Provides the member constant value to true if Type::is_transparent is valid and denotes a type, false otherwise. |
| Cis_equality_comparable | Provides the member constant value to true if a given type is equality comparable, false otherwise |
| Cis_equality_comparable< Type, std::void_t< decltype(std::declval< Type >()==std::declval< Type >())> > | Provides the member constant value to true if a given type is equality comparable, false otherwise. |
| Cconstness_as | Transcribes the constness of a type to another type |
| Cconstness_as< To, const From > | Transcribes the constness of a type to another type. |
| Cmember_class | Extracts the class of a non-static member object or function |
| Cidentity | Identity function object (waiting for C++20) |
| Coverloaded | Helper type for visitors |
| Cy_combinator | Basic implementation of a y-combinator |
| Ccomponent_traits | Common way to access various properties of components |
| Centt_traits | Entity traits |
| Cnull_t | Null object for all identifiers.
|
| Ctombstone_t | Tombstone object for all identifiers.
|
| Cbasic_sparse_set | Basic sparse set implementation |
| Cbasic_storage | Basic storage implementation |
| Cbasic_registry | Fast and reliable entity-component system |
| Cbasic_view | View implementation |
| Cbasic_runtime_view | Runtime view implementation |
| Cbasic_group | Group |
| Cbasic_observer | Observer |
| ►Cbasic_organizer | Utility class for creating a static task graph |
| Cvertex | Vertex type of a task graph defined as an adjacency list |
| Cbasic_handle | Non-owning handle to an entity |
| Cbasic_snapshot | Utility class to create snapshots from a registry |
| Cbasic_snapshot_loader | Utility class to restore a snapshot as a whole |
| Cbasic_continuous_loader | Utility class for continuous loading |
| Cbasic_group< Entity, owned_t<>, get_t< Get... >, exclude_t< Exclude... > > | Non-owning group |
| Cbasic_group< Entity, owned_t< Owned... >, get_t< Get... >, exclude_t< Exclude... > > | Owning group |
| Cas_view | Converts a registry to a view |
| Cas_group | Converts a registry to a group |
| Cmatcher | Grouping matcher |
| Cbasic_collector | Collector |
| Cbasic_collector<> | Collector |
| Cbasic_collector< matcher< type_list< Reject... >, type_list< Require... >, Rule... >, Other... > | Collector |
| Cbasic_runtime_view< basic_sparse_set< Entity, Allocator > > | Generic runtime view |
| Csigh_storage_mixin | Mixin type used to add signal support to storage types |
| Cbasic_storage< Entity, Type, Allocator, std::enable_if_t< ignore_as_empty_v< Type > > > | Default constructor. |
| Cstorage_traits | Provides a common way to access certain properties of storage types |
| Cexclude_t | Alias for exclusion lists |
| Cget_t | Alias for lists of observed components |
| Cowned_t | Alias for lists of owned components |
| Cbasic_view< Entity, get_t< Component... >, exclude_t< Exclude... > > | Multi component view |
| Cbasic_view< Entity, get_t< Component >, exclude_t<>, std::void_t< std::enable_if_t<!component_traits< std::remove_const_t< Component > >::in_place_delete > > > | Single component view specialization |
| Clocator | Service locator, nothing more |
| Cadl_meta_pointer_like | Fake ADL based lookup function for meta pointer-like types |
| Cmeta_sequence_container_traits< std::vector< Type, Args... > > | Meta sequence container traits for std::vectors of any type |
| Cmeta_sequence_container_traits< std::array< Type, N > > | Meta sequence container traits for std::arrays of any type |
| Cmeta_associative_container_traits< std::map< Key, Value, Args... > > | Meta associative container traits for std::maps of any type |
| Cmeta_associative_container_traits< std::unordered_map< Key, Value, Args... > > | Meta associative container traits for std::unordered_maps of any type |
| Cmeta_associative_container_traits< std::set< Key, Args... > > | Meta associative container traits for std::sets of any type |
| Cmeta_associative_container_traits< std::unordered_set< Key, Args... > > | Meta associative container traits for std::unordered_sets of any type |
| Cmeta_associative_container_traits< dense_map< Key, Type, Args... > > | Meta associative container traits for dense_maps of any type |
| Cmeta_associative_container_traits< dense_set< Type, Args... > > | Meta associative container traits for dense_sets of any type |
| Cmeta_ctx | Opaque container for a meta context |
| Cmeta_factory | Meta factory to be used for reflection purposes |
| Cmeta_factory< Type, Spec... > | Extended meta factory to be used for reflection purposes |
| Cmeta_factory< Type > | Basic meta factory to be used for reflection purposes |
| Cmeta_sequence_container | Proxy object for sequence containers |
| Cmeta_associative_container | Proxy object for associative containers |
| Cmeta_any | Opaque wrapper for values of any type |
| Cmeta_handle | Opaque pointers to instances of any type |
| Cmeta_prop | Opaque wrapper for properties of any type |
| Cmeta_data | Opaque wrapper for data members |
| Cmeta_func | Opaque wrapper for member functions |
| Cmeta_type | Opaque wrapper for types |
| Cis_meta_pointer_like< Type * > | Makes plain pointers pointer-like types for the meta system |
| Cis_meta_pointer_like< Type(*)[N]> | Partial specialization used to reject pointers to arrays |
| Cis_meta_pointer_like< std::shared_ptr< Type > > | Makes std::shared_ptrs of any type pointer-like types for the meta system |
| Cis_meta_pointer_like< std::unique_ptr< Type, Args... > > | Makes std::unique_ptrs of any type pointer-like types for the meta system |
| Cas_ref_t | Empty class type used to request the as ref policy |
| Cas_cref_t | Empty class type used to request the as cref policy |
| Cas_is_t | Empty class type used to request the as-is policy |
| Cas_void_t | Empty class type used to request the as void policy |
| Cmeta_range | Iterable range to use to iterate all types of meta objects |
| Cmeta_class_template_tag | Utility class to disambiguate class templates |
| Cmeta_template_traits< Clazz< Args... > > | General purpose traits class for generating meta template information |
| Cmeta_template_traits | Traits class template to be specialized to enable support for meta template information |
| Cmeta_sequence_container_traits | Traits class template to be specialized to enable support for meta sequence containers |
| Cmeta_associative_container_traits | Traits class template to be specialized to enable support for meta associative containers |
| Cis_meta_pointer_like | Provides the member constant value to true if a given type is a pointer-like type from the point of view of the meta system, false otherwise |
| Cis_meta_pointer_like< const Type > | Partial specialization to ensure that const pointer-like types are also accepted |
| Cmeta_function_descriptor | Primary template isn't defined on purpose |
| Cmeta_function_descriptor< Type, Ret(Class::*)(Args...) const > | Meta function descriptor |
| Cmeta_function_descriptor< Type, Ret(Class::*)(Args...)> | Meta function descriptor |
| Cmeta_function_descriptor< Type, Ret Class::* > | Meta function descriptor |
| Cmeta_function_descriptor< Type, Ret(*)(MaybeType, Args...)> | Meta function descriptor |
| Cmeta_function_descriptor< Type, Ret(*)()> | Meta function descriptor |
| Cmeta_function_helper | Meta function helper |
| Cbasic_poly | Static polymorphism made simple and within everyone's reach |
| Cpoly_inspector | Inspector class used to infer the type of the virtual table |
| Cpoly_vtable | Static virtual table factory |
| Cpoly_base | Poly base class used to inject functionalities into concepts |
| Cprocess | Base class for processes |
| Cprocess_adaptor | Adaptor for lambdas and functors to turn them into processes |
| Cscheduler | Cooperative scheduler for processes |
| Cresource_cache | Basic cache for resources of any type |
| Cresource_loader | Transparent loader for shared resources |
| Cresource | Basic resource handle |
| Cconnect_arg_t | Used to wrap a function or a member of a specified type |
| Cdelegate | Basic delegate implementation |
| Cdelegate< Ret(Args...)> | Utility class to use to send around functions and members |
| Cbasic_dispatcher | Basic dispatcher implementation |
| ►Cemitter | General purpose event emitter |
| Cconnection | Generic connection type for events |
| Csink | Sink class |
| Csigh | Unmanaged signal handler |
| Csigh< Ret(Args...), Allocator > | Unmanaged signal handler |
| Cconnection | Connection class |
| Cscoped_connection | Scoped connection class |
| Csink< sigh< Ret(Args...), Allocator > > | Sink class |
| ►Nstd | |
| Ctuple_size< entt::compressed_pair< First, Second > > | std::tuple_size specialization for compressed_pairs |
| Ctuple_element< Index, entt::compressed_pair< First, Second > > | std::tuple_element specialization for compressed_pairs |
