pass 2

apps/LoopThroughWithOpenGLCompositing/gl/OpenGLComposite.cpp

@@ -4,8 +4,12 @@
 #include "GlRenderConstants.h"
 #include "PngScreenshotWriter.h"
 #include "RenderEngine.h"
+#include "RuntimeCoordinator.h"
 #include "RuntimeParameterUtils.h"
 #include "RuntimeServices.h"
+#include "RuntimeSnapshotProvider.h"
+#include "RuntimeStore.h"
+#include "RuntimeUpdateController.h"
 #include "ShaderBuildQueue.h"
 #include "VideoBackend.h"
 
@@ -46,6 +50,13 @@ OpenGLComposite::OpenGLComposite(HWND hWnd, HDC hDC, HGLRC hRC) :
 	mVideoBackend = std::make_unique<VideoBackend>(*mRenderEngine, mRuntimeStore->GetHealthTelemetry());
 	mShaderBuildQueue = std::make_unique<ShaderBuildQueue>(*mRuntimeSnapshotProvider);
 	mRuntimeServices = std::make_unique<RuntimeServices>();
+	mRuntimeUpdateController = std::make_unique<RuntimeUpdateController>(
+		*mRuntimeStore,
+		*mRuntimeCoordinator,
+		*mRuntimeServices,
+		*mRenderEngine,
+		*mShaderBuildQueue,
+		*mVideoBackend);
 }
 
 OpenGLComposite::~OpenGLComposite()
@@ -245,7 +256,7 @@ bool OpenGLComposite::InitOpenGLState()
 	mRenderEngine->ResetTemporalHistoryState();
 	mRenderEngine->ResetShaderFeedbackState();
 
-	broadcastRuntimeState();
+	mRuntimeUpdateController->BroadcastRuntimeState();
 	mRuntimeServices->BeginPolling(*mRuntimeCoordinator);
 	return true;
 }
@@ -273,7 +284,8 @@ bool OpenGLComposite::Stop()
 bool OpenGLComposite::ReloadShader(bool preserveFeedbackState)
 {
 	return mRuntimeCoordinator &&
-		ApplyRuntimeCoordinatorResult(mRuntimeCoordinator->RequestShaderReload(preserveFeedbackState));
+		mRuntimeUpdateController &&
+		mRuntimeUpdateController->ApplyRuntimeCoordinatorResult(mRuntimeCoordinator->RequestShaderReload(preserveFeedbackState));
 }
 
 bool OpenGLComposite::RequestScreenshot(std::string& error)
@@ -285,7 +297,8 @@ bool OpenGLComposite::RequestScreenshot(std::string& error)
 
 void OpenGLComposite::renderEffect()
 {
-	ProcessRuntimePollResults();
+	if (mRuntimeUpdateController)
+		mRuntimeUpdateController->ProcessRuntimeWork();
 	std::vector<RuntimeServices::AppliedOscUpdate> appliedOscUpdates;
 	std::vector<RuntimeServices::CompletedOscCommit> completedOscCommits;
 	if (mRuntimeServices)
@@ -400,105 +413,7 @@ std::filesystem::path OpenGLComposite::BuildScreenshotPath() const
 	return root / "screenshots" / filename.str();
 }
 
