pass 2

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();
+}