render engine updates

apps/LoopThroughWithOpenGLCompositing/gl/RenderEngine.cpp

@@ -6,11 +6,6 @@
 
 #include <algorithm>
 
-namespace
-{
-constexpr auto kOscOverlayCommitDelay = std::chrono::milliseconds(150);
-}
-
 RenderEngine::RenderEngine(
 	RuntimeSnapshotProvider& runtimeSnapshotProvider,
 	HealthTelemetry& healthTelemetry,
@@ -24,10 +19,10 @@ RenderEngine::RenderEngine(
 	mRenderPass(mRenderer),
 	mRenderPipeline(mRenderer, runtimeSnapshotProvider, healthTelemetry, std::move(renderEffect), std::move(screenshotReady), std::move(previewPaint)),
 	mShaderPrograms(mRenderer, runtimeSnapshotProvider),
-	mRuntimeSnapshotProvider(runtimeSnapshotProvider),
 	mMutex(mutex),
 	mHdc(hdc),
-	mHglrc(hglrc)
+	mHglrc(hglrc),
+	mFrameStateResolver(runtimeSnapshotProvider)
 {
 }
 
@@ -86,11 +81,7 @@ bool RenderEngine::ApplyPreparedShaderBuild(
 	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;
+	mFrameStateResolver.StoreCommittedSnapshot(preparedBuild.renderSnapshot, mShaderPrograms.CommittedLayerStates());
 	ResetTemporalHistoryState();
 	if (!preserveFeedbackState)
 		ResetShaderFeedbackState();
@@ -248,92 +239,37 @@ bool RenderEngine::RenderOutputFrame(const RenderPipelineFrameContext& context,
 	return rendered;
 }
 
-bool RenderEngine::ResolveRenderLayerStates(
-	bool useCommittedLayerStates,
-	unsigned renderWidth,
-	unsigned renderHeight,
-	double oscSmoothing,
+bool RenderEngine::ResolveRenderFrameState(
+	const RenderFrameInput& input,
 	std::vector<OscOverlayCommitRequest>* commitRequests,
-	std::vector<RuntimeRenderState>& layerStates)
+	RenderFrameState& frameState)
 {
-	layerStates.clear();
-	if (useCommittedLayerStates)
+	std::vector<RuntimeLiveOscCommitRequest> liveCommitRequests;
+	const bool resolved = mFrameStateResolver.Resolve(
+		input,
+		mShaderPrograms.CommittedLayerStates(),
+		mRuntimeLiveState,
+		commitRequests ? &liveCommitRequests : nullptr,
+		frameState);
+
+	if (commitRequests)
 	{
-		layerStates = ComposeRenderLayerStates(mShaderPrograms.CommittedLayerStates(), false, oscSmoothing, commitRequests);
-		mRuntimeSnapshotProvider.RefreshDynamicRenderStateFields(layerStates);
-		return true;
+		for (const RuntimeLiveOscCommitRequest& request : liveCommitRequests)
+			commitRequests->push_back({ request.routeKey, request.layerKey, request.parameterKey, request.value, request.generation });
 	}
-
-	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;
-
-		renderSnapshot.states = ComposeRenderLayerStates(renderSnapshot.states, true, oscSmoothing, commitRequests);
-		if (mCachedParameterStateVersion != versions.parameterStateVersion &&
-			mRuntimeSnapshotProvider.TryRefreshPublishedSnapshotParameters(renderSnapshot))
-		{
-			mCachedParameterStateVersion = renderSnapshot.versions.parameterStateVersion;
-			renderSnapshot.states = ComposeRenderLayerStates(renderSnapshot.states, true, oscSmoothing, commitRequests);
-		}
-
-		mCachedLayerRenderStates = renderSnapshot.states;
-		layerStates = renderSnapshot.states;
-		mRuntimeSnapshotProvider.RefreshDynamicRenderStateFields(layerStates);
-		return true;
-	}
-
-	RuntimeRenderStateSnapshot renderSnapshot;
-	if (mRuntimeSnapshotProvider.TryPublishRenderStateSnapshot(renderWidth, renderHeight, renderSnapshot))
-	{
-		mCachedLayerRenderStates = renderSnapshot.states;
-		mCachedRenderStateVersion = renderSnapshot.versions.renderStateVersion;
-		mCachedParameterStateVersion = renderSnapshot.versions.parameterStateVersion;
-		mCachedRenderStateWidth = renderSnapshot.outputWidth;
-		mCachedRenderStateHeight = renderSnapshot.outputHeight;
-		mCachedLayerRenderStates = ComposeRenderLayerStates(mCachedLayerRenderStates, true, oscSmoothing, commitRequests);
-		layerStates = mCachedLayerRenderStates;
-		return true;
-	}
-
-	layerStates = ComposeRenderLayerStates(mCachedLayerRenderStates, true, oscSmoothing, commitRequests);
-	mRuntimeSnapshotProvider.RefreshDynamicRenderStateFields(layerStates);
-	return !layerStates.empty();
+	return resolved;
 }
 
-std::vector<RuntimeRenderState> RenderEngine::ComposeRenderLayerStates(
-	const std::vector<RuntimeRenderState>& baseStates,
-	bool allowCommit,
-	double smoothing,
-	std::vector<OscOverlayCommitRequest>* commitRequests)
+void RenderEngine::RenderPreparedFrame(const RenderFrameState& frameState)
 {
-	RenderStateCompositionInput input;
-	input.baseLayerStates = &baseStates;
-	input.liveState = &mRuntimeLiveState;
-	input.allowLiveCommits = allowCommit;
-	input.collectLiveCommitRequests = commitRequests != nullptr;
-	input.liveSmoothing = smoothing;
-	input.liveCommitDelay = kOscOverlayCommitDelay;
-	input.now = std::chrono::steady_clock::now();
-	const RenderStateCompositionResult result = mRenderStateComposer.BuildFrameState(input);
-
-	if (!commitRequests)
-		return result.layerStates;
-
-	for (const RuntimeLiveOscCommitRequest& request : result.commitRequests)
-		commitRequests->push_back({ request.routeKey, request.layerKey, request.parameterKey, request.value, request.generation });
-	return result.layerStates;
+	RenderLayerStack(
+		frameState.hasInputSource,
+		frameState.layerStates,
+		frameState.inputFrameWidth,
+		frameState.inputFrameHeight,
+		frameState.captureTextureWidth,
+		frameState.inputPixelFormat,
+		frameState.historyCap);
 }
 
 void RenderEngine::RenderLayerStack(