-bool OpenGLComposite::ProcessRuntimePollResults()
-{
-	if (!mRuntimeServices)
-		return true;
-
-	bool shaderBuildRequested = false;
-	std::vector<RuntimeCoordinatorServiceResult> serviceResults;
-	mRuntimeServices->ConsumeRuntimeCoordinatorResults(serviceResults);
-	for (const RuntimeCoordinatorServiceResult& serviceResult : serviceResults)
-	{
-		shaderBuildRequested = shaderBuildRequested || serviceResult.result.shaderBuildRequested;
-		ApplyRuntimeCoordinatorResult(serviceResult.result);
-		if (serviceResult.failed)
-			return false;
-	}
-
-	if (!shaderBuildRequested)
-	{
-		if (!mShaderBuildQueue || !mRenderEngine)
-			return true;
-
-		const RenderEngine::PreparedShaderBuildApplyResult buildResult = mRenderEngine->TryApplyReadyShaderBuild(
-			*mShaderBuildQueue,
-			mVideoBackend->InputFrameWidth(),
-			mVideoBackend->InputFrameHeight(),
-			mRuntimeCoordinator && mRuntimeCoordinator->PreserveFeedbackOnNextShaderBuild());
-		if (!buildResult.hadReadyBuild)
-			return true;
-
-		if (!buildResult.applied)
-		{
-			ApplyRuntimeCoordinatorResult(mRuntimeCoordinator->HandlePreparedShaderBuildFailure(buildResult.errorMessage));
-			return false;
-		}
-
-		ApplyRuntimeCoordinatorResult(mRuntimeCoordinator->HandlePreparedShaderBuildSuccess());
-		return true;
-	}
-
-	return true;
-}
-
-void OpenGLComposite::RequestShaderBuild()
-{
-	if (!mShaderBuildQueue || !mVideoBackend)
-		return;
-
-	mShaderBuildQueue->RequestBuild(mVideoBackend->InputFrameWidth(), mVideoBackend->InputFrameHeight());
-}
-
-bool OpenGLComposite::ApplyRuntimeCoordinatorResult(const RuntimeCoordinatorResult& result, std::string* error)
-{
-	if (!result.accepted)
-	{
-		if (error)
-			*error = result.errorMessage;
-		return false;
-	}
-
-	if (result.compileStatusChanged && mRuntimeStore)
-		mRuntimeStore->SetCompileStatus(result.compileStatusSucceeded, result.compileStatusMessage);
-
-	if (result.clearReloadRequest && mRuntimeStore)
-		mRuntimeStore->ClearReloadRequest();
-
-	if (mRuntimeCoordinator)
-		mRuntimeCoordinator->ApplyCommittedStateMode(result.committedStateMode);
-
-	if (result.clearTransientOscState)
-	{
-		if (mRenderEngine)
-			mRenderEngine->ClearOscOverlayState();
-		if (mRuntimeServices)
-			mRuntimeServices->ClearOscState();
-	}
-
-	if (mRenderEngine)
-		mRenderEngine->ApplyRuntimeCoordinatorRenderReset(result.renderResetScope);
-
-	if (result.shaderBuildRequested)
-		RequestShaderBuild();
-
-	if (result.runtimeStateBroadcastRequired)
-		broadcastRuntimeState();
-
-	return true;
-}
-
-void OpenGLComposite::broadcastRuntimeState()
-{
-	if (mRuntimeServices)
-		mRuntimeServices->BroadcastState();
-}
-
 bool OpenGLComposite::CheckOpenGLExtensions()
 {
 	return true;
 }
-
-////////////////////////////////////////////
-
-

apps/LoopThroughWithOpenGLCompositing/gl/OpenGLComposite.h

@@ -12,9 +12,6 @@
 #include <comutil.h>
 
 #include "GLExtensions.h"
-#include "RuntimeCoordinator.h"
-#include "RuntimeSnapshotProvider.h"
-#include "RuntimeStore.h"
 
 #include <functional>
 #include <atomic>
@@ -24,7 +21,11 @@
 #include <vector>
 
 class RenderEngine;
+class RuntimeCoordinator;
+class RuntimeSnapshotProvider;
 class RuntimeServices;
+class RuntimeStore;
+class RuntimeUpdateController;
 class ShaderBuildQueue;
 class VideoBackend;
 
@@ -78,17 +79,14 @@ private:
 	std::unique_ptr<RenderEngine>			mRenderEngine;
 	std::unique_ptr<ShaderBuildQueue>		mShaderBuildQueue;
 	std::unique_ptr<RuntimeServices>		mRuntimeServices;
