▼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 > | |