Skip to content

Releases: ThorstenSuckow/helios

v0.4.0-milestone4

29 Jan 07:24
@ThorstenSuckow ThorstenSuckow
v0.4.0-milestone4
389110f

Choose a tag to compare

View all tags
v0.4.0-milestone4 Pre-release
Pre-release

helios v0.4.0-milestone4

Release Date: January 29, 2026
Project: helios Game Framework
Milestone: Spawn System, Collision Detection & Entity Lifecycle

Overview

This marks the fourth milestone release (milestone_4) of the helios project. Building upon the component architecture from Milestone 3, this release introduces a comprehensive spawn system with rule-based scheduling, grid-based collision detection, entity lifecycle management, and two new demo applications showcasing these features.

Major Features

Spawn System Architecture

A complete spawn infrastructure for entity creation and management:

Core Components

Component Purpose
SpawnManager Central manager for processing spawn/despawn commands
SpawnProfile Configuration combining pool, placer, and initializer
SpawnScheduler Abstract base for rule-based spawn scheduling
DefaultSpawnScheduler Evaluates all rules each frame
CyclicSpawnScheduler<N> Round-robin evaluation, advances on successful spawn

Spawn Policies

Class Purpose
SpawnRule Combines condition, amount provider, and rule ID
SpawnCondition Abstract interface for spawn prerequisites
SpawnConditionAll Composite AND condition
TimerSpawnCondition Interval-based spawning
RequestedAmountIsAvailableCondition Pool availability check
SpawnAmountProvider Abstract interface for spawn counts
FixedSpawnAmount Constant spawn count
SpawnAmountByCallback Dynamic count via callback

Spawn Behaviors

Class Purpose
SpawnPlacer Abstract interface for entity positioning
RandomSpawnPlacer Random position within bounds
EmitterSpawnPlacer Position relative to emitter entity
AxisSpawnPlacer Distribute entities along an axis
DistributedSpawnPlacer<N> Fixed spawn point locations
SpawnInitializer Abstract interface for entity initialization
EmitterInitializer Inherit direction from emitter
MoveInitializer Set movement direction (Random, Axis, Point)
DelayedComponentEnablerInitializer Defer component activation

Grid-Based Collision Detection

Spatial partitioning for efficient collision detection:

  • GridCollisionDetectionSystem with uniform 3D grid
  • Broadphase filtering via layer masks
  • Narrowphase AABB intersection tests
  • HitPolicy enum for collision count control:
    • OneHit: First collision only (projectiles)
    • All: All collisions (area effects)
  • Solid and trigger collision event types
  • CollisionStateComponent for collision results

Entity Lifecycle Management

Components and systems for entity state control:

Component Purpose
DelayedComponentEnabler Queue components for delayed activation
DelayedComponentEnablerSystem Process activation timers each frame
LifecycleBuilder Builder for lifecycle configuration
LifecycleConfig Fluent config for deferred enablement

Use cases:

  • Spawn immunity windows (defer collision)
  • Staggered wave activation
  • Visual fade-in effects

GameLoop Architecture

Structured game loop with phases and passes:

Class Purpose
GameLoop Main loop orchestrator
Phase Pre/Main/Post execution phases
Pass System grouping within phases
CommitPoint Synchronization points for commands

Command System

Deferred command execution pattern:

Command Purpose
SpawnCommand Request entity spawn
DespawnCommand Request entity despawn
ScheduledSpawnPlanCommand Batch spawn from scheduler

Strongly-Typed Identifiers

Type-safe IDs with FNV-1a string hashing:

// Compile-time constant IDs from strings
constexpr GameObjectPoolId ENEMY_POOL{"enemies"};
constexpr SpawnProfileId ENEMY_PROFILE{"enemy_spawn"};
constexpr SpawnRuleId WAVE_RULE{"wave_spawn"};

Core Algorithms

  • fnv1a_hash - Compile-time FNV-1a hash function for string-to-ID conversion

Breaking Changes

Module Reorganization

The helios.engine module has been reorganized into distinct submodules:

helios.engine
├── core        # Core data types and utilities
├── ecs         # Entity-Component-System base classes
├── runtime     # Runtime infrastructure (world, pooling, spawn, messaging)
├── modules     # Domain-agnostic subsystems (physics, spatial, scene)
├── mechanics   # Gameplay-specific systems (bounds, combat, input)
├── builder     # GameObject factory and builders
└── tooling     # Development tools

