mirror of
https://github.com/johndoe6345789/SDL3CPlusPlus.git
synced 2026-04-24 21:55:09 +00:00
110 lines
3.8 KiB
C++
110 lines
3.8 KiB
C++
#include "application_controller.hpp"
|
|
#include "render_controller.hpp"
|
|
#include "../services/interfaces/i_logger.hpp"
|
|
#include "../services/interfaces/i_window_service.hpp"
|
|
#include "../services/interfaces/i_input_service.hpp"
|
|
#include "../services/interfaces/i_physics_service.hpp"
|
|
#include "../services/interfaces/i_scene_service.hpp"
|
|
#include "../events/event_bus.hpp"
|
|
#include "../events/event_types.hpp"
|
|
#include <chrono>
|
|
|
|
namespace sdl3cpp::controllers {
|
|
|
|
ApplicationController::ApplicationController(di::ServiceRegistry& registry)
|
|
: registry_(registry), logger_(registry.GetService<services::ILogger>()), running_(false) {
|
|
logger_->Trace("ApplicationController", "ApplicationController", "", "Created");
|
|
}
|
|
|
|
ApplicationController::~ApplicationController() {
|
|
logger_->Trace("ApplicationController", "~ApplicationController", "", "Destroyed");
|
|
}
|
|
|
|
void ApplicationController::Run() {
|
|
logger_->Trace("ApplicationController", "Run", "", "Entering");
|
|
logger_->Info("ApplicationController::Run: ApplicationController::Run starting");
|
|
logger_->Info("ApplicationController::Run: Application starting main loop");
|
|
|
|
running_ = true;
|
|
auto lastTime = std::chrono::high_resolution_clock::now();
|
|
auto startTime = lastTime;
|
|
const auto timeout = std::chrono::seconds(5); // Exit after 5 seconds for testing
|
|
|
|
while (running_) {
|
|
auto currentTime = std::chrono::high_resolution_clock::now();
|
|
|
|
// Exit after timeout for headless testing
|
|
if (currentTime - startTime > timeout) {
|
|
logger_->Info("ApplicationController::Run: Application timeout reached, exiting");
|
|
running_ = false;
|
|
break;
|
|
}
|
|
|
|
float deltaTime = std::chrono::duration<float>(currentTime - lastTime).count();
|
|
lastTime = currentTime;
|
|
|
|
HandleEvents();
|
|
ProcessFrame(deltaTime);
|
|
}
|
|
|
|
logger_->Info("ApplicationController::Run: Application exiting main loop");
|
|
logger_->Trace("ApplicationController", "Run", "", "Exiting");
|
|
}
|
|
|
|
void ApplicationController::HandleEvents() {
|
|
// Window service polls SDL events and publishes to event bus
|
|
auto windowService = registry_.GetService<services::IWindowService>();
|
|
if (windowService) {
|
|
windowService->PollEvents();
|
|
}
|
|
|
|
// Check for quit events
|
|
auto eventBus = registry_.GetService<events::EventBus>();
|
|
if (eventBus) {
|
|
// Process queued events
|
|
eventBus->ProcessQueue();
|
|
}
|
|
|
|
// Check if window should close
|
|
if (windowService && windowService->ShouldClose()) {
|
|
running_ = false;
|
|
}
|
|
}
|
|
|
|
void ApplicationController::ProcessFrame(float deltaTime) {
|
|
logger_->Trace("ApplicationController", "ProcessFrame", "deltaTime=" + std::to_string(deltaTime), "Entering");
|
|
|
|
// Reset input frame state
|
|
auto inputService = registry_.GetService<services::IInputService>();
|
|
if (inputService) {
|
|
inputService->ResetFrameState();
|
|
}
|
|
|
|
// Update physics
|
|
auto physicsService = registry_.GetService<services::IPhysicsService>();
|
|
if (physicsService) {
|
|
physicsService->StepSimulation(deltaTime);
|
|
}
|
|
|
|
// Update scene
|
|
auto sceneService = registry_.GetService<services::ISceneService>();
|
|
if (sceneService) {
|
|
sceneService->UpdateScene(deltaTime);
|
|
}
|
|
|
|
// Update GUI input to script service
|
|
if (inputService) {
|
|
inputService->UpdateGuiInput();
|
|
}
|
|
|
|
// Render frame
|
|
// Temporarily disabled for testing
|
|
// auto renderController = std::make_unique<RenderController>(registry_);
|
|
// renderController->RenderFrame(static_cast<float>(std::chrono::duration_cast<std::chrono::milliseconds>(
|
|
// std::chrono::high_resolution_clock::now().time_since_epoch()).count()) / 1000.0f);
|
|
|
|
logger_->Trace("ApplicationController", "ProcessFrame", "", "Exiting");
|
|
}
|
|
|
|
} // namespace sdl3cpp::controllers
|