| ▼Naether | |
| ►Ncollision | |
| CAABB | |
| Ccapsule | |
| Ccollision_result | |
| Cdetector | |
| Cdimension_traits | |
| Cdimension_traits< 3 > | |
| Cray | |
| Csegment | |
| Csphere | |
| ►Ncolour | |
| Chsv | |
| Crgb | |
| ►Ncompression | |
| Ccompression_config | Compression rules for given data context |
| Cpacked_reader | Representation of compressed data: |
| Cpacked_writer | |
| ►Ncontainer | |
| Cmax_heap | |
| Cring_buffer | |
| Cspan | |
| ►Necs | |
| ►Ndetail | |
| Cdeserializer_fallback | |
| Cdeserializer_fallback< T, std::enable_if_t< has_deserialization_context< T >::value > > | |
| Cfind_deserialization_context_type | |
| Cfind_manager_type | |
| Cfind_serialization_context_type | |
| Chas_deserialization_context | |
| Chas_deserialization_context< T, std::void_t< typename T::deserialization_context > > | |
| Chas_serialization_context | |
| Chas_serialization_context< T, std::void_t< typename T::serialization_context > > | |
| Cserde_deserialization_context | |
| Cserde_serialization_context | |
| Cserializer_fallback | |
| Cserializer_fallback< T, std::enable_if_t< has_serialization_context< T >::value > > | |
| Ccomponent_manager | |
| Cconstrained_ecs | |
| ►Cecs | |
| Cbehaviour_adapter | |
| Cconst_proxy | |
| Centity_subset | |
| Cglobal_deserialization_context | |
| Cglobal_serialization_context | |
| Copaque_iterator | |
| Cproxy | |
| Cupdate_set | |
| Cecs_collision_detector | |
| Cecs_collisions | |
| ►Ngeometry | |
| Chex_coord | |
| Cvec2f | |
| Cvec3f | |
| ►Nhash | |
| ►Chasher | |
| Cconstants | |
| Cconstants< uint32_t > | |
| Cconstants< uint64_t > | |
| Cpair_hash | |
| ►Ninternal | |
| Cglobal_state_process | |
| ►Nio | |
| ►Nbyte_order | |
| Cendian_buffer | |
| Cin_memory_reader | |
| Cin_memory_writer | |
| Creader | |
| Cwriter | |
| Czstd_reader | |
| Czstd_writer | Compress data before writing into the inferior writer |
| ►Nmessage | |
| ►Ntopic | |
| Ccustom | Custom publish/subscribe topic |
| Centity_id | Publish/Subscribe messages targetting particular entity |
| Cunclaimed_events | Subscribe to messages that were sent to a publisher_topic_type but didn't have any processes subscribed to their topic |
| Cuser_id | Publish/Subscribe messages targeting particular user |
| Call_workers | Message destination: all_workers |
| Cclosest_worker | Message destination: closest existing worker |
| Cglobal_state | Message destination: global_state |
| Cmessage | Represents messages received from an Aether process or a client |
| Creader | A source of messages to be deserialized and processed |
| Ctopic_list | Event destination: subscribers of the specified topics |
| Cwriter | A sink for messages to be sent by the process |
| ►Nmorton | |
| ►Ndetail | |
| Cinterval | |
| Cvalue_printer | |
| ►CAABB | |
| Cinterval_iterator | |
| Cintervals_range | |
| Caabb_merger | |
| Ccode_traits | |
| Cdimension_traits | |
| Cdimension_traits< 2 > | |
| Cdimension_traits< 3 > | |
| Cmorton_code | |
| Coperations | |
| Coperations< uint64_t, 2 > | |
| Coperations< uint64_t, 3 > | |
| Cregion | |
| Ctree_cell | |
| ►Nmpl | |
| Cat | |
| Cat< Index, std::tuple< Ls... > > | |
| Cconcat | |
| Cconcat< std::tuple< A, As... >, std::tuple< Bs... > > | |
| Cconcat< std::tuple<>, std::tuple< Bs... > > | |
| Ccons | |
| Ccons< T, std::tuple< Ls... > > | |
| Ccontains | |
| Ccontains< std::tuple< L, Ls... >, T > | |
| Ccontains< std::tuple< T, Ls... >, T > | |
| Ccontains< std::tuple<>, T > | |
| Cenable_if_t<(Width > 16 &&Width<=32)> | |
| Cenable_if_t<(Width > 32 &&Width<=64)> | |
| Cenable_if_t<(Width > 8 &&Width<=16)> | |
| Cenable_if_t<(Width<=8)> > | |
| Cfor_each_enumerated_helper | |
| Cfor_each_enumerated_helper< F, 0, Ls... > | |
| Cfor_each_helper | |
| Cfor_each_helper< F, 0, Ls... > | |
| Cgather_all | |
| Cgather_all< std::tuple< Ts... > > | |
| Cgather_optional | |
| Cgather_optional< std::tuple< maybe< Ms... >, maybe< Ns... >, Ts... > > | |
| Cgather_optional< std::tuple< maybe< Ms... >, T, Ts... > > | |
| Cgather_optional< std::tuple< maybe< Ts... > > > | |
| Cgather_optional< std::tuple< T, Ts... > > | |
| Cgather_optional< std::tuple<> > | |
| Cgather_required | |
| Cgather_required< std::tuple< maybe< Ms... >, Ts... > > | |
| Cgather_required< std::tuple< T, Ts... > > | |
| Cgather_required< std::tuple<> > | |
| Cindex_of | |
| Cindex_of< std::tuple< L, Ls... >, T > | |
| Cindex_of< std::tuple< T, Ls... >, T > | |
| Cindex_of< std::tuple<>, T > | |
| Cis_superset_of | |
| Cis_superset_of< B, std::tuple< A, As... > > | |
| Cis_superset_of< std::tuple< B... >, std::tuple<> > | |
| Cmake_maybe | |
| Cmake_maybe< std::tuple< Ts... > > | |
| Cmap | |
| Cmap< F, std::tuple< L, Ls... > > | |
| Cmap< F, std::tuple<> > | |
| Cmax_placeholder | |
| Cmax_placeholder< std::tuple< L, Ls... > > | |
| Cmax_placeholder< std::tuple<> > | |
| Cmaybe | |
| Csize | |
| Csize< std::tuple< Ls... > > | |
| Csubtract | |
| Csubtract< std::tuple< A, As... >, std::tuple< Bs... > > | |
| Csubtract< std::tuple<>, std::tuple< Bs... > > | |
| Cuint_exact | |
| Cuint_exact< Width, std::enable_if_t< Width==16 > > | |
| Cuint_exact< Width, std::enable_if_t< Width==32 > > | |
| Cuint_exact< Width, std::enable_if_t< Width==64 > > | |
| Cuint_exact< Width, std::enable_if_t< Width==8 > > | |
| Cuint_least | |
| Czip | |
| Czip< std::tuple< A, As... >, std::tuple< B, Bs... > > | |
| Czip< std::tuple<>, std::tuple<> > | |
| ►Nnetcode | |
| ►Ndetail | |
| Cblob_header | |
| Centity_handle | |
| Cspatial_bucket | |
| Cspatial_index_bucket | |
| Ctrivial_marshalling_config | |
| ►Ntranscode | |
| Cas_uint64 | |
| Cbit_appender | Densely pack a stream of bits into a byte array |
| Cbit_stream | Wraps an array of bytes and provides an interface for reading arbitrary number of bits from the array |
| Cboolean | Encodes a boolean value using 1 bit |
| Cclamp | Clamp a number to range [lower, upper] |
| Cfinite_int | Encodes a integer within [0, limit) using as little bits as possible |
| Cidentity | Copy T verbatim |
| Cinteger_delta_transform | Stateful transformer that XORs values |
| Coptional_struct_coder | A struct coder that can skip fields based on a bit mask |
| Coptional_struct_coder< T, struct_member< BM T::*, bit_mask_ptr, BitMaskCoder >, Spec... > | |
| Coptional_struct_coder_impl | |
| Coptional_struct_coder_impl< T, index, struct_member< BM T::*, bit_mask_ptr, BitMaskCoder >, struct_member< S T::*, ptr, Coder >, Rest... > | |
| Coptional_struct_coder_impl< T, index, BitMaskMember > | |
| CRebase | Transform a number from [old_base, +inf) to [0, +inf). By subtracting old_base |
| Cscale | Scale a number up by scale |
| Cstruct_coder | Encode a C++ struct according to Spec |
| Cstruct_coder< T > | Ditto |
| Cstruct_coder< T, struct_member< S T::*, ptr, Coder >, Rest... > | Ditto |
| Cstruct_member | |
| Cstruct_member< T S::*, ptr, Coder > | Represents a member in the struct, and how it should be encoded |
| Cto_integer | Cast a float point number to integer |
| Ctranscode_base | Base interface for Transcoders |
| Ctransform_base | Base for transformers |
| Ctransform_coder | A coder that transforms the input with Transformer, then encodes it with Coder |
| Ctransform_compose | |
| Cconnection_state | State associated with a connection to a client |
| Ccontrolled_entity | Represents an entity controlled by an external client |
| Cdemarshaller | |
| ►Centity_store | |
| Cmetadata_type | |
| Cgeneric_interest_policy | Defines a policy for rescheduled entities based on the distance of the entity from the player's entities based on a series of rings with a corresponding delay |
| Cgeneric_netcode | The state associated with a muxer thread |
| Cmarshaller | |
| Cmarshalling_factory | |
| Cpacket_priority | Represents the priority of a message to be sent |
| Cspatial_index | |
| Ctrivial_demarshaller | |
| Ctrivial_marshaller | |
| Ctrivial_marshalling | |
| Cworker_state | State associated with a worker |
| ►Nphysx | |
| Cerror_callback | |
| ►Cphysx_c | |
| Cdeserialization_context | |
| Cserialization_context | |
| Cphysx_state | |
| ►Nprotocol | |
| ►Nreplication | |
| ►Ndetail | |
| Cmsgbuf | |
| Cclient | Repclication client |
| Cprotocol | |
| ►Nrigidbody | |
| Ccontact | |
| Cphysics_state | |
| ►Nserde | |
| Cfixed_size_buffered_writer | |
| Cis_memcopyable | |
| Creader_deserializer | |
| Cserde_load_helper | |
| Cserde_load_seq | |
| Cserde_load_seq< SD, T, typename std::enable_if< is_memcopyable< T >::value >::type > | |
| Cserde_save_helper | |
| Cserde_save_seq | |
| Cserde_save_seq< SD, T, typename std::enable_if< is_memcopyable< T >::value >::type > | |
| Cvalue | |
| Cvalue | |
| Cvalue | |
| Cvalue | |
| Cvalue | |
| Cvalue | |
| Cwriter_serializer | |
| ►Ntcp | |
| Casync_connector | |
| Cconnect_result | |
| Carguments | The arguments passed to AetherEngine on startup |
| Caws_bucket | Makes a connection to aws to retrieve objects from an s3 bucket the sercurity is configure using the following environemt variables: |
| Cblob | Manages a memory area and provides access to it via an aether::container::span |
| Cblob_store | Blob_store is used to fetch a blob object asynchronously from a server |
| Ccell_state | This is the state of the worker as it pertains to the manager |
| Cclosure | |
| Cclosure< R(Args...)> | |
| Cdefault_aabb | Default formula for calculating Axis Aligned Bounding Box for the given agent |
| Cdefault_agent_center | Default formula for calculating the center of the given agent |
| Cdefault_handover | |
| ►Cdefault_sim_state | This is the default implementation of cell state without using the ecs |
| COpaqueIterator | This must be implemented as part of cell_state |
| Cdimension_traits | Traits for D-Dimentional morton codes |
| Cdimension_traits< 2 > | 2-Dimentional morton code traits |
| Cdimension_traits< 3 > | 3-Dimentional morton code traits |
| Centity_based_user_state | The class defines an interface that should be implemented in order to build an entity based simulation |
| Centity_based_user_state_adapter | |
| Centity_based_user_state_base | The class makes it simpler to create a simulation by providing default implementations for many functions required by the entity_based_user_state interface |
| Cexternal_storage_base | Base class for implementing write access to external storage, used by aether::entity_based_user_state::build_external_storage and aether::global_state_base::build_external_storage |
| Cexternal_storage_iface | The interface for implementing write access to extenal storage, used by aether::entity_based_user_state::build_external_storage and aether::global_state_base::build_external_storage |
| Cglobal_state_base | A base type for a global state process implementation |
| Chttp_store | Makes an anonymous connection to an http or https server to retrieve a blob |
| Cmachine_id | |
| Cmonostate | |
| Cmuxer_machine | |
| Cmuxers_config | |
| Cnull_external_storage | An empty external storage implementation, used when no external storage is configured |
| Coctree | The main class of the Aether engine which manages all the processes |
| Coctree_impl | |
| Coctree_params_default | Describes parameters for aether::octree |
| Coctree_traits | |
| Cprocess_allocation | Describes how many worker processes are supported by each machine and how many are free |
| Cregion | Represents a region in space using discretized coordinates |
| Crun_id | |
| Csemaphore_guard | The class semaphore_guard is a posix semaphore wrapper that provides a RAII-style mechanism for owning a semaphore for the duration of a scoped block |
| Cstatistics | |
| Cstorage_state | State of the simulation as seen from external_storage_iface implementation |
| Cuser_cell_state_interface | |
| Cworker_id | Represents a worker id, used to identify the different processes |
| ▼Nhadean | |
| ►Nlog | |
| Cdefault_logger | |
| ►Cglobal_logger_type | |
| Cinit_params | |
| Clogger | |
| Clogger_factory | |
| ►Nmetrics | |
| Cresource_diff | |
| Cresource_instant | |
| ▼Nstd | STL namespace |
| Chash< aether::machine_id > | |
| Chash< aether::netcode::detail::entity_handle > | |
| Chash< aether::netcode::detail::spatial_bucket< T > > | |
| Chash< aether::worker_id > | |
