git/SDL3CPlusPlus
1
0
Fork 0
mirror of https://github.com/johndoe6345789/SDL3CPlusPlus.git synced 2026-05-02 09:34:58 +00:00
Code Issues Packages Projects Releases Wiki Activity

Stuff

Browse Source
This commit is contained in:
johndoe6345789
2026-01-09 21:57:06 +00:00
parent c6396a2193
commit 9f4036e77a
7 changed files with 187 additions and 16 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
src/app/service_based_app.cpp
View File

@@ -41,6 +41,7 @@
#include "services/impl/workflow_definition_parser.hpp"
#include "services/impl/workflow_executor.hpp"
#include "services/impl/workflow_step_registry.hpp"
#include "services/impl/frame_workflow_service.hpp"
#include "services/interfaces/i_platform_service.hpp"
#include "services/interfaces/i_probe_service.hpp"
#include "services/interfaces/i_render_graph_service.hpp"

34
src/services/impl/application_loop_service.cpp
View File

@@ -12,6 +12,7 @@ ApplicationLoopService::ApplicationLoopService(std::shared_ptr<ILogger> logger,
std::shared_ptr<ISceneService> sceneService,
std::shared_ptr<IRenderCoordinatorService> renderCoordinatorService,
std::shared_ptr<IAudioService> audioService,
std::shared_ptr<IFrameWorkflowService> frameWorkflowService,
std::shared_ptr<ICrashRecoveryService> crashRecoveryService)
: logger_(std::move(logger)),
windowService_(std::move(windowService)),
@@ -21,6 +22,7 @@ ApplicationLoopService::ApplicationLoopService(std::shared_ptr<ILogger> logger,
sceneService_(std::move(sceneService)),
renderCoordinatorService_(std::move(renderCoordinatorService)),
audioService_(std::move(audioService)),
frameWorkflowService_(std::move(frameWorkflowService)),
crashRecoveryService_(std::move(crashRecoveryService)) {
if (logger_) {
logger_->Trace("ApplicationLoopService", "ApplicationLoopService",
@@ -107,24 +109,28 @@ void ApplicationLoopService::ProcessFrame(float deltaTime, float elapsedTime) {
"Entering");
}
if (physicsService_) {
physicsService_->StepSimulation(deltaTime);
}
if (frameWorkflowService_) {
frameWorkflowService_->ExecuteFrame(deltaTime, elapsedTime);
} else {
if (physicsService_) {
physicsService_->StepSimulation(deltaTime);
}
if (sceneService_) {
sceneService_->UpdateScene(deltaTime);
}
if (sceneService_) {
sceneService_->UpdateScene(deltaTime);
}
if (renderCoordinatorService_) {
renderCoordinatorService_->RenderFrame(elapsedTime);
}
if (renderCoordinatorService_) {
renderCoordinatorService_->RenderFrame(elapsedTime);
}
if (audioService_) {
audioService_->Update();
}
if (audioService_) {
audioService_->Update();
}
if (inputService_) {
inputService_->UpdateGuiInput();
if (inputService_) {
inputService_->UpdateGuiInput();
}
}
if (logger_) {

7
src/services/impl/application_loop_service.hpp
View File

@@ -1,6 +1,7 @@
#pragma once
#include "../interfaces/i_application_loop_service.hpp"
#include "../interfaces/i_frame_workflow_service.hpp"
#include "../interfaces/i_audio_service.hpp"
#include "../interfaces/i_crash_recovery_service.hpp"
#include "../interfaces/i_input_service.hpp"
@@ -23,8 +24,9 @@ public:
std::shared_ptr<IPhysicsService> physicsService,
std::shared_ptr<ISceneService> sceneService,
std::shared_ptr<IRenderCoordinatorService> renderCoordinatorService,
std::shared_ptr<IAudioService> audioService,
std::shared_ptr<ICrashRecoveryService> crashRecoveryService);
std::shared_ptr<IAudioService> audioService,
std::shared_ptr<IFrameWorkflowService> frameWorkflowService,
std::shared_ptr<ICrashRecoveryService> crashRecoveryService);
~ApplicationLoopService() override = default;
void Run() override;
@@ -41,6 +43,7 @@ private:
std::shared_ptr<ISceneService> sceneService_;
std::shared_ptr<IRenderCoordinatorService> renderCoordinatorService_;
std::shared_ptr<IAudioService> audioService_;
std::shared_ptr<IFrameWorkflowService> frameWorkflowService_;
std::shared_ptr<ICrashRecoveryService> crashRecoveryService_;
bool running_ = false;
double lastMemoryCheckSeconds_ = 0.0;

51
src/services/impl/frame_workflow_service.cpp Normal file
View File

@@ -0,0 +1,51 @@
#include "frame_workflow_service.hpp"
#include "frame_workflow_step_registrar.hpp"
#include "workflow_definition_parser.hpp"
#include "../interfaces/i_logger.hpp"
#include <stdexcept>
namespace sdl3cpp::services::impl {
FrameWorkflowService::FrameWorkflowService(std::shared_ptr<ILogger> logger,
std::shared_ptr<IAudioService> audioService,
std::shared_ptr<IInputService> inputService,
std::shared_ptr<IPhysicsService> physicsService,
std::shared_ptr<ISceneService> sceneService,
std::shared_ptr<IRenderCoordinatorService> renderService,
const std::filesystem::path& templatePath)
: registry_(std::make_shared<WorkflowStepRegistry>()),
executor_(registry_, logger),
logger_(std::move(logger)) {
std::filesystem::path path = templatePath.empty()
? std::filesystem::current_path() / "config" / "workflows" / "templates" / "frame_default.json"
: templatePath;
WorkflowDefinitionParser parser;
workflow_ = parser.ParseFile(path);
FrameWorkflowStepRegistrar registrar(logger_,
std::move(audioService),
std::move(inputService),
std::move(physicsService),
std::move(sceneService),
std::move(renderService));
registrar.RegisterUsedSteps(workflow_, registry_);
}
void FrameWorkflowService::ExecuteFrame(float deltaTime, float elapsedTime) {
if (logger_) {
logger_->Trace("FrameWorkflowService", "ExecuteFrame",
"delta=" + std::to_string(deltaTime) +
", elapsed=" + std::to_string(elapsedTime),
"Running frame workflow");
}
WorkflowContext context;
context.Set("frame.delta", static_cast<double>(deltaTime));
context.Set("frame.elapsed", static_cast<double>(elapsedTime));
executor_.Execute(workflow_, context);
}
} // namespace sdl3cpp::services::impl

39
src/services/impl/frame_workflow_service.hpp Normal file
View File

@@ -0,0 +1,39 @@
#pragma once
#include "../interfaces/i_frame_workflow_service.hpp"
#include "../interfaces/i_logger.hpp"
#include "../interfaces/i_audio_service.hpp"
#include "../interfaces/i_input_service.hpp"
#include "../interfaces/i_physics_service.hpp"
#include "../interfaces/i_render_coordinator_service.hpp"
#include "../interfaces/i_scene_service.hpp"
#include "workflow_executor.hpp"
#include "workflow_definition_parser.hpp"
#include "workflow_step_registry.hpp"
#include <filesystem>
#include <memory>
namespace sdl3cpp::services::impl {
class FrameWorkflowService final : public IFrameWorkflowService {
public:
FrameWorkflowService(std::shared_ptr<ILogger> logger,
std::shared_ptr<IAudioService> audioService,
std::shared_ptr<IInputService> inputService,
std::shared_ptr<IPhysicsService> physicsService,
std::shared_ptr<ISceneService> sceneService,
std::shared_ptr<IRenderCoordinatorService> renderService,
const std::filesystem::path& templatePath = {});
void ExecuteFrame(float deltaTime, float elapsedTime) override;
private:
WorkflowDefinition workflow_;
std::shared_ptr<WorkflowStepRegistry> registry_;
WorkflowExecutor executor_;
std::shared_ptr<ILogger> logger_;
};
} // namespace sdl3cpp::services::impl

60
src/services/impl/frame_workflow_step_registrar.cpp Normal file
View File

@@ -0,0 +1,60 @@
#include "frame_workflow_step_registrar.hpp"
#include "workflow_frame_audio_step.hpp"
#include "workflow_frame_begin_step.hpp"
#include "workflow_frame_gui_step.hpp"
#include "workflow_frame_physics_step.hpp"
#include "workflow_frame_render_step.hpp"
#include "workflow_frame_scene_step.hpp"
#include "workflow_step_registry.hpp"
#include <stdexcept>
#include <unordered_set>
namespace sdl3cpp::services::impl {
FrameWorkflowStepRegistrar::FrameWorkflowStepRegistrar(std::shared_ptr<ILogger> logger,
std::shared_ptr<IAudioService> audioService,
std::shared_ptr<IInputService> inputService,
std::shared_ptr<IPhysicsService> physicsService,
std::shared_ptr<ISceneService> sceneService,
std::shared_ptr<IRenderCoordinatorService> renderService)
: logger_(std::move(logger)),
audioService_(std::move(audioService)),
inputService_(std::move(inputService)),
physicsService_(std::move(physicsService)),
sceneService_(std::move(sceneService)),
renderService_(std::move(renderService)) {}
void FrameWorkflowStepRegistrar::RegisterUsedSteps(
const WorkflowDefinition& workflow,
const std::shared_ptr<IWorkflowStepRegistry>& registry) const {
if (!registry) {
throw std::runtime_error("FrameWorkflowStepRegistrar: registry is null");
}
std::unordered_set<std::string> plugins;
for (const auto& step : workflow.steps) {
plugins.insert(step.plugin);
}
if (plugins.contains("frame.begin")) {
registry->RegisterStep(std::make_shared<WorkflowFrameBeginStep>(logger_));
}
if (plugins.contains("frame.physics")) {
registry->RegisterStep(std::make_shared<WorkflowFramePhysicsStep>(physicsService_, logger_));
}
if (plugins.contains("frame.scene")) {
registry->RegisterStep(std::make_shared<WorkflowFrameSceneStep>(sceneService_, logger_));
}
if (plugins.contains("frame.render")) {
registry->RegisterStep(std::make_shared<WorkflowFrameRenderStep>(renderService_, logger_));
}
if (plugins.contains("frame.audio")) {
registry->RegisterStep(std::make_shared<WorkflowFrameAudioStep>(audioService_, logger_));
}
if (plugins.contains("frame.gui")) {
registry->RegisterStep(std::make_shared<WorkflowFrameGuiStep>(inputService_, logger_));
}
}
} // namespace sdl3cpp::services::impl

11
src/services/interfaces/i_frame_workflow_service.hpp Normal file
View File

@@ -0,0 +1,11 @@
#pragma once
namespace sdl3cpp::services {
class IFrameWorkflowService {
public:
virtual ~IFrameWorkflowService() = default;
virtual void ExecuteFrame(float deltaTime, float elapsedTime) = 0;
};
} // namespace sdl3cpp::services