feat(engine): Adds headless mode support

Implements headless mode, allowing the engine to run without a graphical interface.

This is achieved by conditionally initializing the window, ImGui, and rendering components based on the `headless` setting in the `EngineSettings` struct.

A new example is included, demonstrating the use of headless mode with a simple test object that runs for a limited time.

Author: tolstenko

core/engine/Engine.cpp

@@ -56,12 +56,17 @@ void Engine::Run() {
 }
 
 bool Engine::Start(std::string title) {
-  SDL_Log("Initializing Window");
-  window = new Window(title);
-  if (window != nullptr)
-    SDL_Log("Window Initialized");
-  else
-    exit(0);
+  if (!settings.headless) {
+    SDL_Log("Initializing Window");
+    window = new Window(title);
+    if (window != nullptr)
+      SDL_Log("Window Initialized");
+    else
+      exit(0);
+  } else {
+    SDL_Log("Starting in headless mode - no window created");
+    window = nullptr;
+  }
 
   lastFrameTime = std::chrono::high_resolution_clock::now();
   SDL_Delay(1000 / targetFPS);
@@ -71,15 +76,18 @@ bool Engine::Start(std::string title) {
 }
 
 void Engine::Tick() {
-  // Start the Dear ImGui frame
-  ImGui_ImplSDLRenderer2_NewFrame();
-  ImGui_ImplSDL2_NewFrame();
-  ImGui::NewFrame();
-  window->Update();
-
-  SDL_SetRenderDrawColor(window->sdlRenderer, (Uint8)(clear_color.x * 255), (Uint8)(clear_color.y * 255), (Uint8)(clear_color.z * 255),
-                         (Uint8)(clear_color.w * 255));
-  SDL_RenderClear(window->sdlRenderer);
+  // Only initialize ImGui and rendering if not in headless mode
+  if (!settings.headless) {
+    // Start the Dear ImGui frame
+    ImGui_ImplSDLRenderer2_NewFrame();
+    ImGui_ImplSDL2_NewFrame();
+    ImGui::NewFrame();
+    window->Update();
+
+    SDL_SetRenderDrawColor(window->sdlRenderer, (Uint8)(clear_color.x * 255), (Uint8)(clear_color.y * 255), (Uint8)(clear_color.z * 255),
+                           (Uint8)(clear_color.w * 255));
+    SDL_RenderClear(window->sdlRenderer);
+  }
 
   // inputs processing
   processInput();
@@ -94,17 +102,23 @@ void Engine::Tick() {
   // update
   for (auto go : gameObjects) go->Update(deltaTime);
 
-  // iterate over all game objects ui
-  auto gos = gameObjects;                                       // clone to prevent out of bounds access
-  for (auto go : gameObjects) go->OnGui(window->imGuiContext);  // todo: find a better way to pass imgui context
+  // Only process GUI and rendering if not in headless mode
+  if (!settings.headless) {
+    // iterate over all game objects ui
+    auto gos = gameObjects;                                       // clone to prevent out of bounds access
+    for (auto go : gameObjects) go->OnGui(window->imGuiContext);  // todo: find a better way to pass imgui context
 
-  for (auto go : scriptableObjects) go->OnGui(window->imGuiContext);
+    for (auto go : scriptableObjects) go->OnGui(window->imGuiContext);
 
-  // Rendering
-  ImGui::Render();
+    // Rendering
+    ImGui::Render();
 
-  // Draw
-  for (auto go : gameObjects) go->OnDraw(window->sdlRenderer);
+    // Draw
+    for (auto go : gameObjects) go->OnDraw(window->sdlRenderer);
+
+    ImGui_ImplSDLRenderer2_RenderDrawData(ImGui::GetDrawData(), window->sdlRenderer);
+    SDL_RenderPresent(window->sdlRenderer);
+  }
 
   // destroy objects marked to death
   if (!toDestroy.empty()) {
@@ -114,9 +128,6 @@ void Engine::Tick() {
     }
     toDestroy.clear();
   }
-
-  ImGui_ImplSDLRenderer2_RenderDrawData(ImGui::GetDrawData(), window->sdlRenderer);
-  SDL_RenderPresent(window->sdlRenderer);
 }
 
 void Engine::Exit() {
@@ -137,6 +148,11 @@ void Engine::processInput() {
   // clean the state
   arrowInput = Vector2f();
 
+  // Skip input processing in headless mode
+  if (settings.headless) {
+    return;
+  }
+
   // process events
   SDL_Event event;
   while (SDL_PollEvent(&event)) {

core/engine/Engine.h

@@ -63,5 +63,7 @@ class Engine {
   void Destroy(GameObject* go);
 
   void AddScriptableObject(ScriptableObject* pObject) { scriptableObjects.insert(pObject); };
+
+  bool IsHeadless() const { return settings.headless; }
 };
 #endif

core/engine/EngineSettings.h

@@ -6,6 +6,7 @@ struct EngineSettings {
   bool fullscreen : 1 = false;
   bool vsync : 1 = true;
   bool showWindow : 1 = true;
+  bool headless : 1 = false;
 };
 
 #endif  // MOBAGEN_ENGINESETTINGS_H

examples/headless/CMakeLists.txt

@@ -0,0 +1,22 @@
+file(
+  GLOB
+  HEADLESS_INC
+  CONFIGURE_DEPENDS
+  ${CMAKE_CURRENT_SOURCE_DIR}/*.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/*.hpp
+)
+
+file(
+  GLOB
+  HEADLESS_SRC
+  CONFIGURE_DEPENDS
+  ${CMAKE_CURRENT_SOURCE_DIR}/*.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/*.c
+)
+
+install(FILES ${HEADLESS_INC} DESTINATION include/headless)
+
+add_executable(headless ${HEADLESS_SRC} ${HEADLESS_INC})
+
+target_include_directories(headless PUBLIC ${SDL2_INCLUDE_DIR} ${CORE_INC_DIR})
+target_link_libraries(headless PUBLIC SDL2-static IMGUI core)

examples/headless/main.cpp

@@ -0,0 +1,76 @@
+#define SDL_MAIN_HANDLED true
+#include "engine/Engine.h"
+#include "scene/GameObject.h"
+#include "SDL.h"
+#include <iostream>
+
+// Simple test object that runs for a limited time in headless mode
+class HeadlessTestObject : public GameObject {
+private:
+  float totalTime = 0.0f;
+  float maxRunTime = 5.0f;  // Run for 5 seconds
+  int frameCount = 0;
+
+public:
+  HeadlessTestObject(Engine* pEngine) : GameObject(pEngine) {}
+
+  void Update(float deltaTime) override {
+    totalTime += deltaTime;
+    frameCount++;
+    
+    // Log progress every second
+    if (frameCount % 60 == 0) {  // Assuming 60 FPS
+      SDL_Log("Headless simulation running: %.2f seconds, frame %d", totalTime, frameCount);
+    }
+    
+    // Exit after maxRunTime seconds
+    if (totalTime >= maxRunTime) {
+      SDL_Log("Headless simulation completed after %.2f seconds (%d frames)", totalTime, frameCount);
+      engine->Exit();
+    }
+  }
+
+  void OnDraw(SDL_Renderer* renderer) override {
+    // This should never be called in headless mode
+    SDL_Log("Warning: OnDraw called in headless mode!");
+  }
+
+  void OnGui(ImGuiContext* context) override {
+    // This should never be called in headless mode
+    SDL_Log("Warning: OnGui called in headless mode!");
+  }
+};
+
+// Main code
+int main(int, char**) {
+  SDL_Log("Creating Headless Engine");
+  
+  // Create engine settings with headless mode enabled
+  EngineSettings settings;
+  settings.headless = true;
+  settings.debug = true;
+  
+  auto engine = new Engine(settings);
+  SDL_Log("Headless Engine Created");
+
+  SDL_Log("Creating Test Object");
+  new HeadlessTestObject(engine);
+  SDL_Log("Test Object Created");
+
+  SDL_Log("Starting Headless Engine");
+  if (engine->Start("Headless Test")) {
+    SDL_Log("Headless Engine Started");
+
+    SDL_Log("Running Headless Engine");
+    engine->Run();
+    SDL_Log("Headless Engine Stopped");
+  }
+
+  SDL_Log("Exiting Headless Engine");
+  engine->Exit();
+  delete engine;
+  SDL_Log("Headless Engine Exited");
+  
+  std::cout << "Headless simulation completed successfully!" << std::endl;
+  return 0;
+}