System Registration

Systems are now registered with GameLoop phases instead of GameWorld:

// Before (Milestone 3)
gameWorld.add<Move2DSystem>();

// After (Milestone 4)
gameLoop.phase(PhaseType::Pre)
    .addPass()
    .addSystem<Move2DSystem>();

Spawn Infrastructure Location

Spawn infrastructure moved from mechanics/spawn to runtime/spawn:

// Before
import helios.engine.mechanics.spawn;

// After
import helios.engine.runtime.spawn;

Removed Classes

  • GameObjectFactory (replaced by GameObjectFactory::instance())
  • GameObjectPoolFacade
  • PoolRequestHandler / PoolRequestHandlerRegistry

Examples

Six example applications demonstrate the framework capabilities:

Example Description
simple_cube_rendering Basic 3D cube with shader pipeline
game_controller_input Gamepad input visualization
spaceship_control Interactive spaceship with camera follow
spaceship_shooting Twin-stick shooter with projectile pooling
collision_detection Grid collision with multiple spawn patterns
enemy_spawn Spawn system demonstration

Pre-built Windows binaries are available as release assets.

Documentation

New Documentation

  • Spawn system architecture guide
  • Collision detection system documentation
  • Entity lifecycle management guide
  • GameLoop phases and passes documentation
  • Strongly-typed ID documentation with FNV-1a hashing

Updated Documentation

  • README files for all modules with new architecture
  • Builder documentation with LifecycleBuilder
  • MoveInitializer with DirectionType::Point strategy
  • HitPolicy integration in collision system

Dependencies

Library / Tool Purpose
C++23 Core language features and modules
CMake 4.x Build configuration
GLFW Window and input handling
OpenGL (via GLAD) Rendering backend
Dear ImGui Developer UI and debugging tools
Google Test Unit testing
Google Benchmark Performance measurement
Doxygen API documentation

Known Limitations

  • Single-threaded execution model
  • Windows primary development platform
  • Grid collision detection assumes uniform cell sizes

Future Roadmap

See the project milestones for detailed targets.

Links

Summary

helios v0.4.0-milestone4 delivers a complete spawn system with rule-based scheduling, grid-based collision detection, and entity lifecycle management. This release establishes the infrastructure for building complex gameplay systems with the helios engine.

Loading

v0.3.0-milestone3

25 Dec 18:43
@ThorstenSuckow ThorstenSuckow
v0.3.0-milestone3
de9110e

Choose a tag to compare

View all tags
v0.3.0-milestone3 Pre-release
Pre-release

helios v0.3.0-milestone3

Release Date: December 25, 2025
Project: helios Game Framework
Milestone: Component System, Physics Systems & Twin-Stick Shooter Demo

Overview

This marks the third milestone release (milestone_3) of the helios project. Building upon the scene graph and game object framework from Milestone 2, this release introduces a complete component-based architecture with dedicated systems for physics, scene synchronization, and gameplay mechanics. The highlight is a fully functional twin-stick shooter demo showcasing projectile pooling, level bounds, and 2D physics.

Major Features

Component System Architecture

A composition-over-inheritance approach for game entity behavior:

  • TransformComponent for independent transform management (separate from scene graph)
  • ScaleComponent for unit-based sizing with dirty flag tracking
  • AabbColliderComponent for world-space bounding boxes
  • ModelAabbComponent for original model bounds
  • LevelBoundsBehaviorComponent for configurable boundary reactions (bounce, clamp, wrap)
  • Automatic AABB capture from SceneNode meshes via onAttach()

Game Systems

Dedicated systems for processing game logic each frame:

System Purpose
Move2DSystem 2D physics with rotation, velocity integration, and dampening
ScaleSystem Applies unit-based scaling from ScaleComponent to transforms
BoundsUpdateSystem Updates AABB colliders from world transforms
LevelBoundsBehaviorSystem Handles boundary collisions (bounce with restitution)
SceneSyncSystem Synchronizes gameplay transforms with scene graph
TransformClearSystem Clears dirty flags at end of frame
ScaleClearSystem Clears scale dirty flags at end of frame
ProjectilePoolSystem Object pool for efficient projectile spawning

Level System

Level management for gameplay bounds:

  • Level class with configurable world bounds
  • AABB-based arena boundaries
  • Root SceneNode reference for level hierarchy
  • Unit-aware bounds configuration