+	std::unique_ptr<RuntimeUpdateController> mRuntimeUpdateController;
 	std::unique_ptr<VideoBackend>			mVideoBackend;
 	std::atomic<bool>						mScreenshotRequested;
 
 	bool InitOpenGLState();
 	void renderEffect();
-	bool ProcessRuntimePollResults();
-	void RequestShaderBuild();
-	bool ApplyRuntimeCoordinatorResult(const RuntimeCoordinatorResult& result, std::string* error = nullptr);
 	void ProcessScreenshotRequest();
 	std::filesystem::path BuildScreenshotPath() const;
-	void broadcastRuntimeState();
 };
 
 #endif		// __OPENGL_COMPOSITE_H__

apps/LoopThroughWithOpenGLCompositing/gl/OpenGLCompositeRuntimeControls.cpp

@@ -1,5 +1,9 @@
 #include "OpenGLComposite.h"
+#include "RuntimeCoordinator.h"
+#include "RuntimeJson.h"
 #include "RuntimeServices.h"
+#include "RuntimeStore.h"
+#include "RuntimeUpdateController.h"
 
 std::string OpenGLComposite::GetRuntimeStateJson() const
 {
@@ -39,37 +43,43 @@ std::string OpenGLComposite::GetOscAddress() const
 bool OpenGLComposite::AddLayer(const std::string& shaderId, std::string& error)
 {
 	return mRuntimeCoordinator &&
-		ApplyRuntimeCoordinatorResult(mRuntimeCoordinator->AddLayer(shaderId), &error);
+		mRuntimeUpdateController &&
+		mRuntimeUpdateController->ApplyRuntimeCoordinatorResult(mRuntimeCoordinator->AddLayer(shaderId), &error);
 }
 
 bool OpenGLComposite::RemoveLayer(const std::string& layerId, std::string& error)
 {
 	return mRuntimeCoordinator &&
-		ApplyRuntimeCoordinatorResult(mRuntimeCoordinator->RemoveLayer(layerId), &error);
+		mRuntimeUpdateController &&
+		mRuntimeUpdateController->ApplyRuntimeCoordinatorResult(mRuntimeCoordinator->RemoveLayer(layerId), &error);
 }
 
 bool OpenGLComposite::MoveLayer(const std::string& layerId, int direction, std::string& error)
 {
 	return mRuntimeCoordinator &&
-		ApplyRuntimeCoordinatorResult(mRuntimeCoordinator->MoveLayer(layerId, direction), &error);
+		mRuntimeUpdateController &&
+		mRuntimeUpdateController->ApplyRuntimeCoordinatorResult(mRuntimeCoordinator->MoveLayer(layerId, direction), &error);
 }
 
 bool OpenGLComposite::MoveLayerToIndex(const std::string& layerId, std::size_t targetIndex, std::string& error)
 {
 	return mRuntimeCoordinator &&
-		ApplyRuntimeCoordinatorResult(mRuntimeCoordinator->MoveLayerToIndex(layerId, targetIndex), &error);
+		mRuntimeUpdateController &&
+		mRuntimeUpdateController->ApplyRuntimeCoordinatorResult(mRuntimeCoordinator->MoveLayerToIndex(layerId, targetIndex), &error);
 }
 
 bool OpenGLComposite::SetLayerBypass(const std::string& layerId, bool bypassed, std::string& error)
 {
 	return mRuntimeCoordinator &&
-		ApplyRuntimeCoordinatorResult(mRuntimeCoordinator->SetLayerBypass(layerId, bypassed), &error);
+		mRuntimeUpdateController &&
+		mRuntimeUpdateController->ApplyRuntimeCoordinatorResult(mRuntimeCoordinator->SetLayerBypass(layerId, bypassed), &error);
 }
 
 bool OpenGLComposite::SetLayerShader(const std::string& layerId, const std::string& shaderId, std::string& error)
 {
 	return mRuntimeCoordinator &&
-		ApplyRuntimeCoordinatorResult(mRuntimeCoordinator->SetLayerShader(layerId, shaderId), &error);
+		mRuntimeUpdateController &&
+		mRuntimeUpdateController->ApplyRuntimeCoordinatorResult(mRuntimeCoordinator->SetLayerShader(layerId, shaderId), &error);
 }
 
 bool OpenGLComposite::UpdateLayerParameterJson(const std::string& layerId, const std::string& parameterId, const std::string& valueJson, std::string& error)
@@ -79,7 +89,8 @@ bool OpenGLComposite::UpdateLayerParameterJson(const std::string& layerId, const
 		return false;
 
 	return mRuntimeCoordinator &&
-		ApplyRuntimeCoordinatorResult(mRuntimeCoordinator->UpdateLayerParameter(layerId, parameterId, parsedValue), &error);
+		mRuntimeUpdateController &&
+		mRuntimeUpdateController->ApplyRuntimeCoordinatorResult(mRuntimeCoordinator->UpdateLayerParameter(layerId, parameterId, parsedValue), &error);
 }
 
 bool OpenGLComposite::UpdateLayerParameterByControlKeyJson(const std::string& layerKey, const std::string& parameterKey, const std::string& valueJson, std::string& error)
@@ -89,23 +100,27 @@ bool OpenGLComposite::UpdateLayerParameterByControlKeyJson(const std::string& la
 		return false;
 
 	return mRuntimeCoordinator &&
-		ApplyRuntimeCoordinatorResult(mRuntimeCoordinator->UpdateLayerParameterByControlKey(layerKey, parameterKey, parsedValue), &error);
+		mRuntimeUpdateController &&
+		mRuntimeUpdateController->ApplyRuntimeCoordinatorResult(mRuntimeCoordinator->UpdateLayerParameterByControlKey(layerKey, parameterKey, parsedValue), &error);
 }
 
 bool OpenGLComposite::ResetLayerParameters(const std::string& layerId, std::string& error)
 {
 	return mRuntimeCoordinator &&
-		ApplyRuntimeCoordinatorResult(mRuntimeCoordinator->ResetLayerParameters(layerId), &error);
+		mRuntimeUpdateController &&
+		mRuntimeUpdateController->ApplyRuntimeCoordinatorResult(mRuntimeCoordinator->ResetLayerParameters(layerId), &error);
 }
 
 bool OpenGLComposite::SaveStackPreset(const std::string& presetName, std::string& error)
 {
 	return mRuntimeCoordinator &&
-		ApplyRuntimeCoordinatorResult(mRuntimeCoordinator->SaveStackPreset(presetName), &error);
+		mRuntimeUpdateController &&
+		mRuntimeUpdateController->ApplyRuntimeCoordinatorResult(mRuntimeCoordinator->SaveStackPreset(presetName), &error);
 }
 
 bool OpenGLComposite::LoadStackPreset(const std::string& presetName, std::string& error)
 {
 	return mRuntimeCoordinator &&
-		ApplyRuntimeCoordinatorResult(mRuntimeCoordinator->LoadStackPreset(presetName), &error);
+		mRuntimeUpdateController &&
+		mRuntimeUpdateController->ApplyRuntimeCoordinatorResult(mRuntimeCoordinator->LoadStackPreset(presetName), &error);
 }

apps/LoopThroughWithOpenGLCompositing/gl/RenderEngine.cpp

@@ -379,7 +379,7 @@ bool RenderEngine::ResolveRenderLayerStates(
 
 		ApplyOscOverlays(renderSnapshot.states, true, oscSmoothing, commitRequests);
 		if (mCachedParameterStateVersion != versions.parameterStateVersion &&
-			mRuntimeSnapshotProvider.TryRefreshSnapshotParameters(renderSnapshot))
+			mRuntimeSnapshotProvider.TryRefreshPublishedSnapshotParameters(renderSnapshot))
 		{
 			mCachedParameterStateVersion = renderSnapshot.versions.parameterStateVersion;
 			ApplyOscOverlays(renderSnapshot.states, true, oscSmoothing, commitRequests);
@@ -392,7 +392,7 @@ bool RenderEngine::ResolveRenderLayerStates(
 	}
 
 	RuntimeRenderStateSnapshot renderSnapshot;
-	if (mRuntimeSnapshotProvider.TryGetRenderStateSnapshot(renderWidth, renderHeight, renderSnapshot))
+	if (mRuntimeSnapshotProvider.TryPublishRenderStateSnapshot(renderWidth, renderHeight, renderSnapshot))
 	{
 		mCachedLayerRenderStates = renderSnapshot.states;
 		mCachedRenderStateVersion = renderSnapshot.versions.renderStateVersion;

apps/LoopThroughWithOpenGLCompositing/gl/RuntimeUpdateController.cpp

@@ -0,0 +1,103 @@
+#include "RuntimeUpdateController.h"
+
+#include "RenderEngine.h"
+#include "RuntimeServices.h"
+#include "RuntimeStore.h"
+#include "ShaderBuildQueue.h"
+#include "VideoBackend.h"
+
+#include <vector>
+
+RuntimeUpdateController::RuntimeUpdateController(
+	RuntimeStore& runtimeStore,
+	RuntimeCoordinator& runtimeCoordinator,
+	RuntimeServices& runtimeServices,
+	RenderEngine& renderEngine,
+	ShaderBuildQueue& shaderBuildQueue,
+	VideoBackend& videoBackend) :
+	mRuntimeStore(runtimeStore),
+	mRuntimeCoordinator(runtimeCoordinator),
+	mRuntimeServices(runtimeServices),
+	mRenderEngine(renderEngine),
+	mShaderBuildQueue(shaderBuildQueue),
+	mVideoBackend(videoBackend)
+{
+}
+
+bool RuntimeUpdateController::ApplyRuntimeCoordinatorResult(const RuntimeCoordinatorResult& result, std::string* error)
+{
+	if (!result.accepted)
+	{
+		if (error)
+			*error = result.errorMessage;
+		return false;
+	}
+
+	if (result.compileStatusChanged)
+		mRuntimeStore.SetCompileStatus(result.compileStatusSucceeded, result.compileStatusMessage);
+
+	if (result.clearReloadRequest)
+		mRuntimeStore.ClearReloadRequest();
+
+	mRuntimeCoordinator.ApplyCommittedStateMode(result.committedStateMode);
+
+	if (result.clearTransientOscState)
+	{
+		mRenderEngine.ClearOscOverlayState();
+		mRuntimeServices.ClearOscState();
+	}
+
+	mRenderEngine.ApplyRuntimeCoordinatorRenderReset(result.renderResetScope);
+
+	if (result.shaderBuildRequested)
+		RequestShaderBuild();
+
+	if (result.runtimeStateBroadcastRequired)
+		BroadcastRuntimeState();
+
+	return true;
+}
+
+bool RuntimeUpdateController::ProcessRuntimeWork()
+{
+	bool shaderBuildRequested = false;
+	std::vector<RuntimeCoordinatorServiceResult> serviceResults;
+	mRuntimeServices.ConsumeRuntimeCoordinatorResults(serviceResults);
+	for (const RuntimeCoordinatorServiceResult& serviceResult : serviceResults)
+	{
+		shaderBuildRequested = shaderBuildRequested || serviceResult.result.shaderBuildRequested;
+		ApplyRuntimeCoordinatorResult(serviceResult.result);
+		if (serviceResult.failed)
+			return false;
+	}
+
+	if (shaderBuildRequested)
+		return true;
+
+	const RenderEngine::PreparedShaderBuildApplyResult buildResult = mRenderEngine.TryApplyReadyShaderBuild(
+		mShaderBuildQueue,
+		mVideoBackend.InputFrameWidth(),
+		mVideoBackend.InputFrameHeight(),
+		mRuntimeCoordinator.PreserveFeedbackOnNextShaderBuild());
+	if (!buildResult.hadReadyBuild)
+		return true;
+
+	if (!buildResult.applied)
+	{
+		ApplyRuntimeCoordinatorResult(mRuntimeCoordinator.HandlePreparedShaderBuildFailure(buildResult.errorMessage));
+		return false;
+	}
+
+	ApplyRuntimeCoordinatorResult(mRuntimeCoordinator.HandlePreparedShaderBuildSuccess());
+	return true;
+}
+
+void RuntimeUpdateController::RequestShaderBuild()
+{
+	mShaderBuildQueue.RequestBuild(mVideoBackend.InputFrameWidth(), mVideoBackend.InputFrameHeight());
+}
+
+void RuntimeUpdateController::BroadcastRuntimeState()
+{
+	mRuntimeServices.BroadcastState();
+}

apps/LoopThroughWithOpenGLCompositing/gl/RuntimeUpdateController.h

@@ -0,0 +1,36 @@
+#pragma once
+
+#include "RuntimeCoordinator.h"
+
+#include <string>
+
+class RenderEngine;
+class RuntimeServices;
+class RuntimeStore;
+class ShaderBuildQueue;
+class VideoBackend;
+
+class RuntimeUpdateController
+{
+public:
+	RuntimeUpdateController(
+		RuntimeStore& runtimeStore,
+		RuntimeCoordinator& runtimeCoordinator,
+		RuntimeServices& runtimeServices,
+		RenderEngine& renderEngine,
+		ShaderBuildQueue& shaderBuildQueue,
+		VideoBackend& videoBackend);
+
+	bool ApplyRuntimeCoordinatorResult(const RuntimeCoordinatorResult& result, std::string* error = nullptr);
+	bool ProcessRuntimeWork();
+	void RequestShaderBuild();
+	void BroadcastRuntimeState();
+
+private:
+	RuntimeStore& mRuntimeStore;
+	RuntimeCoordinator& mRuntimeCoordinator;
+	RuntimeServices& mRuntimeServices;
+	RenderEngine& mRenderEngine;
+	ShaderBuildQueue& mShaderBuildQueue;
+	VideoBackend& mVideoBackend;
+};

apps/LoopThroughWithOpenGLCompositing/gl/shader/OpenGLShaderPrograms.cpp

@@ -40,7 +40,7 @@ OpenGLShaderPrograms::OpenGLShaderPrograms(OpenGLRenderer& renderer, RuntimeSnap
 bool OpenGLShaderPrograms::CompileLayerPrograms(unsigned inputFrameWidth, unsigned inputFrameHeight, int errorMessageSize, char* errorMessage)
 {
 	const RuntimeRenderStateSnapshot renderSnapshot =
-		mRuntimeSnapshotProvider.GetRenderStateSnapshot(inputFrameWidth, inputFrameHeight);
+		mRuntimeSnapshotProvider.PublishRenderStateSnapshot(inputFrameWidth, inputFrameHeight);
 	const std::vector<RuntimeRenderState>& layerStates = renderSnapshot.states;
 	std::string temporalError;
 	const unsigned historyCap = mRuntimeSnapshotProvider.GetMaxTemporalHistoryFrames();

apps/LoopThroughWithOpenGLCompositing/gl/shader/ShaderBuildQueue.cpp

@@ -111,7 +111,7 @@ PreparedShaderBuild ShaderBuildQueue::Build(uint64_t generation, unsigned output
 {
 	PreparedShaderBuild build;
 	build.generation = generation;
-	build.renderSnapshot = mRuntimeSnapshotProvider.GetRenderStateSnapshot(outputWidth, outputHeight);
+	build.renderSnapshot = mRuntimeSnapshotProvider.PublishRenderStateSnapshot(outputWidth, outputHeight);
 	build.layers.reserve(build.renderSnapshot.states.size());
 
 	for (const RuntimeRenderState& state : build.renderSnapshot.states)