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 ActionId | Strongly-typed identifier for UI actions |
| 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 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 |
| S AttackContext | Data structure containing information about an attack |
| S BounceResult | Result of a bounce calculation against level bounds |
| 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 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 CollisionStateComponent | Stores per-frame collision state for a GameObject |
| 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 CombinedStateToIdMapPair<...> | Maps combined state pairs directly to ID lists |
| C CommandBuffer | Queue for deferred execution of game commands |
| 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) |
| 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 |
| C DamageDealerComponent | Component that stores damage values per collision layer |
| 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 DeathEvent | Event emitted when an entity's health reaches zero |
| 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 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 |
| 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 | Central registry for creating and managing entity handles |
| 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 FontId | Strongly-typed identifier for font families used in text rendering |
| 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 |
| 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 GameObjectPool | Object pool for efficient GameObject lifecycle management |
| S GameObjectPoolConfig | Configuration structure for creating a GameObjectPool |
| S GameObjectPoolId | Strongly-typed identifier for referencing a GameObjectPool |
| 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 GamepadSettings | Configuration class for gamepad input normalization and axis behavior |
| C GamepadState | A lightweight class for transferring the state of a Gamepad |
| C GameTimer | A game timer identified by a GameTimerId |
| C GameTimerBindingComponent | Component that tracks the revision of a specific GameTimer |
| S GameTimerIdTag | Tag type for GameTimerId |
| C GameWorld | Central registry for game entities, managers, pools, 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 Guid | Representative of a Globally Unique Identifier |
| S hash<...> | |
| S hash<...> | Hash specialization for ActionId |
| S hash<...> | std::hash specialization for ComponentTypeId |
| S hash<helios::engine::core::data::FontId> | Hash specialization for `FontId` to enable use in unordered containers |
| S hash<...> | Hash specialization for GameObjectPoolId |
| S hash<helios::engine::core::data::SceneId> | Hash specialization for `SceneId` to enable use in unordered containers |
| S hash<...> | std::hash specialization for ScoreTypeId |
| S hash<...> | Hash specialization for SpawnProfileId |
| S hash<...> | Hash specialization for SpawnRuleId |
| S hash<...> | std::hash specialization for StateTypeId |
| S hash<helios::engine::ecs::EntityHandle> | Hash specialization for EntityHandle |
| S hash<helios::util::Guid> | |
| C HealthBuilder | Builder for configuring health-related components |
| C HealthComponent | Component for tracking entity health and damage |
| C HealthConfig | Fluent configuration for HealthComponent setup |
| S helios_engine_core_data_ComponentTypes | Tag type for the TypeIndexer domain |
| S helios_engine_core_data_ScoreTypes | Tag type for the TypeIndexer domain |
| S helios_engine_core_data_StateTypes | Tag type for the TypeIndexer domain |
| C HierarchyComponent | Stores parent-child relationships for hierarchical entity graphs |
| 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 InvalidStateTransitionId | Placeholder type for missing specializations |
| S Iterator | Forward iterator for traversing the sparse set |
| S Iterator | Forward iterator for View traversal |
| C LastAttackerComponent | Component that stores information about the last attack received |
| 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 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 |
| 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 | Abstract base class for managers that process deferred operations |
| C GameObjectPoolManager | High-level manager for GameObject pooling operations |
| C ScorePoolManager | Manages score pools and processes score commands |
| C SpawnManager | Manager for processing spawn and despawn commands |
| C StateManager<StateType> | Manages state transitions using a rule-based system |
| C TimerManager | Manager that owns game timers and processes timer control commands |
| C UiActionCommandManager | Manages and processes UI action commands with policy-based dispatch |
| S mat4<T> | Represents a 4x4 matrix, stored in column-major order |
| 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 MaxScoreObserverComponent | Component that observes and caches the high score value from a ScorePool |
| 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 |
| S MenuIdTag | Tag type for MenuId |
| C MenuItemConfig | Fluent configuration for menu item GameObjects |
| 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 ModelAabbComponent | Component that stores the canonical Axis-Aligned Bounding Box (AABB) of a model |
| C MotionBuilder | Builder for configuring movement and steering components |
| C Move2DComponent | Component for 2D physics-based movement |
| C Move2DConfig | Fluent configuration for 2D movement behavior |
| 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 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 PrefabIdComponent | Component that stores the PrefabId identifying a GameObject's prefab origin |
| S PrefabIdTag | Tag type for PrefabId |
| 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 RenderPass | Encapsulates a single rendering pass with its associated resources |
| C RenderPassFactory | Factory for constructing `RenderPass` 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 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 |
| C ScaleStateComponent | Component that defines the physical dimensions (scale) of an entity |
| 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 SceneId | Strongly-typed identifier for scenes |
| 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 SceneToViewportMap | Maps scenes to their associated viewports for rendering |
| S ScheduledSpawnPlan | A spawn plan that has been scheduled for execution |
| 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 ScoreCommandHandler | Abstract interface for processing score update commands |
| C ScorePoolManager | Manages score pools and processes score commands |
| C ScoreObserverComponent | Component that observes and caches the score value from a ScorePool |
| 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 |
| 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 OpenGLShader | 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 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> | 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 SpawnCommandHandler | Interface for handlers that process spawn and despawn commands |
| C SpawnManager | Manager for processing spawn and despawn commands |
| C SpawnCommandHandlerRegistry | Registry that maps SpawnProfileIds to their SpawnCommandHandlers |
| 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 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 SpawnProfileId | Strongly-typed identifier for SpawnProfile instances |
| 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 SpawnRuleId | Strongly-typed identifier for SpawnRule instances |
| 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 StateCommandHandler | Abstract base for type-erased state command handling |
| C TypedStateCommandHandler<StateType> | Typed interface for handling state commands |
| C StateManager<StateType> | Manages state transitions using a rule-based system |
| C StateComponent<StateType> | Stores the current state and last transition for an entity |
| 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 StateTransitionContext<StateType> | Captures the complete context of a state transition |
| S StateTransitionId<StateType> | Type trait mapping StateType to its TransitionId type |
| S StateTransitionId<...> | Type trait specialization for GameState |
| S StateTransitionId<...> | Type trait specialization for MatchState |
| 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 SteeringComponent | Component that manages the heading (orientation) of an entity |
| C SteeringConfig | Fluent configuration for steering and rotation behavior |
| 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 SystemRegistry | Container for System instances within a game loop pass |
| C TargetedCommand | Abstract base class for commands targeting a specific GameObject |
| C Aim2DCommand | Command that applies 2D aiming direction to a GameObject |
| C Move2DCommand | Command that applies 2D directional movement to a GameObject |
| C ShootCommand | Command that triggers a shooting action on a GameObject |
| C SteeringCommand | Command that updates the heading direction of a GameObject |
| C TargetedCommandDispatcher | Abstract dispatcher interface for type-safe TargetedCommand handling |
| C TypedTargetedCommandDispatcher<T> | Type-safe dispatcher template for handling specific TargetedCommand types |
| S TargetedCommandProxy | Internal struct pairing a command with its target GameObject identifier |
| 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 TimerCommandHandler | Abstract interface for handling TimerControlCommands |
| C TimerManager | Manager that owns game timers and processes timer control commands |
| S TimerControlContext | Context describing a requested timer state transition |
| C Transform | Represents a 3D transformation consisting of translation, rotation and scale |
| C TransformBuilder | Builder for configuring spatial transform components |
| 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 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 UiActionCommandHandler | Abstract interface for handling UI action commands |
| 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 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 UniformValueMap | Maps uniform semantics to their values for shader parameter binding |
| C Updatable | Interface for components that require per-frame updates |
| C System | Abstract base class for game systems |
| C BoundsUpdateSystem | System that updates AABB colliders based on entity transforms |
| C ChaseSystem | System that steers entities towards their chase targets |
| C CollisionStateClearSystem | System that clears collision state components at the end of each frame |
| C CollisionStateResponseSystem | System that processes collision states and executes configured behaviors |
| C CombatScoringSystem | System that processes death events and awards scores |
| C ComposeTransformSystem | System that composes the final ComposeTransformComponent from state components |
| C DamageOnCollisionSystem | System that processes solid collision events and applies damage |
| C DelayedComponentEnablerSystem | System that processes delayed component activations each frame |
| C GameFlowSystem | System that drives automatic game state transitions |
| C GameObjectSpawnSystem | |
| C GameStateInputResponseSystem | Responds to gamepad input and issues game state commands |
| C GameTimer2UiTextUpdateSystem | System for binding game timer values to UI text components |
| C GameTimerUpdateSystem | Updates all game timers managed by the TimerManager |
| C GridCollisionDetectionSystem | Collision detection system using uniform spatial partitioning for Broadphase and AABB overlaps in the Narrowphase |
| C HealthUpdateSystem | System that detects dead entities and issues despawn commands |
| C HierarchyPropagationSystem | Propagates activation state from parent to child entities |
| C LevelBoundsBehaviorSystem | System that handles entity behavior when colliding with level boundaries |
| C MatchFlowSystem | Automatically advances the match through its state phases |
| C MatchRuleSystem | Evaluates match rules and conditions |
| C MaxScore2UiTextUpdateSystem | System for binding high score values to UI text components |
| C MaxScoreObserverClearSystem | System that resets the hasUpdate flag on all MaxScoreObserverComponents |
| C MaxScoreObserverSystem | System that propagates high score snapshots to MaxScoreObserverComponents |
| C MenuDisplaySystem<StateLft, StateRgt> | Controls menu visibility based on game and match state |
| C MenuNavigationSystem | Handles gamepad input for menu navigation |
| C Move2DSystem | System that processes 2D movement for entities |
| C ProjectileSpawnSystem | System that spawns projectiles for entities with active ShootComponents |
| C ScaleSystem | System that applies scaling to entities based on their ScaleStateComponent |
| C SceneRenderingSystem | Renders scenes through their configured viewports |
| C SceneSyncSystem | System that synchronizes TransformComponents with SceneNodes |
| C Score2UiTextUpdateSystem | System for binding score values to UI text components |
| C ScoreObserverClearSystem | System that resets the hasUpdate flag on all ScoreObserverComponents |
| C ScoreObserverSystem | System that propagates score snapshots to ScoreObserverComponents |
| C SpinSystem | System that updates the spin rotation of entities |
| C StateToViewportPolicyUpdateSystem<...> | Updates the session's active viewport list based on state policy |
| C SteeringSystem | System that processes heading and rotation physics |
| C TransformClearSystem | System that clears the dirty state of TransformComponents and ScaleComponents at the end of a frame |
| C TwinStickInputSystem | Input component for twin-stick gamepad control schemes |
| C UiStyleUpdateSystem | System for updating UI text element bounds |
| C UiTextBoundsUpdateSystem | System for updating UI text element bounds |
| C UiTransformSystem | Computes screen positions for UI elements based on layout configuration |
| S UpdateContext | Context passed to systems and components during per-frame updates |
| 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 WorldCommand | Abstract base class for commands that operate on the entire GameWorld |
| C DespawnCommand | Command to request despawning of a GameObject |
| C ScheduledSpawnPlanCommand | Command for executing a scheduled spawn plan |
| C SpawnCommand | Command to request spawning of GameObjects from a pool |
| C StateCommand<StateType> | Command that requests a state transition |
| C TimerControlCommand | Command that carries a TimerControlContext to the timer subsystem |
| C UiActionCommand | A command that encapsulates a UI action request |
| C UpdateScoreCommand | Command that carries score update information |
| C WorldCommandDispatcher | Abstract dispatcher interface for type-safe WorldCommand handling |
| C TypedWorldCommandDispatcher<T> | Type-safe dispatcher template for handling specific WorldCommand types |
| C DespawnCommandDispatcher | Dispatcher that routes DespawnCommands to the appropriate handler |
| C ScheduledSpawnPlanCommandDispatcher | Dispatcher that routes ScheduledSpawnPlanCommands to the appropriate handler |
| C ScoreCommandDispatcher | Dispatcher that routes UpdateScoreCommand to the registered ScoreCommandHandler |
| C SpawnCommandDispatcher | Dispatcher that routes SpawnCommands to the appropriate handler |
| C StateCommandDispatcher<StateType> | Routes state commands to the appropriate handler |
| C TimerCommandDispatcher | Dispatches TimerControlCommands to the registered TimerCommandHandler |
| C UiActionCommandDispatcher | Routes UiActionCommand instances to the registered handler |
| S WorldCommandProxy | Internal struct pairing a world command with its type index |
| 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.