Gameplay Components

Components for twin-stick shooter mechanics:

  • Aim2DComponent - Direction tracking and firing frequency
  • ShootComponent - Projectile firing with configurable cooldown and speed
  • TwinStickInputComponent - Dual analog stick input translation

Rendering Assets

New shape primitives:

  • Ellipse 2D shape with configurable width, height, and segment count
  • Ideal for projectiles and particle effects

Utility Enhancements

  • Colors struct with comprehensive vec4f color palette
  • Standard colors: Black, White, Red, Green, Blue, Yellow, Cyan, Magenta
  • Extended palette: Coral, Salmon, Orange, Turquoise, Gold, etc.
  • withW() method for alpha channel modification

ImGui Widget Improvements

  • LogWidget: "None" scope option to completely disable logging (default)
  • GamepadWidget: Settings panel with side-by-side stick configuration, initially expanded
  • Left/Right stick deadzone and inversion controls in two-column layout

Breaking Changes

SceneNodeComponent API

setSize() method removed from SceneNodeComponent. Use ScaleComponent instead:

// Before (Milestone 2)
shipGameObject->get<SceneNodeComponent>()
    ->setSize(5.0f, 5.0f, 0.0f, Unit::Meter);

// After (Milestone 3)
shipGameObject->add<ScaleComponent>(5.0f, 5.0f, 0.0f, Unit::Meter);

GameWorld Constructor

GameWorld no longer requires a Scene* parameter:

// Before (Milestone 2)
auto gameWorld = GameWorld{scene.get()};

// After (Milestone 3)
auto gameWorld = GameWorld{};
gameWorld.add<SceneSyncSystem>(scene.get());

System Registration Required

Game logic now requires explicit system registration:

gameWorld.add<ScaleSystem>();
gameWorld.add<Move2DSystem>();
gameWorld.add<SceneSyncSystem>(scene.get());
gameWorld.add<BoundsUpdateSystem>();
gameWorld.add<LevelBoundsBehaviorSystem>();
gameWorld.add<TransformClearSystem>();
gameWorld.add<ScaleClearSystem>();

Move2DComponent API

  • position() removed - transforms managed by TransformComponent
  • rotationAngle() renamed to currentRotationAngle()

Examples

Four example applications demonstrate the framework capabilities:

Example Description
simple_cube_rendering Basic 3D cube with shader pipeline
game_controller_input Gamepad input visualization
spaceship_control Interactive spaceship with camera follow and physics tuning
spaceship_shooting Twin-stick shooter with projectile pooling and arena bounds

Pre-built Windows binaries are available as release assets.

Documentation

New Documentation

  • Physics systems documentation with execution order
  • Component lifecycle documentation (onAttach callbacks)
  • Level and bounds system guide
  • ProjectilePoolSystem usage examples

Updated Documentation

  • README files for all examples updated with new component/system architecture
  • API documentation for new modules
  • SpaceshipWidget documentation updated for new Move2DComponent API

Dependencies

Library / Tool Purpose
C++23 Core language features and modules
CMake 4.x Build configuration
GLFW Window and input handling
OpenGL (via GLAD) Rendering backend
Dear ImGui Developer UI and debugging tools
Google Test Unit testing
Google Benchmark Performance measurement
Doxygen API documentation

Known Limitations

  • Projectile collision uses arena AABB only (no entity-to-entity collision)
  • Z-index handling for 2D gameplay assumes grid at z=0
  • Single-threaded execution model
  • Windows primary development platform

Future Roadmap

See the project milestones for detailed targets.

Links

Summary

helios v0.3.0-milestone3 delivers a complete component-based game architecture with physics systems, level management, and a twin-stick shooter demo. This release establishes the gameplay foundation for building 2D action games with the helios engine.

Loading
0 Join discussion

v0.1.0-milestone2

16 Dec 12:22
@ThorstenSuckow ThorstenSuckow
0.1.0-milestone2
8d9b2e8

Choose a tag to compare

View all tags
v0.1.0-milestone2 Pre-release
Pre-release

helios v0.2.0-milestone2

Release Date: December 16, 2025
Project: helios Game Framework
Milestone: Scene Graph Integration, Game Systems & Developer Tooling

Overview

This marks the second milestone release (milestone_2) of the helios project. Building upon the architectural foundation established in Milestone 1, this release introduces a comprehensive scene graph with camera integration, a game object system, advanced input processing, and an extensive ImGui-based developer tooling layer.

