more seperation

2026-05-10 23:53:27 +10:00
parent 7f0f60c0e3
commit 41075bbc61
25 changed files with 733 additions and 1031 deletions
--- a/apps/LoopThroughWithOpenGLCompositing/runtime/RuntimeCoordinator.cpp
+++ b/apps/LoopThroughWithOpenGLCompositing/runtime/RuntimeCoordinator.cpp
@@ -0,0 +1,173 @@
+#include "RuntimeCoordinator.h"
+
+#include "RuntimeStore.h"
+
+RuntimeCoordinator::RuntimeCoordinator(RuntimeStore& runtimeStore) :
+	mRuntimeStore(runtimeStore)
+{
+}
+
+RuntimeCoordinatorResult RuntimeCoordinator::AddLayer(const std::string& shaderId)
+{
+	std::string error;
+	return ApplyStoreMutation(mRuntimeStore.CreateStoredLayer(shaderId, error), error, true, true);
+}
+
+RuntimeCoordinatorResult RuntimeCoordinator::RemoveLayer(const std::string& layerId)
+{
+	std::string error;
+	return ApplyStoreMutation(mRuntimeStore.DeleteStoredLayer(layerId, error), error, true, true);
+}
+
+RuntimeCoordinatorResult RuntimeCoordinator::MoveLayer(const std::string& layerId, int direction)
+{
+	std::string error;
+	return ApplyStoreMutation(mRuntimeStore.MoveStoredLayer(layerId, direction, error), error, true, true);
+}
+
+RuntimeCoordinatorResult RuntimeCoordinator::MoveLayerToIndex(const std::string& layerId, std::size_t targetIndex)
+{
+	std::string error;
+	return ApplyStoreMutation(mRuntimeStore.MoveStoredLayerToIndex(layerId, targetIndex, error), error, true, true);
+}
+
+RuntimeCoordinatorResult RuntimeCoordinator::SetLayerBypass(const std::string& layerId, bool bypassed)
+{
+	std::string error;
+	return ApplyStoreMutation(mRuntimeStore.SetStoredLayerBypassState(layerId, bypassed, error), error, true, false);
+}
+
+RuntimeCoordinatorResult RuntimeCoordinator::SetLayerShader(const std::string& layerId, const std::string& shaderId)
+{
+	std::string error;
+	return ApplyStoreMutation(mRuntimeStore.SetStoredLayerShaderSelection(layerId, shaderId, error), error, true, false);
+}
+
+RuntimeCoordinatorResult RuntimeCoordinator::UpdateLayerParameter(const std::string& layerId, const std::string& parameterId, const JsonValue& newValue)
+{
+	std::string error;
+	return ApplyStoreMutation(mRuntimeStore.SetStoredParameterValue(layerId, parameterId, newValue, error), error, false, false);
+}
+
+RuntimeCoordinatorResult RuntimeCoordinator::UpdateLayerParameterByControlKey(const std::string& layerKey, const std::string& parameterKey, const JsonValue& newValue)
+{
+	std::string error;
+	return ApplyStoreMutation(mRuntimeStore.SetStoredParameterValueByControlKey(layerKey, parameterKey, newValue, error), error, false, false);
+}
+
+RuntimeCoordinatorResult RuntimeCoordinator::ResetLayerParameters(const std::string& layerId)
+{
+	std::string error;
+	RuntimeCoordinatorResult result = ApplyStoreMutation(mRuntimeStore.ResetStoredLayerParameterValues(layerId, error), error, false, false);
+	if (!result.accepted)
+		return result;
+
+	result.clearTransientOscState = true;
+	result.renderResetScope = RuntimeCoordinatorRenderResetScope::TemporalHistoryAndFeedback;
+	return result;
+}
+
+RuntimeCoordinatorResult RuntimeCoordinator::SaveStackPreset(const std::string& presetName)
+{
+	std::string error;
+	return ApplyStoreMutation(mRuntimeStore.SaveStackPresetSnapshot(presetName, error), error, false, false);
+}
+
+RuntimeCoordinatorResult RuntimeCoordinator::LoadStackPreset(const std::string& presetName)
+{
+	std::string error;
+	return ApplyStoreMutation(mRuntimeStore.LoadStackPresetSnapshot(presetName, error), error, true, false);
+}
+
+RuntimeCoordinatorResult RuntimeCoordinator::RequestShaderReload(bool preserveFeedbackState)
+{
+	return BuildQueuedReloadResult(preserveFeedbackState);
+}
+
+RuntimeCoordinatorResult RuntimeCoordinator::HandleRuntimePollFailure(const std::string& error)
+{
+	RuntimeCoordinatorResult result;
+	result.accepted = true;
+	result.runtimeStateBroadcastRequired = true;
+	result.compileStatusChanged = true;
+	result.compileStatusSucceeded = false;
+	result.compileStatusMessage = error;
+	return result;
+}
+
+RuntimeCoordinatorResult RuntimeCoordinator::HandlePreparedShaderBuildFailure(const std::string& error)
+{
+	mPreserveFeedbackOnNextShaderBuild = false;
+
+	RuntimeCoordinatorResult result;
+	result.accepted = true;
+	result.runtimeStateBroadcastRequired = true;
+	result.compileStatusChanged = true;
+	result.compileStatusSucceeded = false;
+	result.compileStatusMessage = error;
+	result.committedStateMode = RuntimeCoordinatorCommittedStateMode::UseCommittedStates;
+	return result;
+}
+
+RuntimeCoordinatorResult RuntimeCoordinator::HandlePreparedShaderBuildSuccess()
+{
+	RuntimeCoordinatorResult result;
+	result.accepted = true;
+	result.runtimeStateBroadcastRequired = true;
+	result.compileStatusChanged = true;
+	result.compileStatusSucceeded = true;
+	result.compileStatusMessage = "Shader layers compiled successfully.";
+	result.committedStateMode = RuntimeCoordinatorCommittedStateMode::UseLiveSnapshots;
+	mPreserveFeedbackOnNextShaderBuild = false;
+	return result;
+}
+
+RuntimeCoordinatorResult RuntimeCoordinator::HandleRuntimeReloadRequest()
+{
+	return BuildQueuedReloadResult(false);
+}
+
+bool RuntimeCoordinator::PreserveFeedbackOnNextShaderBuild() const
+{
+	return mPreserveFeedbackOnNextShaderBuild;
+}
+
+RuntimeCoordinatorResult RuntimeCoordinator::ApplyStoreMutation(bool succeeded, const std::string& errorMessage, bool reloadRequired, bool preserveFeedbackState)
+{
+	if (!succeeded)
+	{
+		RuntimeCoordinatorResult result;
+		result.accepted = false;
+		result.errorMessage = errorMessage;
+		return result;
+	}
+
+	if (reloadRequired)
+		return BuildQueuedReloadResult(preserveFeedbackState);
+
+	return BuildAcceptedNoReloadResult();
+}
+
+RuntimeCoordinatorResult RuntimeCoordinator::BuildQueuedReloadResult(bool preserveFeedbackState)
+{
+	mPreserveFeedbackOnNextShaderBuild = preserveFeedbackState;
+
+	RuntimeCoordinatorResult result;
+	result.accepted = true;
+	result.runtimeStateBroadcastRequired = true;
+	result.shaderBuildRequested = true;
+	result.compileStatusChanged = true;
+	result.compileStatusSucceeded = true;
+	result.compileStatusMessage = "Shader rebuild queued.";
+	result.clearReloadRequest = true;
+	result.committedStateMode = RuntimeCoordinatorCommittedStateMode::UseCommittedStates;
+	return result;
+}
+
+RuntimeCoordinatorResult RuntimeCoordinator::BuildAcceptedNoReloadResult() const
+{
+	RuntimeCoordinatorResult result;
+	result.accepted = true;
+	result.runtimeStateBroadcastRequired = true;
+	return result;
+}
--- a/apps/LoopThroughWithOpenGLCompositing/runtime/RuntimeCoordinator.h
+++ b/apps/LoopThroughWithOpenGLCompositing/runtime/RuntimeCoordinator.h
@@ -0,0 +1,70 @@
+#pragma once
+
+#include "RuntimeJson.h"
+
+#include <cstddef>
+#include <string>
+
+class RuntimeStore;
+
+enum class RuntimeCoordinatorCommittedStateMode
+{
+	Unchanged,
+	UseCommittedStates,
+	UseLiveSnapshots
+};
+
+enum class RuntimeCoordinatorRenderResetScope
+{
+	None,
+	TemporalHistoryOnly,
+	TemporalHistoryAndFeedback
+};
+
+struct RuntimeCoordinatorResult
+{
+	bool accepted = false;
+	bool runtimeStateBroadcastRequired = false;
+	bool shaderBuildRequested = false;
+	bool clearTransientOscState = false;
+	bool compileStatusChanged = false;
+	bool compileStatusSucceeded = false;
+	bool clearReloadRequest = false;
+	RuntimeCoordinatorCommittedStateMode committedStateMode = RuntimeCoordinatorCommittedStateMode::Unchanged;
+	RuntimeCoordinatorRenderResetScope renderResetScope = RuntimeCoordinatorRenderResetScope::None;
+	std::string compileStatusMessage;
+	std::string errorMessage;
+};
+
+class RuntimeCoordinator
+{
+public:
+	explicit RuntimeCoordinator(RuntimeStore& runtimeStore);
+
+	RuntimeCoordinatorResult AddLayer(const std::string& shaderId);
+	RuntimeCoordinatorResult RemoveLayer(const std::string& layerId);
+	RuntimeCoordinatorResult MoveLayer(const std::string& layerId, int direction);
+	RuntimeCoordinatorResult MoveLayerToIndex(const std::string& layerId, std::size_t targetIndex);
+	RuntimeCoordinatorResult SetLayerBypass(const std::string& layerId, bool bypassed);
+	RuntimeCoordinatorResult SetLayerShader(const std::string& layerId, const std::string& shaderId);
+	RuntimeCoordinatorResult UpdateLayerParameter(const std::string& layerId, const std::string& parameterId, const JsonValue& newValue);
+	RuntimeCoordinatorResult UpdateLayerParameterByControlKey(const std::string& layerKey, const std::string& parameterKey, const JsonValue& newValue);
+	RuntimeCoordinatorResult ResetLayerParameters(const std::string& layerId);
+	RuntimeCoordinatorResult SaveStackPreset(const std::string& presetName);
+	RuntimeCoordinatorResult LoadStackPreset(const std::string& presetName);
+
+	RuntimeCoordinatorResult RequestShaderReload(bool preserveFeedbackState = false);
+	RuntimeCoordinatorResult HandleRuntimePollFailure(const std::string& error);
+	RuntimeCoordinatorResult HandlePreparedShaderBuildFailure(const std::string& error);
+	RuntimeCoordinatorResult HandlePreparedShaderBuildSuccess();
+	RuntimeCoordinatorResult HandleRuntimeReloadRequest();
+	bool PreserveFeedbackOnNextShaderBuild() const;
+
+private:
+	RuntimeCoordinatorResult ApplyStoreMutation(bool succeeded, const std::string& errorMessage, bool reloadRequired, bool preserveFeedbackState);
+	RuntimeCoordinatorResult BuildQueuedReloadResult(bool preserveFeedbackState);
+	RuntimeCoordinatorResult BuildAcceptedNoReloadResult() const;
+
+	RuntimeStore& mRuntimeStore;
+	bool mPreserveFeedbackOnNextShaderBuild = false;
+};
--- a/apps/LoopThroughWithOpenGLCompositing/runtime/RuntimeSnapshotProvider.cpp
+++ b/apps/LoopThroughWithOpenGLCompositing/runtime/RuntimeSnapshotProvider.cpp
@@ -12,6 +12,11 @@ bool RuntimeSnapshotProvider::BuildLayerPassFragmentShaderSources(const std::str
 	return mRuntimeHost.BuildLayerPassFragmentShaderSources(layerId, passSources, error);
 }

