more seperation

apps/LoopThroughWithOpenGLCompositing/gl/OpenGLComposite.cpp

@@ -101,9 +101,10 @@ OpenGLComposite::OpenGLComposite(HWND hWnd, HDC hDC, HGLRC hRC) :
 	mRuntimeHost = std::make_unique<RuntimeHost>();
 	mRuntimeStore = std::make_unique<RuntimeStore>(*mRuntimeHost);
 	mRuntimeSnapshotProvider = std::make_unique<RuntimeSnapshotProvider>(*mRuntimeHost);
+	mRuntimeCoordinator = std::make_unique<RuntimeCoordinator>(*mRuntimeStore);
 	mRenderEngine = std::make_unique<RenderEngine>(
-		*mRuntimeHost,
 		*mRuntimeSnapshotProvider,
+		mRuntimeHost->GetHealthTelemetry(),
 		pMutex,
 		hGLDC,
 		hGLRC,
@@ -202,7 +203,11 @@ bool OpenGLComposite::InitVideoIO()
 	}
 	if (!mVideoBackend->HasInputDevice() && mRuntimeHost)
 	{
-		mRuntimeHost->SetSignalStatus(false, mVideoBackend->InputFrameWidth(), mVideoBackend->InputFrameHeight(), mVideoBackend->InputDisplayModeName());
+		mRuntimeHost->GetHealthTelemetry().ReportSignalStatus(
+			false,
+			mVideoBackend->InputFrameWidth(),
+			mVideoBackend->InputFrameHeight(),
+			mVideoBackend->InputDisplayModeName());
 	}
 
 	if (!mVideoBackend->ConfigureOutput(videoModes.output, mRuntimeStore && mRuntimeStore->IsExternalKeyingConfigured(), initFailureReason))
@@ -227,27 +232,15 @@ void OpenGLComposite::paintGL(bool force)
 	{
 		if (IsIconic(hGLWnd))
 			return;
-
-		const unsigned previewFps = mRuntimeStore ? mRuntimeStore->GetConfiguredPreviewFps() : 30u;
-		if (previewFps == 0)
-			return;
-
-		const auto now = std::chrono::steady_clock::now();
-		const auto minimumInterval = std::chrono::microseconds(1000000 / (previewFps == 0 ? 1u : previewFps));
-		if (mLastPreviewPresentTime != std::chrono::steady_clock::time_point() &&
-			now - mLastPreviewPresentTime < minimumInterval)
-		{
-			return;
-		}
 	}
 
-	if (!mRenderEngine->TryPresentToWindow(mVideoBackend->OutputFrameWidth(), mVideoBackend->OutputFrameHeight()))
+	const unsigned previewFps = mRuntimeStore ? mRuntimeStore->GetConfiguredPreviewFps() : 30u;
+	if (!mRenderEngine->TryPresentPreview(force, previewFps, mVideoBackend->OutputFrameWidth(), mVideoBackend->OutputFrameHeight()))
 	{
 		ValidateRect(hGLWnd, NULL);
 		return;
 	}
 
-	mLastPreviewPresentTime = std::chrono::steady_clock::now();
 	ValidateRect(hGLWnd, NULL);
 }
 
@@ -336,7 +329,7 @@ bool OpenGLComposite::InitOpenGLState()
 		MessageBoxA(NULL, compilerErrorMessage, "OpenGL shader failed to load or compile", MB_OK);
 		return false;
 	}
-	mCachedLayerRenderStates = mRenderEngine->CommittedLayerStates();
+	mRuntimeStore->SetCompileStatus(true, "Shader layers compiled successfully.");
 	mUseCommittedLayerStates = false;
 
 	mRenderEngine->ResetTemporalHistoryState();
@@ -367,15 +360,8 @@ bool OpenGLComposite::Stop()
 
 bool OpenGLComposite::ReloadShader(bool preserveFeedbackState)
 {
-	mPreserveFeedbackOnNextShaderBuild = preserveFeedbackState;
-	if (mRuntimeHost)
-	{
-		mRuntimeStore->SetCompileStatus(true, "Shader rebuild queued.");
-		mRuntimeStore->ClearReloadRequest();
-	}
-	RequestShaderBuild();
-	broadcastRuntimeState();
-	return true;
+	return mRuntimeCoordinator &&
+		ApplyRuntimeCoordinatorResult(mRuntimeCoordinator->RequestShaderReload(preserveFeedbackState));
 }
 
 bool OpenGLComposite::RequestScreenshot(std::string& error)
