re organisation

2026-05-11 02:11:51 +10:00
parent 5cbdbd6813
commit cbf1b541dc
35 changed files with 92 additions and 78 deletions
--- a/apps/LoopThroughWithOpenGLCompositing/runtime/coordination/RuntimeCoordinator.cpp
+++ b/apps/LoopThroughWithOpenGLCompositing/runtime/coordination/RuntimeCoordinator.cpp
@@ -0,0 +1,370 @@
+#include "RuntimeCoordinator.h"
+
+#include "RuntimeParameterUtils.h"
+#include "RuntimeStore.h"
+
+RuntimeCoordinator::RuntimeCoordinator(RuntimeStore& runtimeStore) :
+	mRuntimeStore(runtimeStore)
+{
+}
+
+RuntimeCoordinatorResult RuntimeCoordinator::AddLayer(const std::string& shaderId)
+{
+	std::lock_guard<std::mutex> lock(mMutex);
+	std::string error;
+	if (!ValidateShaderExists(shaderId, error))
+		return ApplyStoreMutation(false, error, false, false);
+
+	return ApplyStoreMutation(mRuntimeStore.CreateStoredLayer(shaderId, error), error, true, true);
+}
+
+RuntimeCoordinatorResult RuntimeCoordinator::RemoveLayer(const std::string& layerId)
+{
+	std::lock_guard<std::mutex> lock(mMutex);
+	std::string error;
+	if (!ValidateLayerExists(layerId, error))
+		return ApplyStoreMutation(false, error, false, false);
+
+	return ApplyStoreMutation(mRuntimeStore.DeleteStoredLayer(layerId, error), error, true, true);
+}
+
+RuntimeCoordinatorResult RuntimeCoordinator::MoveLayer(const std::string& layerId, int direction)
+{
+	std::lock_guard<std::mutex> lock(mMutex);
+	std::string error;
+	bool shouldMove = false;
+	if (!ResolveLayerMove(layerId, direction, shouldMove, error))
+		return ApplyStoreMutation(false, error, false, false);
+	if (!shouldMove)
+		return BuildAcceptedNoReloadResult();
+
+	return ApplyStoreMutation(mRuntimeStore.MoveStoredLayer(layerId, direction, error), error, true, true);
+}
+
+RuntimeCoordinatorResult RuntimeCoordinator::MoveLayerToIndex(const std::string& layerId, std::size_t targetIndex)
+{
+	std::lock_guard<std::mutex> lock(mMutex);
+	std::string error;
+	bool shouldMove = false;
+	if (!ResolveLayerMoveToIndex(layerId, targetIndex, shouldMove, error))
+		return ApplyStoreMutation(false, error, false, false);
+	if (!shouldMove)
+		return BuildAcceptedNoReloadResult();
+
+	return ApplyStoreMutation(mRuntimeStore.MoveStoredLayerToIndex(layerId, targetIndex, error), error, true, true);
+}
+
+RuntimeCoordinatorResult RuntimeCoordinator::SetLayerBypass(const std::string& layerId, bool bypassed)
+{
+	std::lock_guard<std::mutex> lock(mMutex);
+	std::string error;
+	if (!ValidateLayerExists(layerId, error))
+		return ApplyStoreMutation(false, error, false, false);
+
+	return ApplyStoreMutation(mRuntimeStore.SetStoredLayerBypassState(layerId, bypassed, error), error, true, false);
+}
+
+RuntimeCoordinatorResult RuntimeCoordinator::SetLayerShader(const std::string& layerId, const std::string& shaderId)
+{
+	std::lock_guard<std::mutex> lock(mMutex);
+	std::string error;
+	if (!ValidateLayerExists(layerId, error) || !ValidateShaderExists(shaderId, error))
+		return ApplyStoreMutation(false, error, false, false);
+
+	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::lock_guard<std::mutex> lock(mMutex);
+	std::string error;
+	ResolvedParameterMutation mutation;
+	if (!BuildParameterMutationById(layerId, parameterId, newValue, true, mutation, error))
+		return ApplyStoreMutation(false, error, false, false);
+
+	return ApplyStoreMutation(mRuntimeStore.SetStoredParameterValue(mutation.layerId, mutation.parameterId, mutation.value, mutation.persistState, error), error, false, false);
+}
+
+RuntimeCoordinatorResult RuntimeCoordinator::UpdateLayerParameterByControlKey(const std::string& layerKey, const std::string& parameterKey, const JsonValue& newValue)
+{
+	std::lock_guard<std::mutex> lock(mMutex);
+	std::string error;
+	ResolvedParameterMutation mutation;
+	if (!BuildParameterMutationByControlKey(layerKey, parameterKey, newValue, true, mutation, error))
+		return ApplyStoreMutation(false, error, false, false);
+
+	return ApplyStoreMutation(mRuntimeStore.SetStoredParameterValue(mutation.layerId, mutation.parameterId, mutation.value, mutation.persistState, error), error, false, false);
+}
+
+RuntimeCoordinatorResult RuntimeCoordinator::CommitOscParameterByControlKey(const std::string& layerKey, const std::string& parameterKey, const JsonValue& newValue)
+{
+	std::lock_guard<std::mutex> lock(mMutex);
+	std::string error;
+	ResolvedParameterMutation mutation;
+	if (!BuildParameterMutationByControlKey(layerKey, parameterKey, newValue, false, mutation, error))
+		return ApplyStoreMutation(false, error, false, false);
+
+	return ApplyStoreMutation(mRuntimeStore.SetStoredParameterValue(mutation.layerId, mutation.parameterId, mutation.value, mutation.persistState, error), error, false, false);
+}
+
+RuntimeCoordinatorResult RuntimeCoordinator::ResetLayerParameters(const std::string& layerId)
+{
+	std::lock_guard<std::mutex> lock(mMutex);
+	std::string error;
+	if (!ValidateLayerExists(layerId, error))
+		return ApplyStoreMutation(false, error, false, false);
+
+	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::lock_guard<std::mutex> lock(mMutex);
+	std::string error;
+	if (!ValidatePresetName(presetName, error))
+		return ApplyStoreMutation(false, error, false, false);
+
+	return ApplyStoreMutation(mRuntimeStore.SaveStackPresetSnapshot(presetName, error), error, false, false);
+}
+
+RuntimeCoordinatorResult RuntimeCoordinator::LoadStackPreset(const std::string& presetName)
+{
+	std::lock_guard<std::mutex> lock(mMutex);
+	std::string error;
+	if (!ValidatePresetName(presetName, error))
+		return ApplyStoreMutation(false, error, false, false);
+
+	return ApplyStoreMutation(mRuntimeStore.LoadStackPresetSnapshot(presetName, error), error, true, false);
+}
+
+RuntimeCoordinatorResult RuntimeCoordinator::RequestShaderReload(bool preserveFeedbackState)
+{
+	std::lock_guard<std::mutex> lock(mMutex);
+	return BuildQueuedReloadResult(preserveFeedbackState);
+}
+
+RuntimeCoordinatorResult RuntimeCoordinator::PollRuntimeStoreChanges(bool& registryChanged)
+{
+	std::lock_guard<std::mutex> lock(mMutex);
+
+	registryChanged = false;
+	bool reloadRequested = false;
+	std::string error;
+	if (!mRuntimeStore.PollStoredFileChanges(registryChanged, reloadRequested, error))
+		return HandleRuntimePollFailure(error);
+
+	if (reloadRequested)
+		return BuildQueuedReloadResult(false);
+
+	if (registryChanged)
+		return BuildAcceptedNoReloadResult();
+
+	RuntimeCoordinatorResult result;
+	result.accepted = true;
+	return result;
+}
+
+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)
+{
+	std::lock_guard<std::mutex> lock(mMutex);
+	mPreserveFeedbackOnNextShaderBuild = false;
+	mUseCommittedLayerStates = true;
+
+	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()
+{
+	std::lock_guard<std::mutex> lock(mMutex);
+	mUseCommittedLayerStates = false;
+
+	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()
+{
+	std::lock_guard<std::mutex> lock(mMutex);
+	return BuildQueuedReloadResult(false);
+}
+
+void RuntimeCoordinator::ApplyCommittedStateMode(RuntimeCoordinatorCommittedStateMode mode)
+{
+	std::lock_guard<std::mutex> lock(mMutex);
+	switch (mode)
+	{
+	case RuntimeCoordinatorCommittedStateMode::UseCommittedStates:
+		mUseCommittedLayerStates = true;
+		break;
+	case RuntimeCoordinatorCommittedStateMode::UseLiveSnapshots:
+		mUseCommittedLayerStates = false;
+		break;
+	case RuntimeCoordinatorCommittedStateMode::Unchanged:
+	default:
+		break;
+	}
+}
+
+bool RuntimeCoordinator::UseCommittedLayerStates() const
+{
+	return mUseCommittedLayerStates.load();
+}
+
+bool RuntimeCoordinator::PreserveFeedbackOnNextShaderBuild() const
+{
+	std::lock_guard<std::mutex> lock(mMutex);
+	return mPreserveFeedbackOnNextShaderBuild;
+}
+
+bool RuntimeCoordinator::BuildParameterMutationById(const std::string& layerId, const std::string& parameterId, const JsonValue& newValue,
+	bool persistState, ResolvedParameterMutation& mutation, std::string& error) const
+{
+	RuntimeStore::StoredParameterSnapshot snapshot;
+	if (!mRuntimeStore.TryGetStoredParameterById(layerId, parameterId, snapshot, error))
+		return false;
+
+	return BuildParameterMutationFromSnapshot(snapshot.layerId, snapshot.definition, snapshot.currentValue, snapshot.hasCurrentValue,
+		newValue, persistState, mutation, error);
+}
+
+bool RuntimeCoordinator::BuildParameterMutationByControlKey(const std::string& layerKey, const std::string& parameterKey, const JsonValue& newValue,
+	bool persistState, ResolvedParameterMutation& mutation, std::string& error) const
+{
+	RuntimeStore::StoredParameterSnapshot snapshot;
+	if (!mRuntimeStore.TryGetStoredParameterByControlKey(layerKey, parameterKey, snapshot, error))
+		return false;
+
+	return BuildParameterMutationFromSnapshot(snapshot.layerId, snapshot.definition, snapshot.currentValue, snapshot.hasCurrentValue,
+		newValue, persistState, mutation, error);
+}
+
+bool RuntimeCoordinator::BuildParameterMutationFromSnapshot(const std::string& layerId, const ShaderParameterDefinition& definition,
+	const ShaderParameterValue& currentValue, bool hasCurrentValue, const JsonValue& newValue,
+	bool persistState, ResolvedParameterMutation& mutation, std::string& error) const
+{
+	mutation.layerId = layerId;
+	mutation.parameterId = definition.id;
+	mutation.persistState = persistState;
+
+	if (definition.type == ShaderParameterType::Trigger)
+	{
+		const double previousCount = !hasCurrentValue || currentValue.numberValues.empty()
+			? 0.0
+			: currentValue.numberValues[0];
+		const double triggerTime = mRuntimeStore.GetRuntimeElapsedSeconds();
+		mutation.value.numberValues = { previousCount + 1.0, triggerTime };
+		mutation.persistState = false;
+		return true;
+	}
+
+	return NormalizeAndValidateParameterValue(definition, newValue, mutation.value, error);
+}
+
+bool RuntimeCoordinator::ValidateLayerExists(const std::string& layerId, std::string& error) const
+{
+	if (mRuntimeStore.HasStoredLayer(layerId))
+		return true;
+
+	error = "Unknown layer id: " + layerId;
+	return false;
+}
+
+bool RuntimeCoordinator::ValidateShaderExists(const std::string& shaderId, std::string& error) const
+{
+	if (mRuntimeStore.HasStoredShader(shaderId))
+		return true;
+
+	error = "Unknown shader id: " + shaderId;
+	return false;
+}
+
+bool RuntimeCoordinator::ResolveLayerMove(const std::string& layerId, int direction, bool& shouldMove, std::string& error) const
+{
+	return mRuntimeStore.ResolveStoredLayerMove(layerId, direction, shouldMove, error);
+}
+
+bool RuntimeCoordinator::ResolveLayerMoveToIndex(const std::string& layerId, std::size_t targetIndex, bool& shouldMove, std::string& error) const
+{
+	return mRuntimeStore.ResolveStoredLayerMoveToIndex(layerId, targetIndex, shouldMove, error);
+}
+
+bool RuntimeCoordinator::ValidatePresetName(const std::string& presetName, std::string& error) const
+{
+	if (mRuntimeStore.IsValidStackPresetName(presetName))
+		return true;
+
+	error = "Preset name must include at least one letter or number.";
+	return false;
+}
+
+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;
+	mUseCommittedLayerStates = true;
+
+	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/coordination/RuntimeCoordinator.h
+++ b/apps/LoopThroughWithOpenGLCompositing/runtime/coordination/RuntimeCoordinator.h
@@ -0,0 +1,99 @@
+#pragma once
+
+#include "RuntimeJson.h"
+#include "ShaderTypes.h"
+
+#include <atomic>
+#include <cstddef>
+#include <mutex>
+#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 CommitOscParameterByControlKey(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 PollRuntimeStoreChanges(bool& registryChanged);
+	RuntimeCoordinatorResult HandleRuntimePollFailure(const std::string& error);
+	RuntimeCoordinatorResult HandlePreparedShaderBuildFailure(const std::string& error);
+	RuntimeCoordinatorResult HandlePreparedShaderBuildSuccess();
+	RuntimeCoordinatorResult HandleRuntimeReloadRequest();
+	void ApplyCommittedStateMode(RuntimeCoordinatorCommittedStateMode mode);
+	bool UseCommittedLayerStates() const;
+	bool PreserveFeedbackOnNextShaderBuild() const;
+
+private:
+	struct ResolvedParameterMutation
+	{
+		std::string layerId;
+		std::string parameterId;
+		ShaderParameterValue value;
+		bool persistState = true;
+	};
+
+	bool BuildParameterMutationById(const std::string& layerId, const std::string& parameterId, const JsonValue& newValue,
+		bool persistState, ResolvedParameterMutation& mutation, std::string& error) const;
+	bool BuildParameterMutationByControlKey(const std::string& layerKey, const std::string& parameterKey, const JsonValue& newValue,
+		bool persistState, ResolvedParameterMutation& mutation, std::string& error) const;
+	bool BuildParameterMutationFromSnapshot(const std::string& layerId, const ShaderParameterDefinition& definition,
+		const ShaderParameterValue& currentValue, bool hasCurrentValue, const JsonValue& newValue,
+		bool persistState, ResolvedParameterMutation& mutation, std::string& error) const;
+	bool ValidateLayerExists(const std::string& layerId, std::string& error) const;
+	bool ValidateShaderExists(const std::string& shaderId, std::string& error) const;
+	bool ResolveLayerMove(const std::string& layerId, int direction, bool& shouldMove, std::string& error) const;
+	bool ResolveLayerMoveToIndex(const std::string& layerId, std::size_t targetIndex, bool& shouldMove, std::string& error) const;
+	bool ValidatePresetName(const std::string& presetName, std::string& error) const;
+	RuntimeCoordinatorResult ApplyStoreMutation(bool succeeded, const std::string& errorMessage, bool reloadRequired, bool preserveFeedbackState);
+	RuntimeCoordinatorResult BuildQueuedReloadResult(bool preserveFeedbackState);
+	RuntimeCoordinatorResult BuildAcceptedNoReloadResult() const;
+
+	RuntimeStore& mRuntimeStore;
+	mutable std::mutex mMutex;
+	bool mPreserveFeedbackOnNextShaderBuild = false;
+	std::atomic<bool> mUseCommittedLayerStates{ false };
+};