more seperation

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