@@ -442,7 +428,7 @@ void OpenGLComposite::renderEffect()
 
 	const auto applyOscOverlays = [&](std::vector<RuntimeRenderState>& states, bool allowCommit)
 	{
-		if (states.empty() || mOscOverlayStates.empty() || !mRuntimeHost)
+		if (states.empty() || mOscOverlayStates.empty())
 			return;
 
 		const double smoothing = ClampOscAlpha(mRuntimeStore ? mRuntimeStore->GetConfiguredOscSmoothing() : 0.0);
@@ -576,66 +562,12 @@ void OpenGLComposite::renderEffect()
 
 	const bool hasInputSource = mVideoBackend->HasInputSource();
 	std::vector<RuntimeRenderState> layerStates;
-	if (mUseCommittedLayerStates)
-	{
-		layerStates = mRenderEngine->CommittedLayerStates();
-		applyOscOverlays(layerStates, false);
-		if (mRuntimeSnapshotProvider)
-			mRuntimeSnapshotProvider->RefreshDynamicRenderStateFields(layerStates);
-	}
-	else if (mRuntimeSnapshotProvider)
-	{
-		const unsigned renderWidth = mVideoBackend->InputFrameWidth();
-		const unsigned renderHeight = mVideoBackend->InputFrameHeight();
-		const RuntimeSnapshotVersions versions = mRuntimeSnapshotProvider->GetVersions();
-		const bool renderStateCacheValid =
-			!mCachedLayerRenderStates.empty() &&
-			mCachedRenderStateVersion == versions.renderStateVersion &&
-			mCachedRenderStateWidth == renderWidth &&
-			mCachedRenderStateHeight == renderHeight;
-
-		if (renderStateCacheValid)
-		{
-			RuntimeRenderStateSnapshot renderSnapshot;
-			renderSnapshot.outputWidth = renderWidth;
-			renderSnapshot.outputHeight = renderHeight;
-			renderSnapshot.versions.renderStateVersion = mCachedRenderStateVersion;
-			renderSnapshot.versions.parameterStateVersion = mCachedParameterStateVersion;
-			renderSnapshot.states = mCachedLayerRenderStates;
-
-			applyOscOverlays(renderSnapshot.states, true);
-			if (mCachedParameterStateVersion != versions.parameterStateVersion &&
-				mRuntimeSnapshotProvider->TryRefreshSnapshotParameters(renderSnapshot))
-			{
-				mCachedParameterStateVersion = renderSnapshot.versions.parameterStateVersion;
-				applyOscOverlays(renderSnapshot.states, true);
-			}
-
-			mCachedLayerRenderStates = renderSnapshot.states;
-			layerStates = renderSnapshot.states;
-			mRuntimeSnapshotProvider->RefreshDynamicRenderStateFields(layerStates);
-		}
-		else
-		{
-			RuntimeRenderStateSnapshot renderSnapshot;
-			if (mRuntimeSnapshotProvider->TryGetRenderStateSnapshot(renderWidth, renderHeight, renderSnapshot))
-			{
-				mCachedLayerRenderStates = renderSnapshot.states;
-				mCachedRenderStateVersion = renderSnapshot.versions.renderStateVersion;
-				mCachedParameterStateVersion = renderSnapshot.versions.parameterStateVersion;
-				mCachedRenderStateWidth = renderSnapshot.outputWidth;
-				mCachedRenderStateHeight = renderSnapshot.outputHeight;
-				applyOscOverlays(mCachedLayerRenderStates, true);
-				layerStates = mCachedLayerRenderStates;
-			}
-			else
-			{
-				applyOscOverlays(mCachedLayerRenderStates, true);
-				layerStates = mCachedLayerRenderStates;
-				mRuntimeSnapshotProvider->RefreshDynamicRenderStateFields(layerStates);
-			}
-		}
-	}
+	mRenderEngine->ResolveRenderLayerStates(
+		mUseCommittedLayerStates.load(),
+		mVideoBackend->InputFrameWidth(),
+		mVideoBackend->InputFrameHeight(),
+		applyOscOverlays,
+		layerStates);
 	const unsigned historyCap = mRuntimeStore ? mRuntimeStore->GetConfiguredMaxTemporalHistoryFrames() : 0;
 	mRenderEngine->RenderLayerStack(
 		hasInputSource,
@@ -657,20 +589,9 @@ void OpenGLComposite::ProcessScreenshotRequest()
 	if (width == 0 || height == 0)
 		return;
 
-	std::vector<unsigned char> bottomUpPixels;
-	if (!mRenderEngine->ReadOutputFrameRgba(width, height, bottomUpPixels))
+	std::vector<unsigned char> topDownPixels;
+	if (!mRenderEngine->CaptureOutputFrameRgbaTopDown(width, height, topDownPixels))
 		return;
-	std::vector<unsigned char> topDownPixels(bottomUpPixels.size());
-
-	const std::size_t rowBytes = static_cast<std::size_t>(width) * 4;
-	for (unsigned y = 0; y < height; ++y)
-	{
-		const unsigned sourceY = height - 1 - y;
-		std::copy(
-			bottomUpPixels.begin() + static_cast<std::ptrdiff_t>(sourceY * rowBytes),
-			bottomUpPixels.begin() + static_cast<std::ptrdiff_t>((sourceY + 1) * rowBytes),
-			topDownPixels.begin() + static_cast<std::ptrdiff_t>(y * rowBytes));
-	}
 
 	try
 	{
@@ -707,14 +628,13 @@ std::filesystem::path OpenGLComposite::BuildScreenshotPath() const
 
 bool OpenGLComposite::ProcessRuntimePollResults()
 {
-	if (!mRuntimeHost || !mRuntimeServices)
+	if (!mRuntimeServices)
 		return true;
 
 	const RuntimePollEvents events = mRuntimeServices->ConsumePollEvents();
 	if (events.failed)
 	{
-		mRuntimeStore->SetCompileStatus(false, events.error);
-		broadcastRuntimeState();
+		ApplyRuntimeCoordinatorResult(mRuntimeCoordinator->HandleRuntimePollFailure(events.error));
 		return false;
 	}
 
@@ -728,29 +648,23 @@ bool OpenGLComposite::ProcessRuntimePollResults()
 			return true;
 
 		char compilerErrorMessage[1024] = {};
-		if (!mRenderEngine->CommitPreparedLayerPrograms(readyBuild, mVideoBackend->InputFrameWidth(), mVideoBackend->InputFrameHeight(), sizeof(compilerErrorMessage), compilerErrorMessage))
+		if (!mRenderEngine->ApplyPreparedShaderBuild(
+			readyBuild,
+			mVideoBackend->InputFrameWidth(),
+			mVideoBackend->InputFrameHeight(),
+			mRuntimeCoordinator && mRuntimeCoordinator->PreserveFeedbackOnNextShaderBuild(),
+			sizeof(compilerErrorMessage),
+			compilerErrorMessage))
 		{
-			mRuntimeStore->SetCompileStatus(false, compilerErrorMessage);
-			mUseCommittedLayerStates = true;
-			mPreserveFeedbackOnNextShaderBuild = false;
-			broadcastRuntimeState();
+			ApplyRuntimeCoordinatorResult(mRuntimeCoordinator->HandlePreparedShaderBuildFailure(compilerErrorMessage));
 			return false;
 		}
 
-		mUseCommittedLayerStates = false;
-		mCachedLayerRenderStates = mRenderEngine->CommittedLayerStates();
-		mRenderEngine->ResetTemporalHistoryState();
-		if (!mPreserveFeedbackOnNextShaderBuild)
-			mRenderEngine->ResetShaderFeedbackState();
-		mPreserveFeedbackOnNextShaderBuild = false;
-		broadcastRuntimeState();
+		ApplyRuntimeCoordinatorResult(mRuntimeCoordinator->HandlePreparedShaderBuildSuccess());
 		return true;
 	}
 
-	mRuntimeStore->SetCompileStatus(true, "Shader rebuild queued.");
-	mPreserveFeedbackOnNextShaderBuild = false;
-	RequestShaderBuild();
-	broadcastRuntimeState();
+	ApplyRuntimeCoordinatorResult(mRuntimeCoordinator->HandleRuntimeReloadRequest());
 	return true;
 }
 
@@ -759,24 +673,81 @@ void OpenGLComposite::RequestShaderBuild()
 	if (!mShaderBuildQueue || !mVideoBackend)
 		return;
 
-	mUseCommittedLayerStates = true;
-	if (mRuntimeHost)
-		mRuntimeStore->ClearReloadRequest();
 	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();
+
+	switch (result.committedStateMode)
+	{
+	case RuntimeCoordinatorCommittedStateMode::UseCommittedStates:
+		mUseCommittedLayerStates = true;
+		break;
+	case RuntimeCoordinatorCommittedStateMode::UseLiveSnapshots:
+		mUseCommittedLayerStates = false;
+		break;
+	case RuntimeCoordinatorCommittedStateMode::Unchanged:
+	default:
+		break;
+	}
+
+	if (result.clearTransientOscState)
+	{
+		mOscOverlayStates.clear();
+		if (mRuntimeServices)
+			mRuntimeServices->ClearOscState();
+	}
+
+	ApplyRuntimeCoordinatorRenderReset(result.renderResetScope);
+
+	if (result.shaderBuildRequested)
+		RequestShaderBuild();
+
+	if (result.runtimeStateBroadcastRequired)
+		broadcastRuntimeState();
+
+	return true;
+}
+
+void OpenGLComposite::ApplyRuntimeCoordinatorRenderReset(RuntimeCoordinatorRenderResetScope resetScope)
+{
+	if (!mRenderEngine)
+		return;
+
+	switch (resetScope)
+	{
+	case RuntimeCoordinatorRenderResetScope::TemporalHistoryOnly:
+		mRenderEngine->ResetTemporalHistoryState();
+		break;
+	case RuntimeCoordinatorRenderResetScope::TemporalHistoryAndFeedback:
+		mRenderEngine->ResetTemporalHistoryState();
+		mRenderEngine->ResetShaderFeedbackState();
+		break;
+	case RuntimeCoordinatorRenderResetScope::None:
+	default:
+		break;
+	}
+}
+
 void OpenGLComposite::broadcastRuntimeState()
 {
 	if (mRuntimeServices)
 		mRuntimeServices->BroadcastState();
 }
 
-void OpenGLComposite::resetTemporalHistoryState()
-{
-	mRenderEngine->ResetTemporalHistoryState();
-	mRenderEngine->ResetShaderFeedbackState();
-}
-
 bool OpenGLComposite::CheckOpenGLExtensions()
 {
 	return true;

apps/LoopThroughWithOpenGLCompositing/gl/OpenGLComposite.h

@@ -12,6 +12,7 @@
 #include <comutil.h>
 
 #include "GLExtensions.h"
+#include "RuntimeCoordinator.h"
 #include "RuntimeHost.h"
 #include "RuntimeSnapshotProvider.h"
 #include "RuntimeStore.h"
@@ -91,30 +92,25 @@ private:
 
 	std::unique_ptr<RuntimeHost>				mRuntimeHost;
 	std::unique_ptr<RuntimeStore>			mRuntimeStore;
+	std::unique_ptr<RuntimeCoordinator>		mRuntimeCoordinator;
 	std::unique_ptr<RuntimeSnapshotProvider>	mRuntimeSnapshotProvider;
 	std::unique_ptr<RenderEngine>			mRenderEngine;
 	std::unique_ptr<ShaderBuildQueue>		mShaderBuildQueue;
 	std::unique_ptr<RuntimeServices>		mRuntimeServices;
 	std::unique_ptr<VideoBackend>			mVideoBackend;
-	std::vector<RuntimeRenderState>			mCachedLayerRenderStates;
-	uint64_t								mCachedRenderStateVersion = 0;
-	uint64_t								mCachedParameterStateVersion = 0;
-	unsigned								mCachedRenderStateWidth = 0;
-	unsigned								mCachedRenderStateHeight = 0;
 	std::map<std::string, OscOverlayState>	mOscOverlayStates;
 	std::atomic<bool>						mUseCommittedLayerStates;
 	std::atomic<bool>						mScreenshotRequested;
-	std::chrono::steady_clock::time_point	mLastPreviewPresentTime;
-	bool									mPreserveFeedbackOnNextShaderBuild = false;
 
 	bool InitOpenGLState();
 	void renderEffect();
 	bool ProcessRuntimePollResults();
 	void RequestShaderBuild();
+	bool ApplyRuntimeCoordinatorResult(const RuntimeCoordinatorResult& result, std::string* error = nullptr);
+	void ApplyRuntimeCoordinatorRenderReset(RuntimeCoordinatorRenderResetScope resetScope);
 	void ProcessScreenshotRequest();
 	std::filesystem::path BuildScreenshotPath() const;
 	void broadcastRuntimeState();
-	void resetTemporalHistoryState();
 };
 
 #endif		// __OPENGL_COMPOSITE_H__

apps/LoopThroughWithOpenGLCompositing/gl/OpenGLCompositeRuntimeControls.cpp

@@ -38,62 +38,38 @@ std::string OpenGLComposite::GetOscAddress() const
 
 bool OpenGLComposite::AddLayer(const std::string& shaderId, std::string& error)
 {
-	if (!mRuntimeStore->CreateStoredLayer(shaderId, error))
-		return false;
-
-	ReloadShader(true);
-	broadcastRuntimeState();
-	return true;
+	return mRuntimeCoordinator &&
+		ApplyRuntimeCoordinatorResult(mRuntimeCoordinator->AddLayer(shaderId), &error);
 }
 
 bool OpenGLComposite::RemoveLayer(const std::string& layerId, std::string& error)
 {
-	if (!mRuntimeStore->DeleteStoredLayer(layerId, error))
-		return false;
-
-	ReloadShader(true);
-	broadcastRuntimeState();
-	return true;
+	return mRuntimeCoordinator &&
+		ApplyRuntimeCoordinatorResult(mRuntimeCoordinator->RemoveLayer(layerId), &error);
 }
 
 bool OpenGLComposite::MoveLayer(const std::string& layerId, int direction, std::string& error)
 {
-	if (!mRuntimeStore->MoveStoredLayer(layerId, direction, error))
-		return false;
-
-	ReloadShader(true);
-	broadcastRuntimeState();
-	return true;
+	return mRuntimeCoordinator &&
+		ApplyRuntimeCoordinatorResult(mRuntimeCoordinator->MoveLayer(layerId, direction), &error);
 }
 
 bool OpenGLComposite::MoveLayerToIndex(const std::string& layerId, std::size_t targetIndex, std::string& error)
 {
-	if (!mRuntimeStore->MoveStoredLayerToIndex(layerId, targetIndex, error))
-		return false;
-
-	ReloadShader(true);
-	broadcastRuntimeState();
-	return true;
+	return mRuntimeCoordinator &&
+		ApplyRuntimeCoordinatorResult(mRuntimeCoordinator->MoveLayerToIndex(layerId, targetIndex), &error);
 }
 
 bool OpenGLComposite::SetLayerBypass(const std::string& layerId, bool bypassed, std::string& error)
 {
-	if (!mRuntimeStore->SetStoredLayerBypassState(layerId, bypassed, error))
-		return false;
-
-	ReloadShader();
-	broadcastRuntimeState();
-	return true;
+	return mRuntimeCoordinator &&
+		ApplyRuntimeCoordinatorResult(mRuntimeCoordinator->SetLayerBypass(layerId, bypassed), &error);
 }
 
 bool OpenGLComposite::SetLayerShader(const std::string& layerId, const std::string& shaderId, std::string& error)
 {
-	if (!mRuntimeStore->SetStoredLayerShaderSelection(layerId, shaderId, error))
-		return false;
-
-	ReloadShader();
-	broadcastRuntimeState();
-	return true;
+	return mRuntimeCoordinator &&
+		ApplyRuntimeCoordinatorResult(mRuntimeCoordinator->SetLayerShader(layerId, shaderId), &error);
 }
 
 bool OpenGLComposite::UpdateLayerParameterJson(const std::string& layerId, const std::string& parameterId, const std::string& valueJson, std::string& error)
@@ -102,11 +78,8 @@ bool OpenGLComposite::UpdateLayerParameterJson(const std::string& layerId, const
 	if (!ParseJson(valueJson, parsedValue, error))
 		return false;
 
-	if (!mRuntimeStore->SetStoredParameterValue(layerId, parameterId, parsedValue, error))
-		return false;
-
-	broadcastRuntimeState();
-	return true;
+	return mRuntimeCoordinator &&
+		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)
@@ -115,42 +88,24 @@ bool OpenGLComposite::UpdateLayerParameterByControlKeyJson(const std::string& la
 	if (!ParseJson(valueJson, parsedValue, error))
 		return false;
 
-	if (!mRuntimeStore->SetStoredParameterValueByControlKey(layerKey, parameterKey, parsedValue, error))
-		return false;
-
-	broadcastRuntimeState();
-	return true;
+	return mRuntimeCoordinator &&
+		ApplyRuntimeCoordinatorResult(mRuntimeCoordinator->UpdateLayerParameterByControlKey(layerKey, parameterKey, parsedValue), &error);
 }
 
 bool OpenGLComposite::ResetLayerParameters(const std::string& layerId, std::string& error)
 {
-	if (!mRuntimeStore->ResetStoredLayerParameterValues(layerId, error))
-		return false;
-
-	mOscOverlayStates.clear();
-	if (mRuntimeServices)
-		mRuntimeServices->ClearOscState();
-	resetTemporalHistoryState();
-
-	broadcastRuntimeState();
-	return true;
+	return mRuntimeCoordinator &&
+		ApplyRuntimeCoordinatorResult(mRuntimeCoordinator->ResetLayerParameters(layerId), &error);
 }
 
 bool OpenGLComposite::SaveStackPreset(const std::string& presetName, std::string& error)
 {
-	if (!mRuntimeStore->SaveStackPresetSnapshot(presetName, error))
-		return false;
-
-	broadcastRuntimeState();
-	return true;
+	return mRuntimeCoordinator &&
+		ApplyRuntimeCoordinatorResult(mRuntimeCoordinator->SaveStackPreset(presetName), &error);
 }
 
 bool OpenGLComposite::LoadStackPreset(const std::string& presetName, std::string& error)
 {
-	if (!mRuntimeStore->LoadStackPresetSnapshot(presetName, error))
-		return false;
-
-	ReloadShader();
-	broadcastRuntimeState();
-	return true;
+	return mRuntimeCoordinator &&
+		ApplyRuntimeCoordinatorResult(mRuntimeCoordinator->LoadStackPreset(presetName), &error);
 }

apps/LoopThroughWithOpenGLCompositing/gl/RenderEngine.cpp

@@ -2,9 +2,12 @@
 
 #include <gl/gl.h>
 
+#include <algorithm>
+#include <cstddef>
+
 RenderEngine::RenderEngine(
-	RuntimeHost& runtimeHost,
 	RuntimeSnapshotProvider& runtimeSnapshotProvider,
+	HealthTelemetry& healthTelemetry,
 	CRITICAL_SECTION& mutex,
 	HDC hdc,
 	HGLRC hglrc,
@@ -13,8 +16,9 @@ RenderEngine::RenderEngine(
 	PreviewPaintCallback previewPaint) :
 	mRenderer(),
 	mRenderPass(mRenderer),
-	mRenderPipeline(mRenderer, runtimeHost, std::move(renderEffect), std::move(screenshotReady), std::move(previewPaint)),
-	mShaderPrograms(mRenderer, runtimeHost, runtimeSnapshotProvider),
+	mRenderPipeline(mRenderer, runtimeSnapshotProvider, healthTelemetry, std::move(renderEffect), std::move(screenshotReady), std::move(previewPaint)),
+	mShaderPrograms(mRenderer, runtimeSnapshotProvider),
+	mRuntimeSnapshotProvider(runtimeSnapshotProvider),
 	mMutex(mutex),
 	mHdc(hdc),
 	mHglrc(hglrc)
@@ -65,6 +69,28 @@ bool RenderEngine::CommitPreparedLayerPrograms(const PreparedShaderBuild& prepar
 	return mShaderPrograms.CommitPreparedLayerPrograms(preparedBuild, inputFrameWidth, inputFrameHeight, errorMessageSize, errorMessage);
 }
 
+bool RenderEngine::ApplyPreparedShaderBuild(
+	const PreparedShaderBuild& preparedBuild,
+	unsigned inputFrameWidth,
+	unsigned inputFrameHeight,
+	bool preserveFeedbackState,
+	int errorMessageSize,
+	char* errorMessage)
+{
+	if (!CommitPreparedLayerPrograms(preparedBuild, inputFrameWidth, inputFrameHeight, errorMessageSize, errorMessage))
+		return false;
+
+	mCachedLayerRenderStates = mShaderPrograms.CommittedLayerStates();
+	mCachedRenderStateVersion = preparedBuild.renderSnapshot.versions.renderStateVersion;
+	mCachedParameterStateVersion = preparedBuild.renderSnapshot.versions.parameterStateVersion;
+	mCachedRenderStateWidth = preparedBuild.renderSnapshot.outputWidth;
+	mCachedRenderStateHeight = preparedBuild.renderSnapshot.outputHeight;
+	ResetTemporalHistoryState();
+	if (!preserveFeedbackState)
+		ResetShaderFeedbackState();
+	return true;
+}
+
 const std::vector<RuntimeRenderState>& RenderEngine::CommittedLayerStates() const
 {
 	return mShaderPrograms.CommittedLayerStates();
@@ -85,12 +111,27 @@ void RenderEngine::ResizeView(int width, int height)
 	mRenderer.ResizeView(width, height);
 }
 
-bool RenderEngine::TryPresentToWindow(unsigned outputFrameWidth, unsigned outputFrameHeight)
+bool RenderEngine::TryPresentPreview(bool force, unsigned previewFps, unsigned outputFrameWidth, unsigned outputFrameHeight)
 {
+	if (!force)
+	{
+		if (previewFps == 0)
+			return false;
+
+		const auto now = std::chrono::steady_clock::now();
+		const auto minimumInterval = std::chrono::microseconds(1000000 / (previewFps == 0 ? 1u : previewFps));
+		if (mLastPreviewPresentTime != std::chrono::steady_clock::time_point() &&
+			now - mLastPreviewPresentTime < minimumInterval)
+		{
+			return false;
+		}
+	}
+
 	if (!TryEnterCriticalSection(&mMutex))
 		return false;
 
 	mRenderer.PresentToWindow(mHdc, outputFrameWidth, outputFrameHeight);
+	mLastPreviewPresentTime = std::chrono::steady_clock::now();
 	LeaveCriticalSection(&mMutex);
 	return true;
 }
@@ -133,6 +174,76 @@ bool RenderEngine::RenderOutputFrame(const RenderPipelineFrameContext& context,
 	return rendered;
 }
 
+bool RenderEngine::ResolveRenderLayerStates(
+	bool useCommittedLayerStates,
+	unsigned renderWidth,
+	unsigned renderHeight,
+	OverlayApplier overlayApplier,
+	std::vector<RuntimeRenderState>& layerStates)
+{
+	layerStates.clear();
+	if (useCommittedLayerStates)
+	{
+		layerStates = mShaderPrograms.CommittedLayerStates();
+		if (overlayApplier)
+			overlayApplier(layerStates, false);
+		mRuntimeSnapshotProvider.RefreshDynamicRenderStateFields(layerStates);
+		return true;
+	}
+
+	const RuntimeSnapshotVersions versions = mRuntimeSnapshotProvider.GetVersions();
+	const bool renderStateCacheValid =
+		!mCachedLayerRenderStates.empty() &&
+		mCachedRenderStateVersion == versions.renderStateVersion &&
+		mCachedRenderStateWidth == renderWidth &&
+		mCachedRenderStateHeight == renderHeight;
+
+	if (renderStateCacheValid)
+	{
+		RuntimeRenderStateSnapshot renderSnapshot;
+		renderSnapshot.outputWidth = renderWidth;
+		renderSnapshot.outputHeight = renderHeight;
+		renderSnapshot.versions.renderStateVersion = mCachedRenderStateVersion;
+		renderSnapshot.versions.parameterStateVersion = mCachedParameterStateVersion;
+		renderSnapshot.states = mCachedLayerRenderStates;
+
+		if (overlayApplier)
+			overlayApplier(renderSnapshot.states, true);
+		if (mCachedParameterStateVersion != versions.parameterStateVersion &&
+			mRuntimeSnapshotProvider.TryRefreshSnapshotParameters(renderSnapshot))
+		{
+			mCachedParameterStateVersion = renderSnapshot.versions.parameterStateVersion;
+			if (overlayApplier)
+				overlayApplier(renderSnapshot.states, true);
+		}
+
+		mCachedLayerRenderStates = renderSnapshot.states;
+		layerStates = renderSnapshot.states;
+		mRuntimeSnapshotProvider.RefreshDynamicRenderStateFields(layerStates);
+		return true;
+	}
+
+	RuntimeRenderStateSnapshot renderSnapshot;
+	if (mRuntimeSnapshotProvider.TryGetRenderStateSnapshot(renderWidth, renderHeight, renderSnapshot))
+	{
+		mCachedLayerRenderStates = renderSnapshot.states;
+		mCachedRenderStateVersion = renderSnapshot.versions.renderStateVersion;
+		mCachedParameterStateVersion = renderSnapshot.versions.parameterStateVersion;
+		mCachedRenderStateWidth = renderSnapshot.outputWidth;
+		mCachedRenderStateHeight = renderSnapshot.outputHeight;
+		if (overlayApplier)
+			overlayApplier(mCachedLayerRenderStates, true);
+		layerStates = mCachedLayerRenderStates;
+		return true;
+	}
+
+	if (overlayApplier)
+		overlayApplier(mCachedLayerRenderStates, true);
+	layerStates = mCachedLayerRenderStates;
+	mRuntimeSnapshotProvider.RefreshDynamicRenderStateFields(layerStates);
+	return !layerStates.empty();
+}
+
 void RenderEngine::RenderLayerStack(
 	bool hasInputSource,
 	const std::vector<RuntimeRenderState>& layerStates,
@@ -178,3 +289,23 @@ bool RenderEngine::ReadOutputFrameRgba(unsigned width, unsigned height, std::vec
 	LeaveCriticalSection(&mMutex);
 	return true;
 }
+
+bool RenderEngine::CaptureOutputFrameRgbaTopDown(unsigned width, unsigned height, std::vector<unsigned char>& topDownPixels)
+{
+	std::vector<unsigned char> bottomUpPixels;
+	if (!ReadOutputFrameRgba(width, height, bottomUpPixels))
+		return false;
+
+	topDownPixels.resize(bottomUpPixels.size());
+	const std::size_t rowBytes = static_cast<std::size_t>(width) * 4;
+	for (unsigned y = 0; y < height; ++y)
+	{
+		const unsigned sourceY = height - 1 - y;
+		std::copy(
+			bottomUpPixels.begin() + static_cast<std::ptrdiff_t>(sourceY * rowBytes),
+			bottomUpPixels.begin() + static_cast<std::ptrdiff_t>((sourceY + 1) * rowBytes),
+			topDownPixels.begin() + static_cast<std::ptrdiff_t>(y * rowBytes));
+	}
+
+	return true;
+}

apps/LoopThroughWithOpenGLCompositing/gl/RenderEngine.h

@@ -4,11 +4,13 @@
 #include "OpenGLRenderPipeline.h"
 #include "OpenGLRenderer.h"
 #include "OpenGLShaderPrograms.h"
-#include "RuntimeHost.h"
+#include "HealthTelemetry.h"
 #include "RuntimeSnapshotProvider.h"
 
 #include <windows.h>
 
+#include <cstdint>
+#include <chrono>
 #include <functional>
 #include <string>
 #include <vector>
@@ -19,10 +21,11 @@ public:
 	using RenderEffectCallback = std::function<void()>;
 	using ScreenshotCallback = std::function<void()>;
 	using PreviewPaintCallback = std::function<void()>;
+	using OverlayApplier = std::function<void(std::vector<RuntimeRenderState>& states, bool allowCommit)>;
 
 	RenderEngine(
-		RuntimeHost& runtimeHost,
 		RuntimeSnapshotProvider& runtimeSnapshotProvider,
+		HealthTelemetry& healthTelemetry,
 		CRITICAL_SECTION& mutex,
 		HDC hdc,
 		HGLRC hglrc,
@@ -43,14 +46,27 @@ public:
 		std::string& error);
 	bool CompileLayerPrograms(unsigned inputFrameWidth, unsigned inputFrameHeight, int errorMessageSize, char* errorMessage);
 	bool CommitPreparedLayerPrograms(const PreparedShaderBuild& preparedBuild, unsigned inputFrameWidth, unsigned inputFrameHeight, int errorMessageSize, char* errorMessage);
+	bool ApplyPreparedShaderBuild(
+		const PreparedShaderBuild& preparedBuild,
+		unsigned inputFrameWidth,
+		unsigned inputFrameHeight,
+		bool preserveFeedbackState,
+		int errorMessageSize,
+		char* errorMessage);
 
 	const std::vector<RuntimeRenderState>& CommittedLayerStates() const;
 	void ResetTemporalHistoryState();
 	void ResetShaderFeedbackState();
 	void ResizeView(int width, int height);
-	bool TryPresentToWindow(unsigned outputFrameWidth, unsigned outputFrameHeight);
+	bool TryPresentPreview(bool force, unsigned previewFps, unsigned outputFrameWidth, unsigned outputFrameHeight);
 	bool TryUploadInputFrame(const VideoIOFrame& inputFrame, const VideoIOState& videoState);
 	bool RenderOutputFrame(const RenderPipelineFrameContext& context, VideoIOOutputFrame& outputFrame);
+	bool ResolveRenderLayerStates(
+		bool useCommittedLayerStates,
+		unsigned renderWidth,
+		unsigned renderHeight,
+		OverlayApplier overlayApplier,
+		std::vector<RuntimeRenderState>& layerStates);
 	void RenderLayerStack(
 		bool hasInputSource,
 		const std::vector<RuntimeRenderState>& layerStates,
@@ -60,13 +76,21 @@ public:
 		VideoIOPixelFormat inputPixelFormat,
 		unsigned historyCap);
 	bool ReadOutputFrameRgba(unsigned width, unsigned height, std::vector<unsigned char>& bottomUpPixels);
+	bool CaptureOutputFrameRgbaTopDown(unsigned width, unsigned height, std::vector<unsigned char>& topDownPixels);
 
 private:
 	OpenGLRenderer mRenderer;
 	OpenGLRenderPass mRenderPass;
 	OpenGLRenderPipeline mRenderPipeline;
 	OpenGLShaderPrograms mShaderPrograms;
+	RuntimeSnapshotProvider& mRuntimeSnapshotProvider;
 	CRITICAL_SECTION& mMutex;
 	HDC mHdc;
 	HGLRC mHglrc;
+	std::vector<RuntimeRenderState> mCachedLayerRenderStates;
+	uint64_t mCachedRenderStateVersion = 0;
+	uint64_t mCachedParameterStateVersion = 0;
+	unsigned mCachedRenderStateWidth = 0;
+	unsigned mCachedRenderStateHeight = 0;
+	std::chrono::steady_clock::time_point mLastPreviewPresentTime;
 };

apps/LoopThroughWithOpenGLCompositing/gl/pipeline/OpenGLRenderPipeline.cpp

@@ -1,7 +1,8 @@
 #include "OpenGLRenderPipeline.h"
 
+#include "HealthTelemetry.h"
 #include "OpenGLRenderer.h"
-#include "RuntimeHost.h"
+#include "RuntimeSnapshotProvider.h"
 #include "VideoIOFormat.h"
 
 #include <cstring>
@@ -11,12 +12,14 @@
 
 OpenGLRenderPipeline::OpenGLRenderPipeline(
 	OpenGLRenderer& renderer,
-	RuntimeHost& runtimeHost,
+	RuntimeSnapshotProvider& runtimeSnapshotProvider,
+	HealthTelemetry& healthTelemetry,
 	RenderEffectCallback renderEffect,
 	OutputReadyCallback outputReady,
 	PaintCallback paint) :
 	mRenderer(renderer),
-	mRuntimeHost(runtimeHost),
+	mRuntimeSnapshotProvider(runtimeSnapshotProvider),
+	mHealthTelemetry(healthTelemetry),
 	mRenderEffect(renderEffect),
 	mOutputReady(outputReady),
 	mPaint(paint)
@@ -47,8 +50,8 @@ bool OpenGLRenderPipeline::RenderFrame(const RenderPipelineFrameContext& context
 
 	const auto renderEndTime = std::chrono::steady_clock::now();
 	const double renderMilliseconds = std::chrono::duration_cast<std::chrono::duration<double, std::milli>>(renderEndTime - renderStartTime).count();
-	mRuntimeHost.GetHealthTelemetry().TryRecordPerformanceStats(state.frameBudgetMilliseconds, renderMilliseconds);
-	mRuntimeHost.TryAdvanceFrame();
+	mHealthTelemetry.TryRecordPerformanceStats(state.frameBudgetMilliseconds, renderMilliseconds);
+	mRuntimeSnapshotProvider.TryAdvanceFrame();
 
 	ReadOutputFrame(state, outputFrame);
 	if (mPaint)

apps/LoopThroughWithOpenGLCompositing/gl/pipeline/OpenGLRenderPipeline.h

@@ -8,7 +8,8 @@
 #include <vector>
 
 class OpenGLRenderer;
-class RuntimeHost;
+class HealthTelemetry;
+class RuntimeSnapshotProvider;
 
 struct RenderPipelineFrameContext
 {
@@ -25,7 +26,8 @@ public:
 
 	OpenGLRenderPipeline(
 		OpenGLRenderer& renderer,
-		RuntimeHost& runtimeHost,
+		RuntimeSnapshotProvider& runtimeSnapshotProvider,
+		HealthTelemetry& healthTelemetry,
 		RenderEffectCallback renderEffect,
 		OutputReadyCallback outputReady,
 		PaintCallback paint);
@@ -53,7 +55,8 @@ private:
 	void ReadOutputFrame(const VideoIOState& state, VideoIOOutputFrame& outputFrame);
 
 	OpenGLRenderer& mRenderer;
-	RuntimeHost& mRuntimeHost;
+	RuntimeSnapshotProvider& mRuntimeSnapshotProvider;
+	HealthTelemetry& mHealthTelemetry;
 	RenderEffectCallback mRenderEffect;
 	OutputReadyCallback mOutputReady;
 	PaintCallback mPaint;

apps/LoopThroughWithOpenGLCompositing/gl/pipeline/OpenGLVideoIOBridge.cpp

@@ -1,81 +1,25 @@
 #include "OpenGLVideoIOBridge.h"
 
-#include "HealthTelemetry.h"
 #include "RenderEngine.h"
 
-#include <chrono>
-
-OpenGLVideoIOBridge::OpenGLVideoIOBridge(
-	VideoIODevice& videoIO,
-	RenderEngine& renderEngine,
-	HealthTelemetry& healthTelemetry) :
-	mVideoIO(videoIO),
-	mRenderEngine(renderEngine),
-	mHealthTelemetry(healthTelemetry)
+OpenGLVideoIOBridge::OpenGLVideoIOBridge(RenderEngine& renderEngine) :
+	mRenderEngine(renderEngine)
 {
 }
 
-void OpenGLVideoIOBridge::RecordFramePacing(VideoIOCompletionResult completionResult)
+void OpenGLVideoIOBridge::UploadInputFrame(const VideoIOFrame& inputFrame, const VideoIOState& state)
 {
-	const auto now = std::chrono::steady_clock::now();
-	if (mLastPlayoutCompletionTime != std::chrono::steady_clock::time_point())
-	{
-		mCompletionIntervalMilliseconds = std::chrono::duration_cast<std::chrono::duration<double, std::milli>>(now - mLastPlayoutCompletionTime).count();
-		if (mSmoothedCompletionIntervalMilliseconds <= 0.0)
-			mSmoothedCompletionIntervalMilliseconds = mCompletionIntervalMilliseconds;
-		else
-			mSmoothedCompletionIntervalMilliseconds = mSmoothedCompletionIntervalMilliseconds * 0.9 + mCompletionIntervalMilliseconds * 0.1;
-		if (mCompletionIntervalMilliseconds > mMaxCompletionIntervalMilliseconds)
-			mMaxCompletionIntervalMilliseconds = mCompletionIntervalMilliseconds;
-	}
-	mLastPlayoutCompletionTime = now;
-
-	if (completionResult == VideoIOCompletionResult::DisplayedLate)
-		++mLateFrameCount;
-	else if (completionResult == VideoIOCompletionResult::Dropped)
-		++mDroppedFrameCount;
-	else if (completionResult == VideoIOCompletionResult::Flushed)
-		++mFlushedFrameCount;
-
-	mHealthTelemetry.TryRecordFramePacingStats(
-		mCompletionIntervalMilliseconds,
-		mSmoothedCompletionIntervalMilliseconds,
-		mMaxCompletionIntervalMilliseconds,
-		mLateFrameCount,
-		mDroppedFrameCount,
-		mFlushedFrameCount);
-}
-
-void OpenGLVideoIOBridge::VideoFrameArrived(const VideoIOFrame& inputFrame)
-{
-	const VideoIOState& state = mVideoIO.State();
-	mHealthTelemetry.TryReportSignalStatus(!inputFrame.hasNoInputSource, state.inputFrameSize.width, state.inputFrameSize.height, state.inputDisplayModeName);
-
 	if (inputFrame.hasNoInputSource || inputFrame.bytes == nullptr)
 		return;							// don't transfer texture when there's no input
 
 	mRenderEngine.TryUploadInputFrame(inputFrame, state);
 }
 
-void OpenGLVideoIOBridge::PlayoutFrameCompleted(const VideoIOCompletion& completion)
+void OpenGLVideoIOBridge::RenderScheduledFrame(const VideoIOState& state, const VideoIOCompletion& completion, VideoIOOutputFrame& outputFrame)
 {
-	RecordFramePacing(completion.result);
-
-	VideoIOOutputFrame outputFrame;
-	if (!mVideoIO.BeginOutputFrame(outputFrame))
-		return;
-	const VideoIOState& state = mVideoIO.State();
 	RenderPipelineFrameContext frameContext;
 	frameContext.videoState = state;
 	frameContext.completion = completion;
 
 	mRenderEngine.RenderOutputFrame(frameContext, outputFrame);
-
-	mVideoIO.EndOutputFrame(outputFrame);
-
-	mVideoIO.AccountForCompletionResult(completion.result);
-
-	// Schedule the next frame for playout after the GL bridge is released so
-	// input uploads are not blocked by non-GL output bookkeeping.
-	mVideoIO.ScheduleOutputFrame(outputFrame);
 }

apps/LoopThroughWithOpenGLCompositing/gl/pipeline/OpenGLVideoIOBridge.h

@@ -2,34 +2,16 @@
 
 #include "OpenGLRenderPipeline.h"
 
-#include <chrono>
-#include <cstdint>
-
-class HealthTelemetry;
 class RenderEngine;
 
 class OpenGLVideoIOBridge
 {
 public:
-	OpenGLVideoIOBridge(
-		VideoIODevice& videoIO,
-		RenderEngine& renderEngine,
-		HealthTelemetry& healthTelemetry);
+	explicit OpenGLVideoIOBridge(RenderEngine& renderEngine);
 
-	void VideoFrameArrived(const VideoIOFrame& inputFrame);
-	void PlayoutFrameCompleted(const VideoIOCompletion& completion);
+	void UploadInputFrame(const VideoIOFrame& inputFrame, const VideoIOState& state);
+	void RenderScheduledFrame(const VideoIOState& state, const VideoIOCompletion& completion, VideoIOOutputFrame& outputFrame);
 
 private:
-	void RecordFramePacing(VideoIOCompletionResult completionResult);
-
-	VideoIODevice& mVideoIO;
 	RenderEngine& mRenderEngine;
-	HealthTelemetry& mHealthTelemetry;
-	std::chrono::steady_clock::time_point mLastPlayoutCompletionTime;
-	double mCompletionIntervalMilliseconds = 0.0;
-	double mSmoothedCompletionIntervalMilliseconds = 0.0;
-	double mMaxCompletionIntervalMilliseconds = 0.0;
-	uint64_t mLateFrameCount = 0;
-	uint64_t mDroppedFrameCount = 0;
-	uint64_t mFlushedFrameCount = 0;
 };

apps/LoopThroughWithOpenGLCompositing/gl/shader/OpenGLShaderPrograms.cpp

@@ -29,12 +29,11 @@ std::size_t RequiredTemporaryRenderTargets(const std::vector<OpenGLRenderer::Lay
 }
 }
 
-OpenGLShaderPrograms::OpenGLShaderPrograms(OpenGLRenderer& renderer, RuntimeHost& runtimeHost, RuntimeSnapshotProvider& runtimeSnapshotProvider) :
+OpenGLShaderPrograms::OpenGLShaderPrograms(OpenGLRenderer& renderer, RuntimeSnapshotProvider& runtimeSnapshotProvider) :
 	mRenderer(renderer),
-	mRuntimeHost(runtimeHost),
 	mRuntimeSnapshotProvider(runtimeSnapshotProvider),
 	mGlobalParamsBuffer(renderer),
-	mCompiler(renderer, runtimeHost, mTextureBindings)
+	mCompiler(renderer, runtimeSnapshotProvider, mTextureBindings)
 {
 }
 
@@ -44,7 +43,7 @@ bool OpenGLShaderPrograms::CompileLayerPrograms(unsigned inputFrameWidth, unsign
 		mRuntimeSnapshotProvider.GetRenderStateSnapshot(inputFrameWidth, inputFrameHeight);
 	const std::vector<RuntimeRenderState>& layerStates = renderSnapshot.states;
 	std::string temporalError;
-	const unsigned historyCap = mRuntimeHost.GetMaxTemporalHistoryFrames();
+	const unsigned historyCap = mRuntimeSnapshotProvider.GetMaxTemporalHistoryFrames();
 	if (!mRenderer.TemporalHistory().ValidateTextureUnitBudget(layerStates, historyCap, temporalError))
 	{
 		CopyErrorMessage(temporalError, errorMessageSize, errorMessage);
@@ -92,9 +91,6 @@ bool OpenGLShaderPrograms::CompileLayerPrograms(unsigned inputFrameWidth, unsign
 	mRenderer.ReplaceLayerPrograms(newPrograms);
 	mCommittedLayerStates = renderSnapshot.states;
 
-	mRuntimeHost.SetCompileStatus(true, "Shader layers compiled successfully.");
-	mRuntimeHost.ClearReloadRequest();
-
 	return true;
 }
 
@@ -107,7 +103,7 @@ bool OpenGLShaderPrograms::CommitPreparedLayerPrograms(const PreparedShaderBuild
 	}
 
 	std::string temporalError;
-	const unsigned historyCap = mRuntimeHost.GetMaxTemporalHistoryFrames();
+	const unsigned historyCap = mRuntimeSnapshotProvider.GetMaxTemporalHistoryFrames();
 	if (!mRenderer.TemporalHistory().ValidateTextureUnitBudget(preparedBuild.renderSnapshot.states, historyCap, temporalError))
 	{
 		CopyErrorMessage(temporalError, errorMessageSize, errorMessage);
@@ -155,9 +151,6 @@ bool OpenGLShaderPrograms::CommitPreparedLayerPrograms(const PreparedShaderBuild
 	mRenderer.ReplaceLayerPrograms(newPrograms);
 	mCommittedLayerStates = preparedBuild.renderSnapshot.states;
 
-	mRuntimeHost.SetCompileStatus(true, "Shader layers compiled successfully.");
-	mRuntimeHost.ClearReloadRequest();
-
 	return true;
 }
 

apps/LoopThroughWithOpenGLCompositing/gl/shader/OpenGLShaderPrograms.h

@@ -2,7 +2,6 @@
 
 #include "GlobalParamsBuffer.h"
 #include "OpenGLRenderer.h"
-#include "RuntimeHost.h"
 #include "RuntimeSnapshotProvider.h"
 #include "ShaderBuildQueue.h"
 #include "ShaderTypes.h"
@@ -16,7 +15,7 @@ class OpenGLShaderPrograms
 public:
 	using LayerProgram = OpenGLRenderer::LayerProgram;
 
-	OpenGLShaderPrograms(OpenGLRenderer& renderer, RuntimeHost& runtimeHost, RuntimeSnapshotProvider& runtimeSnapshotProvider);
+	OpenGLShaderPrograms(OpenGLRenderer& renderer, RuntimeSnapshotProvider& runtimeSnapshotProvider);
 
 	bool CompileLayerPrograms(unsigned inputFrameWidth, unsigned inputFrameHeight, int errorMessageSize, char* errorMessage);
 	bool CommitPreparedLayerPrograms(const PreparedShaderBuild& preparedBuild, unsigned inputFrameWidth, unsigned inputFrameHeight, int errorMessageSize, char* errorMessage);
@@ -33,7 +32,6 @@ public:
 
 private:
 	OpenGLRenderer& mRenderer;
-	RuntimeHost& mRuntimeHost;
 	RuntimeSnapshotProvider& mRuntimeSnapshotProvider;
 	ShaderTextureBindings mTextureBindings;
 	GlobalParamsBuffer mGlobalParamsBuffer;

apps/LoopThroughWithOpenGLCompositing/gl/shader/ShaderProgramCompiler.cpp

@@ -19,9 +19,9 @@ void CopyErrorMessage(const std::string& message, int errorMessageSize, char* er
 }
 }
 
-ShaderProgramCompiler::ShaderProgramCompiler(OpenGLRenderer& renderer, RuntimeHost& runtimeHost, ShaderTextureBindings& textureBindings) :
+ShaderProgramCompiler::ShaderProgramCompiler(OpenGLRenderer& renderer, RuntimeSnapshotProvider& runtimeSnapshotProvider, ShaderTextureBindings& textureBindings) :
 	mRenderer(renderer),
-	mRuntimeHost(runtimeHost),
+	mRuntimeSnapshotProvider(runtimeSnapshotProvider),
 	mTextureBindings(textureBindings)
 {
 }
@@ -31,7 +31,7 @@ bool ShaderProgramCompiler::CompileLayerProgram(const RuntimeRenderState& state,
 	std::vector<ShaderPassBuildSource> passSources;
 	std::string loadError;
 
-	if (!mRuntimeHost.BuildLayerPassFragmentShaderSources(state.layerId, passSources, loadError))
+	if (!mRuntimeSnapshotProvider.BuildLayerPassFragmentShaderSources(state.layerId, passSources, loadError))
 	{
 		CopyErrorMessage(loadError, errorMessageSize, errorMessage);
 		return false;
@@ -117,7 +117,7 @@ bool ShaderProgramCompiler::CompilePreparedLayerProgram(const RuntimeRenderState
 		passProgram.passId = passSource.passId;
 		passProgram.inputNames = passSource.inputNames;
 		passProgram.outputName = passSource.outputName;
-		passProgram.shaderTextureBase = mTextureBindings.ResolveShaderTextureBase(state, mRuntimeHost.GetMaxTemporalHistoryFrames());
+		passProgram.shaderTextureBase = mTextureBindings.ResolveShaderTextureBase(state, mRuntimeSnapshotProvider.GetMaxTemporalHistoryFrames());
 		passProgram.textureBindings.swap(textureBindings);
 		passProgram.textBindings.swap(textBindings);
 
@@ -125,7 +125,7 @@ bool ShaderProgramCompiler::CompilePreparedLayerProgram(const RuntimeRenderState
 		if (globalParamsIndex != GL_INVALID_INDEX)
 			glUniformBlockBinding(newProgram.get(), globalParamsIndex, kGlobalParamsBindingPoint);
 
-		const unsigned historyCap = mRuntimeHost.GetMaxTemporalHistoryFrames();
+		const unsigned historyCap = mRuntimeSnapshotProvider.GetMaxTemporalHistoryFrames();
 		glUseProgram(newProgram.get());
 		mTextureBindings.AssignLayerSamplerUniforms(newProgram.get(), state, passProgram, historyCap);
 		glUseProgram(0);

apps/LoopThroughWithOpenGLCompositing/gl/shader/ShaderProgramCompiler.h

@@ -1,7 +1,7 @@
 #pragma once
 
 #include "OpenGLRenderer.h"
-#include "RuntimeHost.h"
+#include "RuntimeSnapshotProvider.h"
 #include "ShaderTextureBindings.h"
 
 #include <string>
@@ -13,7 +13,7 @@ public:
 	using LayerProgram = OpenGLRenderer::LayerProgram;
 	using PassProgram = OpenGLRenderer::LayerProgram::PassProgram;
 
-	ShaderProgramCompiler(OpenGLRenderer& renderer, RuntimeHost& runtimeHost, ShaderTextureBindings& textureBindings);
+	ShaderProgramCompiler(OpenGLRenderer& renderer, RuntimeSnapshotProvider& runtimeSnapshotProvider, ShaderTextureBindings& textureBindings);
 
 	bool CompileLayerProgram(const RuntimeRenderState& state, LayerProgram& layerProgram, int errorMessageSize, char* errorMessage);
 	bool CompilePreparedLayerProgram(const RuntimeRenderState& state, const std::vector<ShaderPassBuildSource>& passSources, LayerProgram& layerProgram, int errorMessageSize, char* errorMessage);
@@ -22,6 +22,6 @@ public:
 
 private:
 	OpenGLRenderer& mRenderer;
-	RuntimeHost& mRuntimeHost;
+	RuntimeSnapshotProvider& mRuntimeSnapshotProvider;
 	ShaderTextureBindings& mTextureBindings;
 };