+unsigned RuntimeSnapshotProvider::GetMaxTemporalHistoryFrames() const
+{
+	return mRuntimeHost.GetMaxTemporalHistoryFrames();
+}
+
 RuntimeSnapshotVersions RuntimeSnapshotProvider::GetVersions() const
 {
 	RuntimeSnapshotVersions versions;
@@ -35,6 +40,16 @@ RuntimeRenderFrameContext RuntimeSnapshotProvider::GetFrameContext() const
 	return frameContext;
 }

+void RuntimeSnapshotProvider::AdvanceFrame()
+{
+	mRuntimeHost.AdvanceFrame();
+}
+
+bool RuntimeSnapshotProvider::TryAdvanceFrame()
+{
+	return mRuntimeHost.TryAdvanceFrame();
+}
+
 RuntimeRenderStateSnapshot RuntimeSnapshotProvider::GetRenderStateSnapshot(unsigned outputWidth, unsigned outputHeight) const
 {
 	for (;;)
--- a/apps/LoopThroughWithOpenGLCompositing/runtime/RuntimeSnapshotProvider.h
+++ b/apps/LoopThroughWithOpenGLCompositing/runtime/RuntimeSnapshotProvider.h
@@ -35,8 +35,11 @@ public:
 	explicit RuntimeSnapshotProvider(RuntimeHost& runtimeHost);

 	bool BuildLayerPassFragmentShaderSources(const std::string& layerId, std::vector<ShaderPassBuildSource>& passSources, std::string& error) const;
+	unsigned GetMaxTemporalHistoryFrames() const;
 	RuntimeSnapshotVersions GetVersions() const;
 	RuntimeRenderFrameContext GetFrameContext() const;
+	void AdvanceFrame();
+	bool TryAdvanceFrame();
 	RuntimeRenderStateSnapshot GetRenderStateSnapshot(unsigned outputWidth, unsigned outputHeight) const;
 	bool TryGetRenderStateSnapshot(unsigned outputWidth, unsigned outputHeight, RuntimeRenderStateSnapshot& snapshot) const;
 	bool TryRefreshSnapshotParameters(RuntimeRenderStateSnapshot& snapshot) const;