The focus of this milestone is on providing the infrastructure for interactive 3D applications with real-time debugging capabilities.

Major Features

Scene Graph & Camera System

The camera system has been fully integrated into the scene graph hierarchy:

  • CameraSceneNode enables cameras to participate in the transform hierarchy
  • Cameras can follow game objects via scene graph parenting
  • Selective transform inheritance (Translation, Rotation, Scale) via TransformType
  • View matrix computed from inverse world transform
  • lookAt() and lookAtLocal() methods for intuitive camera orientation

Game System (helios.engine.game)

A complete game object framework for entity management:

  • GameObject base class with GUID identification
  • GameWorld container for centralized object management
  • CommandBuffer for deferred command execution (Command Pattern)
  • InputSnapshot for frame-consistent input state
  • InputHandler interface for input-to-command translation
  • Unit-based sizing with setSize() method

Units System (helios.core.units)

Standardized measurement units across the engine:

  • Standard spatial unit: 1 Meter (1 hu = 1 m)
  • Standard time unit: Seconds
  • Conversion utilities between Meter/Centimeter and Seconds/Milliseconds
  • Compile-time constants for unit definitions

Advanced Gamepad Input

Enhanced gamepad support with per-controller configuration:

  • GamepadSettings for deadzone and axis inversion settings
  • RadialDeadzoneStrategy for circular deadzone normalization
  • Per-stick deadzone thresholds (0.0 to 0.9 range)
  • Individual axis inversion for all four stick axes
  • Runtime configuration access via InputAdapter

Engine & Tooling

Frame timing and performance measurement utilities:

  • FramePacer for configurable frame rate limiting
  • FrameStats for detailed frame timing breakdown
  • FpsMetrics for statistical frame rate analysis
  • Stopwatch high-resolution timer utility

ImGui Integration Layer

A complete abstraction layer for ImGui integration:

  • ImGuiBackend abstraction for platform-agnostic backends
  • ImGuiGlfwOpenGLBackend for GLFW/OpenGL projects
  • ImGuiOverlay singleton manager with DockSpace support
  • ImGuiWidget base interface for extensible widget development
  • Configurable semi-transparent window backgrounds

Developer Widgets

Comprehensive debugging and control widgets:

Widget Purpose
FpsWidget Frame rate display with target FPS control
GamepadWidget Real-time gamepad state visualization with settings panel
LogWidget Scrollable log console with scope/level filtering and search
CameraWidget Camera parameter control with space toggle and presets
MainMenuWidget Application settings (transparency, docking, themes)

Logging System Enhancements

Self-registering sink architecture for extensible logging:

  • LogSink abstract interface with type identifiers
  • ConsoleSink for terminal output
  • ImGuiLogSink for LogWidget integration
  • Enable/disable sinks by type identifier at runtime
  • Scope-based filtering support

Breaking Changes

This release includes several breaking changes to improve architecture and maintainability.

Camera System Refactor

Cameras are now managed via CameraSceneNode instead of standalone Camera objects:

// Before (Milestone 1)
auto camera = std::make_shared<Camera>();
viewport->setCamera(camera.get());
camera->setPosition({0, 0, 5});

// After (Milestone 2)
auto camera = std::make_unique<Camera>();
auto cameraNode = std::make_unique<CameraSceneNode>(std::move(camera));
auto* nodePtr = scene->addNode(std::move(cameraNode));
viewport->setCameraSceneNode(nodePtr);
nodePtr->setTranslation({0, 0, 5});

Enum Sentinel Naming

All enum counter entries renamed from COUNT to size_ for consistency.

MeshData Removal

MeshData has been merged into Mesh class.

Material Ownership

Materials now own their shader and properties via shared pointers.

Documentation

New Documentation

  • CONVENTIONS.md: Left-Handed Coordinate System (LHS), matrix storage format, view matrix construction
  • Units system documentation with standard unit definitions
  • Scene graph camera integration guide
  • ImGui widget development guide

Updated Documentation

  • API documentation for all new modules
  • Example code with improved section headers and comments
  • Migration guide for breaking changes

Examples

Three example applications demonstrate the framework capabilities:

Example Description
simple_cube_rendering Basic 3D cube with shader pipeline
game_controller_input Gamepad input visualization
spaceship_control Interactive spaceship with camera follow, ImGui overlay, and command pattern

