Classes
The classes, structs, union and interfaces used by this project are:
| S aabb<T> | Axis-Aligned Bounding Box for spatial culling and collision detection |
| C AabbColliderComponent | Component that defines an Axis-Aligned Bounding Box (AABB) for physics interactions |
| S ActionIdTag | Tag type for ActionId |
| S Active | Tag component indicating that an entity is active |
| C ActiveViewportIdsStateComponent | Stores the currently active viewport IDs based on game/match state |
| C AiBuilder | Builder for configuring AI behavior components |
| C Aim2DCommand | Command that applies 2D aiming direction to a GameObject |
| C Aim2DComponent | Component for handling 2D aiming direction and fire frequency |
| C Application | Class providing the entry point for a helios application |
| C GLFWApplication | An Application implementation for glfw-based environments |
| C ApplyDamageCommand | Command that carries a DamageContext for deferred damage processing |
| S BounceResult | Result of a bounce calculation against level bounds |
| C BoundsUpdateSystem | System that updates AABB colliders based on entity transforms |
| C Buffer | Abstract base class for type-erased buffer implementations |
| C ReadWriteBuffer<T> | Combined read-write buffer with immediate visibility |
| C Camera | Represents a camera for perspective or orthographic projection |
| S CameraEntry | |
| C ChaseComponent | Component storing chase behavior data |
| C ChaseConfig | Fluent configuration for AI chase behavior |
| C ChaseSystem | System that steers entities towards their chase targets |
| C CollisionBuilder | Builder for configuring collision detection components |
| S CollisionCandidate | Internal structure holding references to a potential collision candidate |
| C CollisionComponent | Defines collision layer membership and interaction masks for a GameObject |
| C CollisionConfig | Fluent configuration for collision detection setup |
| S CollisionContext | Context data describing a collision event |
| C CollisionStateClearSystem | System that clears collision state components at the end of each frame |
| C CollisionStateComponent | Stores per-frame collision state for a GameObject |
| C CollisionStateResponseSystem | System that processes collision states and executes configured behaviors |
| S CollisionStruct | Helper-struct representing the properties and interaction state of a collision event between two entities |
| S Colors | Standard color palette providing commonly used colors as vec4f (RGBA) |
| C CombatBuilder | Builder for configuring weapon and projectile components |
| C CombatConfig | |
| C CombatScoringSystem | System that processes death events and awards scores |
| C CombinedStateToIdMapPair<...> | Maps combined state pairs directly to ID lists |
| C CommandBuffer | Type-erased wrapper for command buffers using the Concept/Model pattern |
| S CommandBufferRole | Compile-time tag identifying a class as a CommandBuffer |
| C CommandBufferTypeId | Unique type identifier for command buffer types |
| S CommandHandlerEntry | Type-erased storage entry for a registered command handler |
| S CommandHandlerRef<CommandType> | Typed reference wrapper for invoking a registered handler |
| C CommandHandlerRegistry | Registry that maps CommandType types to handler instances via function pointers |
| C CommandTypeId | Unique type identifier for command types |
| S ComponentOps | Container for type-erased component lifecycle function pointers |
| C ComponentOpsRegistry | Global registry for component lifecycle function pointers |
| C ComponentReflector | Generates and registers ComponentOps for a component type |
| C ComponentTypeId | Unique type identifier for component types |
| C ComposeTransformComponent | Component that holds transformation data (position, rotation, scale) |
| C ComposeTransformSystem | System that composes the final ComposeTransformComponent from state components |
| C Concept | Internal virtual interface for type-erased dispatch |
| C Concept | Internal virtual interface for type erasure |
| C Concept | Internal virtual interface for type erasure |
| C ConceptModelRegistry<AnyT, IdProvider> | Generic type-indexed registry for type-erased wrapper instances |
| S ConstIterator | Const forward iterator for traversing the sparse set |
| S ConstIterator | Const forward iterator for traversing the sparse set |
| C Controller | Abstract base class for application controllers |
| C WindowRenderingController | Abstract base controller for handling window related events |
| C BasicWindowRenderingController | Basic implementation of a window rendering controller |
| S DamageContext | Extends InteractionContext with a damage amount |
| C DamageDealerComponent | Component that stores damage values per collision layer |
| C DamageOnCollisionSystem | Emits HealthChangedEvents when solid collisions involve damage dealers |
| C DeadTagComponent | Marker component attached to entities whose health has been depleted |
| C DeadzoneStrategy | Abstract strategy interface for normalizing gamepad stick input with deadzone handling |
| C RadialDeadzoneStrategy | Implements a radial (circular) deadzone strategy for analog stick normalization |
| C DefaultGameStateTransitionRules | Provides the default set of game state transition rules |
| C DefaultMatchStateTransitionGuards | Provides default guard functions for match state transitions |
| C DefaultMatchStateTransitionRules | Provides the default set of match state transition rules |
| S DeferredComponent | Internal structure tracking a deferred component |
| C DelayedComponentEnabler | Component that manages delayed activation of other components |
| C DelayedComponentEnablerSystem | System that processes delayed component activations each frame |
| C DelayedStateCommand<StateType> | Command that pairs a state transition request with a timer |
| C DenseRuntimeHandleRegistry<...> | Maps strong identifiers to dense, contiguous runtime indices |
| C DespawnCommand | Command to request despawning of a GameObject |
| C DirectionComponent | Component that holds a normalized direction vector |
| C Dispatcher | A generic event Dispatcher for type-safe event handling |
| C DoubleBuffer | Abstract base class for type-erased message buffers |
| C ReadWriteDoubleBuffer<T> | Type-safe double-buffered container for messages of type T |
| C EffectsBuilder | Builder for configuring visual effects components |
| C EmittedByComponent | Component that tracks which entity emitted/spawned this object |
| S EmitterContext | Context data from the entity that triggered a spawn operation |
| C EngineCommandBuffer | Concrete command buffer pre-configured with all engine command types |
| S EntityHandle<TStrongId> | A versioned handle for referencing entities in a registry |
| S EntityHandle | A versioned handle for referencing entities in an EntityPool |
| S EntityHandlePairHash | Hash functor for pairs of EntityHandles |
| C EntityManager | Manages entities and their associated components |
| C EntityRegistry<...> | Generic registry for creating and managing strongly-typed entity handles |
| C EntityRegistry | Central registry for creating and managing entity handles |
| S EntityResolver | Callable that resolves an EntityHandle to a GameObject |
| S ErasedUnique | Type-erased unique ownership wrapper |
| C Event | Base class for events in the helios framework |
| C WindowEvent | Abstract base class for Window related events |
| C FrameBufferResizeEvent | Event representing a change in the framebuffer's size |
| C EventManager | An abstract EventManager managing the buffering and dispatching of events, acting as a central hub for event management |
| C BasicEventManager | Basic implementation of the EventManager |
| C EventQueue | Abstract base class defining an interface for an EventQueue |
| C DequeEventQueue | Concrete implementation of an EventQueue that uses a Deque as its underlying queue strategy. Adding and removing events follows a FIFO strategy |
| S FontCache | Internal cache structure for a single font's glyphs |
| S FontIdTag | Tag type for FontId |
| C FontResourceProvider | Abstract interface for loading fonts and providing glyph data |
| C FreeTypeFontResourceManager | FreeType-based implementation of `FontResourceProvider` for OpenGL |
| C FpsMetrics | Aggregates and analyzes frame timing data over a rolling window |
| C FramePacer | Controls and maintains a target frame rate through precise timing and pacing |
| S FrameStats | Contains timing statistics for a single frame |
| C FrustumCullingStrategy | Abstract base class for implementing frustum culling strategies |
| C CullNoneStrategy | A default FrustumCullingStrategy that simply returns all SceneNodes found, e.g. no culling is applied |
| C GameFlowSystem | System that drives automatic game state transitions |
| S GameLoopEventBusGroup | Tag type for the game loop event bus index space |
| C GameObject | Lightweight facade for entity component manipulation |
| C GameObjectFactory | Factory class for creating and cloning GameObjects |
| C GameObjectLifecycleSystem | Reacts to HealthDepletedEvents and despawns or deactivates entities |
| C GameObjectPool | Object pool for efficient GameObject lifecycle management |
| S GameObjectPoolConfig | Configuration structure for creating a GameObjectPool |
| S GameObjectPoolIdTag | Tag type for GameObjectPoolId |
| C GameObjectPoolManager | High-level manager for GameObject pooling operations |
| C GameObjectPoolRegistry | Central registry for managing multiple named GameObjectPools |
| S GameObjectPoolSnapshot | Immutable snapshot of a GameObjectPool's current state |
| C GameObjectPrototype | Internal builder class for fluent GameObject configuration |
| C GameObjectSpawnSystem | |
| C GamepadSettings | Configuration class for gamepad input normalization and axis behavior |
| C GamepadState | A lightweight class for transferring the state of a Gamepad |
| C GameStateInputResponseSystem | Responds to gamepad input and issues game state commands |
| C GameTimer | A game timer identified by a GameTimerId |
| C GameTimer2UiTextUpdateSystem | System for binding game timer values to UI text components |
| C GameTimerBindingComponent | Component that tracks the revision of a specific GameTimer |
| C GameTimerClearSystem | Resets finished game timers to an undefined state |
| S GameTimerIdTag | Tag type for GameTimerId |
| C GameTimerUpdateSystem | Updates all game timers managed by the TimerManager |
| C GameWorld | Central game state container for entities, resources, and the active level |
| C GfxEffectsConfig | Fluent configuration for visual effects |
| C GLFWFactory | Factory class for creating pre-configured GLFW-specific application components |
| C GLFWRAIIGuard | A RAII Guard for GLFW |
| S GLFWWindowUserPointer | A structure to hold user defined data associated with a GLFWwindow |
| S Glyph | Represents a single rendered glyph (character) from a font |
| S GridCell | Represents a single cell in the spatial partitioning grid |
| C GridCollisionDetectionSystem | Collision detection system using uniform spatial partitioning for Broadphase and AABB overlaps in the Narrowphase |
| C Guid | Representative of a Globally Unique Identifier |
| S hash<...> | Hash specialization for RuntimeHandle |
| S hash<...> | |
| S hash<...> | Hash specialization for EntityHandle |
| S hash<helios::engine::ecs::EntityHandle> | Hash specialization for EntityHandle |
| S hash<...> | std::hash specialization for ComponentTypeId |
| S hash<...> | std::hash specialization for ScoreTypeId |
| S hash<...> | Hash specialization for SceneId |
| S hash<...> | Hash specialization for ActionId |
| S hash<...> | Hash specialization for FontId |
| S hash<...> | Hash specialization for CommandBufferTypeId |
| S hash<...> | Hash specialization for CommandTypeId |
| S hash<...> | Hash specialization for GameObjectPoolId |
| S hash<...> | Hash specialization for SpawnProfileId |
| S hash<...> | Hash specialization for SpawnRuleId |
| S hash<...> | Hash specialization for ManagerTypeId |
| S hash<...> | Hash specialization for ResourceTypeId |
| S hash<...> | Hash specialization for SystemTypeId |
| S hash<...> | std::hash specialization for StateTypeId |
| S hash<helios::util::Guid> | |
| C HashedLookupStrategy | Lookup strategy using an unordered set for O(1) amortized lookups |
| C HealthBuilder | Builder for configuring health-related components |
| S HealthChangeContext | Describes a health modification applied to an entity |
| C HealthChangedEvent | Event carrying details of a health modification |
| C HealthComponent | Component for tracking entity health and damage |
| C HealthConfig | Fluent configuration for HealthComponent setup |
| C HealthDepletedEvent | Event emitted when an entity's health reaches zero |
| C HealthManager | Manager that processes damage commands and updates entity health |
| C HealthUpdateClearSystem | Clears the dirty flag on every active HealthComponent |
| S helios_engine_common_tag_CommandTypes | Tag type for the TypeIndexer domain |
| S helios_engine_common_tag_CommandTypes | Tag type for the TypeIndexer domain |
| S helios_engine_common_tag_ComponentTypes | Tag type for the TypeIndexer domain |
| S helios_engine_common_tag_ResourceTypes | Tag type for the TypeIndexer domain |
| S helios_engine_common_tag_ResourceTypes | Tag type for the TypeIndexer domain |
| S helios_engine_common_tag_ScoreTypes | Tag type for the TypeIndexer domain |
| S helios_engine_common_tag_StateTypes | Tag type for the TypeIndexer domain |
| S helios_engine_common_tag_SystemTypes | Tag type for the TypeIndexer domain |
| C HierarchyComponent | Stores parent-child relationships for hierarchical entity graphs |
| C HierarchyPropagationSystem | Propagates activation state from parent to child entities |
| C ImGuiBackend | Platform-agnostic interface for ImGui backend implementations |
| C ImGuiGlfwOpenGLBackend | ImGui backend for GLFW windowing and OpenGL 4.6 rendering |
| C ImGuiOverlay | Central manager for ImGui widgets rendered via a specific backend |
| C ImGuiWidget | Abstract base class for ImGui widgets rendered in debug overlays |
| C CameraWidget | Debug widget for real-time camera parameter control and visualization |
| C FpsWidget | Debug widget for real-time FPS metrics and frame pacing configuration |
| C GamepadSettingsWidget | A configuration widget for adjusting gamepad input settings |
| C GamepadWidget | A debug widget to visualize the state of a specific gamepad |
| C LogWidget | Debug widget for displaying log output in a scrollable ImGui panel |
| C MainMenuWidget | Main menu bar providing access to application settings |
| S Inactive | Tag component indicating that an entity is inactive |
| C InputAdapter | Abstract interface for platform-specific input adapters |
| C GLFWInputAdapter | InputAdapter implementation for a GLFWWindow |
| C InputManager | InputManager providing access to various input states |
| C InputSnapshot | Immutable snapshot capturing input state at a specific point in time |
| S InteractionContext | Describes a generic interaction between entities |
| S InvalidStateTransitionId | Placeholder type for missing specializations |
| S Iterator | Forward iterator for traversing the sparse set |
| S Iterator | Forward iterator for traversing the sparse set |
| S Iterator | Forward iterator for View traversal |
| C LastDamageComponent | Component that stores information about the last damage received |
| C LegacyRenderPass | Encapsulates a single rendering pass with its associated resources |
| C Level | Represents a game level containing the scene graph and world boundaries |
| C LevelBoundsBehaviorComponent | Component that defines how an entity reacts to level boundaries |
| C LevelBoundsBehaviorSystem | System that handles entity behavior when colliding with level boundaries |
| C LevelBoundsCollisionConfig | Fluent configuration for level boundary collision behavior |
| C LifecycleBuilder | Builder for lifecycle management and component activation timing |
| C LifecycleConfig | Configuration for lifecycle management on a GameObject |
| C LinearLookupStrategy | Lookup strategy using a flat vector with linear scan |
| C Lives2UiTextUpdateSystem | Updates UiTextComponents bound to a LivesComponent via LivesBindingComponent |
| C LivesBindingComponent | Binds a UI entity to the LivesComponent of a target entity |
| C LivesComponent | Tracks the remaining lives of an entity |
| S LogEntry | Represents a single log entry with level, scope, and message |
| C Logger | Logger implementation with configurable output sinks |
| C LogManager | LogManager for managing scoped Loggers and global sink configuration |
| C Manager | Type-erased wrapper for game world managers |
| S ManagerRole | Compile-time tag identifying a class as a Manager |
| C ManagerTypeId | Unique type identifier for engine resources |
| S mat4<T> | Represents a 4x4 matrix, stored in column-major order |
| C MatchFlowSystem | Automatically advances the match through its state phases |
| C MatchRuleSystem | Evaluates match rules and conditions |
| C Material | Represents a parameterizable material |
| C MaterialShaderProperties | Represents a Value Object for an immutable set of material properties |
| S MaterialShaderPropertiesOverride | Configuration container for overriding specific material properties |
| C MaxScore2UiTextUpdateSystem | System for binding high score values to UI text components |
| C MaxScoreObserverClearSystem | System that resets the hasUpdate flag on all MaxScoreObserverComponents |
| C MaxScoreObserverComponent | Component that observes and caches the high score value from a ScorePool |
| C MaxScoreObserverSystem | System that propagates high score snapshots to MaxScoreObserverComponents |
| S MaxScorePoolSnapshot | Immutable snapshot of a ScorePool's high score state |
| C MenuBuilder | Builder for creating menu and menu item configurations |
| C MenuComponent | Manages a collection of menu items for UI navigation |
| C MenuConfig | Fluent configuration for menu GameObjects |
| C MenuDisplaySystem<StateLft, StateRgt> | Controls menu visibility based on game and match state |
| S MenuIdTag | Tag type for MenuId |
| C MenuItemConfig | Fluent configuration for menu item GameObjects |
| C MenuNavigationSystem | Handles gamepad input for menu navigation |
| C Mesh | Representative of a renderable 3D mesh |
| C OpenGLMesh | Representative of an OpenGLMesh. This class manages the OpenGL Vertex Array Object (VAO), the Vertex Buffer Object (VBO) and Element Buffer Object (EBO) handles. The raw mesh data is uploaded to the GPU, preparing it for subsequent rendering commands / draw calls |
| S MeshConfig | Configuration for how a Mesh's data should be interpreted and rendered |
| C MeshRenderableConfig | Fluent configuration for setting up a Renderable on a GameObject |
| C MeshRenderCommand | DTO for storing rendering-specific command information to be passed to the RenderQueue |
| C MeshRenderer | Abstract base class for mesh rendering operations |
| C OpenGLMeshRenderer | OpenGL implementation of the MeshRenderer interface |
| C Model<T> | Typed model that adapts a concrete buffer to the Concept interface |
| C Model<T> | Typed wrapper that adapts a concrete manager to the Concept interface |
| C Model<T> | Typed wrapper that adapts a concrete system to the Concept interface |
| C ModelAabbComponent | Component that stores the canonical Axis-Aligned Bounding Box (AABB) of a model |
| C MotionBuilder | Builder for configuring movement and steering components |
| C Move2DCommand | Command that applies 2D directional movement to a GameObject |
| C Move2DComponent | Component for 2D physics-based movement |
| C Move2DConfig | Fluent configuration for 2D movement behavior |
| C Move2DSystem | System that processes 2D movement for entities |
| S no_init_t | Tag type used to indicate skipping default initialization |
| C NumberFormatterComponent | Component that formats arithmetic values into a display string |
| C ObserverBuilder | Builder for configuring observer components |
| C ObserverConfig | Fluent configuration for observer component setup |
| C OpenGLShader | An OpenGL-specific implementation of a Shader program, consisting of a vertex and a fragment shader |
| C OpenGLUniformLocationMap | Manages the mapping between OpenGL uniform semantics and their locations in an underlying OpenGL shader |
| C Pass | Abstract base class for game loop passes |
| C TypedPass<StateType> | State-filtered pass that only executes in specific states |
| C PassCommitListener | Interface for receiving notifications when a pass reaches its commit point |
| C GameLoop | Central orchestrator for the game update cycle |
| C Phase | Represents a phase in the game loop containing multiple passes |
| C PlayerComponent | Component representing the player in a match |
| C PlayerDiedEvent | Event signalling that the player entity has died |
| C PrefabIdComponent | Component that stores the PrefabId identifying a GameObject's prefab origin |
| S PrefabIdTag | Tag type for PrefabId |
| C ProjectileSpawnSystem | System that spawns projectiles for entities with active ShootComponents |
| C Random | Utility class for generating pseudo-random numbers |
| C ReadBuffer<T> | Read-only buffer for consuming messages in a double-buffered system |
| C ReadSource | Lightweight handle for reading messages from a TypeIndexedDoubleBuffer |
| C Renderable | Abstract base class for objects that can be rendered by the rendering system |
| C MeshRenderable | Represents a renderable object that combines a shared prototype with instance-specific overrides |
| C TextRenderable | High-level text component that can be attached to game objects |
| C RenderableComponent | Component that holds a shared pointer to a Renderable resource |
| C RenderingBuilder | Builder for configuring visual representation components |
| C RenderingDevice | Abstract interface for a low-level rendering device |
| C OpenGLDevice | OpenGL implementation of `RenderingDevice` |
| C RenderPassFactory | Factory for constructing `LegacyRenderPass` objects from scene snapshots |
| C RenderPrototype | An immutable, shared prototype of a renderable object |
| C RenderQueue | Manages collections of render commands for geometry and text |
| C RenderTarget | Represents a destination for rendering operations, such as a window's framebuffer |
| C ResourceRegistry | Unified type-indexed registry for all engine resources |
| C ResourceTypeId | Unique type identifier for engine resources |
| C RotationStateComponent | Component that manages composite rotation from heading and spin rotations |
| S RuleConfig | Configuration pairing a spawn profile with its rule |
| C RuleProcessor | Abstract interface for processing spawn rules into spawn plans |
| C DefaultRuleProcessor | Default implementation of RuleProcessor |
| S RuntimeHandle<...> | A lightweight handle that pairs a stable StrongIdentifier with a dense RuntimeId |
| C ScaleStateComponent | Component that defines the physical dimensions (scale) of an entity |
| C ScaleSystem | System that applies scaling to entities based on their ScaleStateComponent |
| C Scene | Represents a hierarchical SceneGraph that organizes all renderable and non-renderable objects within a scene |
| C SceneBuilder | Builder for configuring scene graph integration |
| S SceneGraphKey | SceneGraphKey as passkey idiom for accessing `setWorldTransform()`. All friend classes are able to construct the SceneGraphKey for accessing pass key guarded methods like `setWorldTransform` |
| S SceneIdTag | Tag type for SceneId |
| C SceneNode | Represents a SceneNode within a SceneGraph |
| C CameraSceneNode | Represents an adapter for cameras, allowing spatial positioning and transformation within the scene graph |
| C SceneNodeComponent | Component that links a GameObject to a SceneNode in the scene graph |
| C SceneNodeConfig | Fluent configuration for scene graph integration |
| C SceneRenderingSystem | Renders scenes through their configured viewports |
| C SceneSyncSystem | System that synchronizes TransformComponents with SceneNodes |
| C SceneToViewportMap | Maps scenes to their associated viewports for rendering |
| S ScheduledSpawnPlan | A spawn plan that has been scheduled for execution |
| C ScheduledSpawnPlanCommand | Command for executing a scheduled spawn plan |
| C SchedulerBuilder | Builder for configuring and registering SpawnSchedulers |
| C SchedulerConfig | Fluent configuration for a single spawn rule |
| C Score | Abstract base class for score value types |
| C KillReward | Score type awarded when an entity is killed |
| C Score2UiTextUpdateSystem | System for binding score values to UI text components |
| C ScoreObserverClearSystem | System that resets the hasUpdate flag on all ScoreObserverComponents |
| C ScoreObserverComponent | Component that observes and caches the score value from a ScorePool |
| C ScoreObserverSystem | System that propagates score snapshots to ScoreObserverComponents |
| C ScorePool | Container that accumulates scores by type within a pool |
| C ScorePoolComponent | Component that associates an entity with a score pool |
| C ScorePoolConfig | Fluent configuration for ScorePoolComponent setup |
| S ScorePoolIdTag | Tag type for ScorePoolId |
| C ScorePoolManager | Manages score pools and processes score commands |
| S ScorePoolSnapshot | Immutable snapshot of a ScorePool's state |
| C ScoreTypeId | Strongly-typed identifier for score types |
| C ScoreValueComponent<T> | Template component that stores a score value of a specific type |
| C ScoreValueConfig | Fluent configuration for ScoreValueComponent setup |
| S ScoreValueContext | Data structure containing score update information |
| C ScoringBuilder | Builder for configuring scoring-related components |
| C Session | Holds session-level state for the current game instance |
| C Shader | Abstract representation of a Shader program (e.g. composed of vertex/fragment shader) |
| C LegacyOpenGLShader | An OpenGL-specific implementation of a Shader program, consisting of a vertex and a fragment shader |
| S Shape | Struct representing geometric primitives and indices for various shapes. provides immutable, shared access to vertices and indices of the represented geometric shape |
| S Circle | Basic Circle Shape (2D, in XY plane) |
| S Cube | Basic Cube Shape |
| S Ellipse | Basic Ellipse Shape (2D, in XY plane) |
| S Grid | A configurable grid shape for rendering reference lines in 3D space |
| S Line | Basic Line Shape |
| S Rectangle | Basic Rectangle Shape |
| S Rhombus | A 2D rhombus (diamond) shape primitive |
| S Triangle | Basic Triangle Shape |
| C ShootCommand | Command that triggers a shooting action on a GameObject |
| C ShootComponent | Component for handling projectile shooting with rate limiting |
| C Snapshot | Represents an immutable snapshot of a SceneGraph at a given point in time |
| S SnapshotItem | Structure for representing a snapshot item of a renderable's object state at a specific point in time |
| C SolidCollisionEvent | Event emitted when a solid collision is detected |
| C SparseSetBase | Abstract base class for type-erased sparse set access |
| C SparseSet<T, TAllowRemoval> | A generic sparse set providing O(1) insertion, lookup, and removal |
| C SparseSetBase | Abstract base class for type-erased sparse set access |
| C SparseSet<T> | A generic sparse set providing O(1) insertion, lookup, and removal |
| C SpawnAmountProvider | Abstract interface for determining spawn quantity |
| C FixedSpawnAmount | Amount provider that returns a fixed spawn count |
| C SpawnAll | Spawns all inactive objects from a pool |
| C SpawnAmountByCallback | Amount provider that delegates to a user-provided callback |
| C SpawnBuilder | Builder for configuring spawn-related components |
| C SpawnCommand | Command to request spawning of GameObjects from a pool |
| C SpawnCondition | Abstract interface for determining when spawning should occur |
| C RequestedAmountIsAvailableCondition | Condition verifying the pool has enough inactive entities |
| C SpawnConditionAll | Composite condition requiring all child conditions to pass |
| C TimerSpawnCondition | A SpawnCondition that triggers spawning at fixed time intervals |
| C SpawnConfig | Fluent configuration for spawn system integration |
| S SpawnContext | Context data passed to spawn behaviors during entity initialization |
| C SpawnedByProfileComponent | Component that stores the spawn profile ID that created this GameObject |
| C SpawnInitializer | Abstract interface for initializing spawned entity state |
| C DelayedComponentEnablerInitializer<...> | Initializer that schedules delayed activation of arbitrary components |
| C EmitterInitializer | Initializer that configures spawned entities based on emitter state |
| C InitializerList<N> | Composite initializer that executes multiple SpawnInitializers in sequence |
| C MoveInitializer | Initializer that sets movement direction for spawned entities |
| C RandomDirectionInitializer | Initializer that configures spawned entities with random direction |
| C SpawnManager | Manager for processing spawn and despawn commands |
| C SpawnPlacer | Abstract interface for determining spawn positions |
| C AxisSpawnPlacer | Spawn placer that distributes entities evenly along an axis |
| C ColumnSpawnPlacer | Places spawned entities in a vertical column formation |
| C DistributedSpawnPlacer<N> | Spawn placer that assigns entities to predefined spawn points |
| C EmitterSpawnPlacer | Placer that spawns entities at the emitter's position |
| C RandomSpawnPlacer | Placer that spawns entities at random positions within bounds |
| S SpawnPlan | Data structure describing a planned spawn operation |
| S SpawnPlanCommandExecutedEvent | Event indicating a spawn plan command has been executed |
| S SpawnPlanCursor | Tracks the current position within a spawn batch |
| C SpawnPoolConfig | ID-centric configuration for a spawn pool with associated profiles |
| S SpawnProfile | Configuration profile defining spawn behavior for a pool |
| C SpawnProfileConfig | Fluent configuration for a spawn profile bound to a pool |
| S SpawnProfileIdTag | Tag type for SpawnProfileId |
| C SpawnRule | Combines a condition and amount provider into a complete spawn rule |
| C SpawnRuleConfig | Fluent configuration for a spawn rule bound to a profile |
| S SpawnRuleIdTag | Tag type for SpawnRuleId |
| C SpawnRuleState | Runtime state for a spawn rule |
| C SpawnScheduler | Abstract base class for spawn schedulers |
| C CyclicSpawnScheduler<N> | Scheduler that cycles through spawn rules in round-robin order |
| C DefaultSpawnScheduler | Scheduler that evaluates spawn rules and produces spawn plans |
| C SpawnSystemConfigurator | Lightweight handle for chaining pool configurations |
| C SpawnSystemFactory | Factory for ID-centric spawn system configuration |
| C SpinComponent | Component that defines spin properties for an entity |
| C SpinSystem | System that updates the spin rotation of entities |
| C StateCommand<StateType> | Command that requests a state transition |
| C StateCommandHandler | Abstract base for type-erased state command handling |
| C TypedStateCommandHandler<StateType> | Typed interface for handling state commands |
| C StateComponent<StateType> | Stores the current state and last transition for an entity |
| C StateManager<StateType> | Manages state transitions using a rule-based system |
| C StateToIdMap<TState, TId> | Maps state enum values to lists of IDs |
| C StateToIdMapPair<LState, RState, TId> | Combines two StateToIdMap instances for dual-state lookups |
| C StateToViewportPolicyUpdateSystem<...> | Updates the session's active viewport list based on state policy |
| C StateTransitionContext<StateType> | Captures the complete context of a state transition |
| S StateTransitionId<StateType> | Type trait mapping StateType to its TransitionId type |
| S StateTransitionId<...> | Binds GameState to GameStateTransitionId |
| S StateTransitionId<...> | Binds MatchState to MatchStateTransitionId |
| C StateTransitionListener<StateType> | Interface for observing state transitions |
| C LambdaStateListener<StateType> | Lambda-based implementation of StateTransitionListener |
| C StateTransitionRequest<StateType> | Represents a request to perform a state transition |
| C StateTransitionRule<StateType> | Defines a valid state transition with optional guard |
| S StateTransitionType<StateType> | Type trait for state transition customization points |
| C StateTypeId | |
| C SteeringCommand | Command that updates the heading direction of a GameObject |
| C SteeringComponent | Component that manages the heading (orientation) of an entity |
| C SteeringConfig | Fluent configuration for steering and rotation behavior |
| C SteeringSystem | System that processes heading and rotation physics |
| C Stopwatch | A high-resolution timer based on std::chrono::steady_clock |
| C StringFileReader | Abstract base class for reading file contents into a string |
| C BasicStringFileReader | Basic implementation of a string file reader |
| S StrongId<Tag, Underlying> | A strongly-typed identifier using tag-based type safety |
| C System | Type-erased wrapper for game logic processors |
| S SystemRole | Compile-time tag identifying a class as a System |
| C SystemTypeId | Unique type identifier for system types |
| S TextLayout | Result of text layout computation |
| C TextMesh | Manages text content and caches layout data for efficient rendering |
| C TextRenderableConfig | Fluent configuration for text renderable GameObjects |
| C TextRenderCommand | Immutable command object for rendering a single piece of text |
| C TextRenderer | Abstract interface for text rendering implementations |
| C OpenGLGlyphTextRenderer | Renders and manages text using OpenGL and FreeType |
| C TextRenderPrototype | Immutable, shared prototype for text rendering configuration |
| C TextShaderProperties | Immutable shader properties for text rendering |
| S TextShaderPropertiesOverride | Optional overrides for text shader properties |
| C TimeFormatterComponent | Component that formats elapsed or remaining time into a display string |
| C TimerControlCommand | Command that carries a TimerControlContext to the timer subsystem |
| S TimerControlContext | Context describing a requested timer state transition |
| C TimerManager | Manager that owns game timers and processes timer control commands |
| C Transform | Represents a 3D transformation consisting of translation, rotation and scale |
| C TransformBuilder | Builder for configuring spatial transform components |
| C TransformClearSystem | System that clears the dirty state of TransformComponents and ScaleComponents at the end of a frame |
| C TransformConfig | Fluent configuration for spatial transform setup |
| C TranslationStateComponent | Component that holds the current translation (position) state |
| C TriggerCollisionEvent | Event emitted when a trigger collision is detected |
| C TwinStickInputSystem | Input component for twin-stick gamepad control schemes |
| C TypedCommandBuffer<CommandTypes> | Compile-time typed command buffer with per-type queues and handler routing |
| C TypeIndexedDoubleBuffer<Indexer> | Central hub for publishing and consuming typed messages |
| C TypeIndexedReadWriteBuffer<Indexer> | Type-indexed container for immediate-access message buffers |
| C TypeIndexer<Group> | Utility class to generate unique type indices at runtime |
| C TypeSetter | Computes text layout by positioning glyphs and generating vertex data |
| C UiActionCommand | A command that encapsulates a UI action request |
| C UiActionCommandManager | Manages and processes UI action commands with policy-based dispatch |
| C UiActionComponent | Associates an action identifier with a UI element |
| S UiFocusComponent | Tagging struct for the UI-component that currently has the focus |
| C UiStateComponent | Tracks interaction state for UI widgets |
| C UiStyleComponent | Stores color styles for different UI widget states |
| C UiStyleUpdateSystem | System for updating UI text element bounds |
| C UiTextBoundsUpdateSystem | System for updating UI text element bounds |
| C UiTextComponent | Component for displaying formatted text in the UI |
| C UiTransformBuilder | Builder for configuring UI transform components |
| C UiTransformComponent | Component for viewport-relative UI positioning |
| C UiTransformConfig | Fluent configuration for spatial transform setup |
| C UiTransformSystem | Computes screen positions for UI elements based on layout configuration |
| C UniformValueMap | Maps uniform semantics to their values for shader parameter binding |
| C UniformValueMap | Maps uniform semantics to their values for shader parameter binding |
| C UpdateContext | Per-frame context passed to systems during game loop updates |
| C UpdateScoreCommand | Command that carries score update information |
| S vec2<T> | Represents a 2-dimensional vector of the generic type <T> |
| S vec3<T> | Represents a 3-dimensional vector of the generic type <T> |
| S vec4<T> | Represents a 4-dimensional vector of the generic type <T> |
| S Vertex | Represents a standard vertex with position, normal, and texture coordinates |
| C View<Components> | A view class to iterate over entities having specific components |
| C Viewport | Represents a rectangular area within a RenderTarget where a scene is rendered |
| S ViewportIdTag | Tag type for ViewportId |
| S ViewportKey | A passkey used to establish a parent-child relationship between a RenderTarget and a Viewport |
| S ViewportSnapshot | Immutable snapshot of a Viewport's state at a specific point in time |
| C WeaponConfig | Fluent configuration for weapon and projectile systems |
| C Window | Abstract base class representing a generic window |
| C GLFWWindow | An OpenGL focused window implementation using GLFW |
| S WindowConfig | Configuration structure for creating and initializing a Window |
| S GLFWWindowConfig | Configuration structure for a GLFWWindow |
| C WorldLifecycleCommand | Command for requesting a world-level lifecycle operation |
| C WorldLifecycleManager | Manager that processes deferred world lifecycle commands |
| C WriteBuffer<T> | Write-only buffer for accumulating messages in a double-buffered system |
| C WriteSink | Lightweight handle for pushing messages to a TypeIndexedDoubleBuffer |
Generated via doxygen2docusaurus 2.0.0 by Doxygen 1.15.0.