Pre-built Windows binaries are available as release assets.

Dependencies

Library / Tool Purpose
C++23 Core language features and modules
CMake 4.x Build configuration
GLFW Window and input handling
GLM Validation reference for math library
OpenGL (via GLAD) Rendering backend
Dear ImGui Developer UI and debugging tools
Google Test Unit testing
Google Benchmark Performance measurement
Doxygen API documentation

Known Limitations

  • Rendering pipeline remains in foundational stage
  • No asset loading system (textures, models)
  • Single-threaded execution model
  • Windows primary development platform (Linux/macOS support experimental)

Future Roadmap

See the project milestones for detailed targets of the upcoming milestones.

Acknowledgements

Special thanks to the open-source community, particularly the Dear ImGui project for providing excellent developer tooling capabilities.

Links

Summary

helios v0.2.0-milestone2 delivers a fully integrated scene graph with camera support, a game object system, advanced input handling, and comprehensive developer tooling via ImGui. This release establishes the interactive foundation for building 3D game applications.

Loading
0 Join discussion

v0.1.0-milestone1

01 Nov 18:28
@ThorstenSuckow ThorstenSuckow
0.1.0-milestone1
e394305

Choose a tag to compare

View all tags
v0.1.0-milestone1 Pre-release
Pre-release

helios v0.1.0-milestone1

Release Date: November 1, 2025
Project: helios Game Framework
Milestone: Initial Architecture and Documentation Release

Overview

This marks the first milestone release (milestone_1) of the helios project, a modern C++23-based game framework focused on clean architecture, maintainability, and software engineering best practices.

This milestone establishes the foundational architecture, core subsystems and technical documentation for this educational project.

Major Features

Core Architecture

Feature layers of the modular subsystem design include:

  • helios::app: Application lifecycle and controllers
  • helios::event: Event dispatching and management system
  • helios::input: Input handling abstraction layer
  • helios::window: Window management
  • helios::rendering: Rendering subsystem
  • helios::scene: Scene graph and entity management
  • helios::math: Mathematical utilities
  • helios::util: General utility library

Project Structure

  • Adopted the Pitchfork Layout for consistent organization
  • Separated include/ and src/ directories following modern C++ conventions
  • Centralized external dependencies in the ext/ directory
  • Added dedicated examples/, tests/, and benchmarks/ directories

Design Principles

  • Application of SOLID principles throughout the codebase
  • Emphasis on Inversion of Control and Dependency Injection
  • Clear interface-implementation separation for enhanced modularity
  • Strong focus on testability and maintainability from the outset

Build System

  • CMake-based configuration ensuring cross-platform compatibility
  • Modular build scripts per subsystem
  • Support for external dependencies (GLFW, GLM, OpenGL via GLAD)
  • Integrated GitHub Actions workflow for automated API documentation generation

Documentation

A detailed project paper (see /docs) includes:

  • Abstract, introduction, and motivation
  • Architecture overview with package diagrams and design patterns
  • Project structure and tooling documentation
  • Discussion of key design decisions, including comparison with Unity ECS and Unreal Mass Entity
  • Analysis of Object-Oriented vs. Data-Oriented Design in game development
  • Application of SOLID principles in game development
  • Requirements engineering aspects in games
  • Conclusion, outlook, and bibliography with academic references

API Documentation

  • Doxygen configuration for automatic generation
  • GitHub Actions deployment of HTML and XML documentation
  • XML archive distribution for integration with the helios website repository

Dependencies

Key dependencies used in this release:

Library / Tool Purpose
C++23 Core language features
CMake 4.x Build configuration
GLFW Window and input handling
GLM Validation reference for the custom math library
OpenGL (via GLAD) Rendering backend
Google Test Unit testing
Google Benchmark Performance measurement
Doxygen API documentation

Known Limitations

This is an educational baseline release focused primarily on establishing the architecture.
Some systems, notably the core rendering pipeline, remain in their foundational stage of development.

Future Roadmap

Upcoming milestones will expand helios functionality.
See the project milestones for detailed targets and timelines.

Acknowledgements

Special thanks to the open-source community for providing the essential tools, libraries, and knowledge that made this project possible.

Links

Summary

helios v0.1.0-milestone1 establishes the groundwork for a modular and extensible game framework prototype, forming the technical basis for future integration of gameplay systems.

Loading