render engine updates

apps/LoopThroughWithOpenGLCompositing/control/RuntimeServiceLiveBridge.cpp

@@ -56,25 +56,16 @@ void QueueServiceCommitRequests(
 }
 }
 
-bool RuntimeServiceLiveBridge::PrepareLiveRenderLayerStates(
+bool RuntimeServiceLiveBridge::PrepareLiveRenderFrameState(
 	RuntimeServices& runtimeServices,
 	RenderEngine& renderEngine,
-	bool useCommittedLayerStates,
-	unsigned renderWidth,
-	unsigned renderHeight,
-	double oscSmoothing,
-	std::vector<RuntimeRenderState>& layerStates)
+	const RenderFrameInput& input,
+	RenderFrameState& frameState)
 {
 	DrainServiceEvents(runtimeServices, renderEngine);
 
 	std::vector<RenderEngine::OscOverlayCommitRequest> commitRequests;
-	const bool resolved = renderEngine.ResolveRenderLayerStates(
-		useCommittedLayerStates,
-		renderWidth,
-		renderHeight,
-		oscSmoothing,
-		&commitRequests,
-		layerStates);
+	const bool resolved = renderEngine.ResolveRenderFrameState(input, &commitRequests, frameState);
 
 	QueueServiceCommitRequests(runtimeServices, commitRequests);
 	return resolved;

apps/LoopThroughWithOpenGLCompositing/control/RuntimeServiceLiveBridge.h

@@ -1,6 +1,6 @@
 #pragma once
 
-#include "ShaderTypes.h"
+#include "RenderFrameState.h"
 
 #include <vector>
 
@@ -10,12 +10,9 @@ class RuntimeServices;
 class RuntimeServiceLiveBridge
 {
 public:
-	static bool PrepareLiveRenderLayerStates(
+	static bool PrepareLiveRenderFrameState(
 		RuntimeServices& runtimeServices,
 		RenderEngine& renderEngine,
-		bool useCommittedLayerStates,
-		unsigned renderWidth,
-		unsigned renderHeight,
-		double oscSmoothing,
-		std::vector<RuntimeRenderState>& layerStates);
+		const RenderFrameInput& input,
+		RenderFrameState& frameState);
 };

apps/LoopThroughWithOpenGLCompositing/gl/OpenGLComposite.cpp

@@ -294,39 +294,32 @@ void OpenGLComposite::renderEffect()
 	if (mRuntimeUpdateController)
 		mRuntimeUpdateController->ProcessRuntimeWork();
 
-	const bool hasInputSource = mVideoBackend->HasInputSource();
-	std::vector<RuntimeRenderState> layerStates;
-	const double smoothing = mRuntimeStore ? mRuntimeStore->GetConfiguredOscSmoothing() : 0.0;
+	RenderFrameInput frameInput;
+	frameInput.useCommittedLayerStates = mRuntimeCoordinator && mRuntimeCoordinator->UseCommittedLayerStates();
+	frameInput.hasInputSource = mVideoBackend->HasInputSource();
+	frameInput.renderWidth = mVideoBackend->InputFrameWidth();
+	frameInput.renderHeight = mVideoBackend->InputFrameHeight();
+	frameInput.inputFrameWidth = mVideoBackend->InputFrameWidth();
+	frameInput.inputFrameHeight = mVideoBackend->InputFrameHeight();
+	frameInput.captureTextureWidth = mVideoBackend->CaptureTextureWidth();
+	frameInput.inputPixelFormat = mVideoBackend->InputPixelFormat();
+	frameInput.historyCap = mRuntimeStore ? mRuntimeStore->GetConfiguredMaxTemporalHistoryFrames() : 0;
+	frameInput.oscSmoothing = mRuntimeStore ? mRuntimeStore->GetConfiguredOscSmoothing() : 0.0;
+
+	RenderFrameState frameState;
 	if (mRuntimeServices)
 	{
-		RuntimeServiceLiveBridge::PrepareLiveRenderLayerStates(
+		RuntimeServiceLiveBridge::PrepareLiveRenderFrameState(
 			*mRuntimeServices,
 			*mRenderEngine,
-			mRuntimeCoordinator && mRuntimeCoordinator->UseCommittedLayerStates(),
-			mVideoBackend->InputFrameWidth(),
-			mVideoBackend->InputFrameHeight(),
-			smoothing,
-			layerStates);
+			frameInput,
+			frameState);
 	}
 	else
 	{
-		mRenderEngine->ResolveRenderLayerStates(
-			mRuntimeCoordinator && mRuntimeCoordinator->UseCommittedLayerStates(),
-			mVideoBackend->InputFrameWidth(),
-			mVideoBackend->InputFrameHeight(),
-			smoothing,
-			nullptr,
-			layerStates);
+		mRenderEngine->ResolveRenderFrameState(frameInput, nullptr, frameState);
 	}
-	const unsigned historyCap = mRuntimeStore ? mRuntimeStore->GetConfiguredMaxTemporalHistoryFrames() : 0;
-	mRenderEngine->RenderLayerStack(
-		hasInputSource,
-		layerStates,
-		mVideoBackend->InputFrameWidth(),
-		mVideoBackend->InputFrameHeight(),
-		mVideoBackend->CaptureTextureWidth(),
-		mVideoBackend->InputPixelFormat(),
-		historyCap);
+	mRenderEngine->RenderPreparedFrame(frameState);
 }
 
 void OpenGLComposite::ProcessScreenshotRequest()

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(

apps/LoopThroughWithOpenGLCompositing/gl/RenderEngine.h

@@ -4,7 +4,8 @@
 #include "OpenGLRenderPipeline.h"
 #include "OpenGLRenderer.h"
 #include "OpenGLShaderPrograms.h"
-#include "RenderStateComposer.h"
+#include "RenderFrameState.h"
+#include "RenderFrameStateResolver.h"
 #include "HealthTelemetry.h"
 #include "RuntimeCoordinator.h"
 #include "RuntimeSnapshotProvider.h"
@@ -104,13 +105,11 @@ public:
 	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,
-		double oscSmoothing,
+	bool ResolveRenderFrameState(
+		const RenderFrameInput& input,
 		std::vector<OscOverlayCommitRequest>* commitRequests,
-		std::vector<RuntimeRenderState>& layerStates);
+		RenderFrameState& frameState);
+	void RenderPreparedFrame(const RenderFrameState& frameState);
 	void RenderLayerStack(
 		bool hasInputSource,
 		const std::vector<RuntimeRenderState>& layerStates,
@@ -127,23 +126,11 @@ private:
 	OpenGLRenderPass mRenderPass;
 	OpenGLRenderPipeline mRenderPipeline;
 	OpenGLShaderPrograms mShaderPrograms;
-	RuntimeSnapshotProvider& mRuntimeSnapshotProvider;
 	CRITICAL_SECTION& mMutex;
 	HDC mHdc;
 	HGLRC mHglrc;
 
-	std::vector<RuntimeRenderState> ComposeRenderLayerStates(
-		const std::vector<RuntimeRenderState>& baseStates,
-		bool allowCommit,
-		double smoothing,
-		std::vector<OscOverlayCommitRequest>* commitRequests);
-
-	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;
-	RenderStateComposer mRenderStateComposer;
+	RenderFrameStateResolver mFrameStateResolver;
 	RuntimeLiveState mRuntimeLiveState;
 };

apps/LoopThroughWithOpenGLCompositing/gl/RenderFrameState.h

@@ -0,0 +1,31 @@
+#pragma once
+
+#include "ShaderTypes.h"
+#include "VideoIOTypes.h"
+
+#include <vector>
+
+struct RenderFrameInput
+{
+	bool useCommittedLayerStates = false;
+	bool hasInputSource = false;
+	unsigned renderWidth = 0;
+	unsigned renderHeight = 0;
+	unsigned inputFrameWidth = 0;
+	unsigned inputFrameHeight = 0;
+	unsigned captureTextureWidth = 0;
+	VideoIOPixelFormat inputPixelFormat = VideoIOPixelFormat::Uyvy8;
+	unsigned historyCap = 0;
+	double oscSmoothing = 0.0;
+};
+
+struct RenderFrameState
+{
+	bool hasInputSource = false;
+	unsigned inputFrameWidth = 0;
+	unsigned inputFrameHeight = 0;
+	unsigned captureTextureWidth = 0;
+	VideoIOPixelFormat inputPixelFormat = VideoIOPixelFormat::Uyvy8;
+	unsigned historyCap = 0;
+	std::vector<RuntimeRenderState> layerStates;
+};

apps/LoopThroughWithOpenGLCompositing/gl/RenderFrameStateResolver.cpp

@@ -0,0 +1,119 @@
+#include "RenderFrameStateResolver.h"
+
+#include <chrono>
+
+namespace
+{
+constexpr auto kOscOverlayCommitDelay = std::chrono::milliseconds(150);
+}
+
+RenderFrameStateResolver::RenderFrameStateResolver(RuntimeSnapshotProvider& runtimeSnapshotProvider) :
+	mRuntimeSnapshotProvider(runtimeSnapshotProvider)
+{
+}
+
+void RenderFrameStateResolver::StoreCommittedSnapshot(
+	const RuntimeRenderStateSnapshot& snapshot,
+	const std::vector<RuntimeRenderState>& committedLayerStates)
+{
+	mCachedLayerRenderStates = committedLayerStates;
+	mCachedRenderStateVersion = snapshot.versions.renderStateVersion;
+	mCachedParameterStateVersion = snapshot.versions.parameterStateVersion;
+	mCachedRenderStateWidth = snapshot.outputWidth;
+	mCachedRenderStateHeight = snapshot.outputHeight;
+}
+
+bool RenderFrameStateResolver::Resolve(
+	const RenderFrameInput& input,
+	const std::vector<RuntimeRenderState>& committedLayerStates,
+	RuntimeLiveState& liveState,
+	std::vector<RuntimeLiveOscCommitRequest>* commitRequests,
+	RenderFrameState& frameState)
+{
+	frameState.hasInputSource = input.hasInputSource;
+	frameState.inputFrameWidth = input.inputFrameWidth;
+	frameState.inputFrameHeight = input.inputFrameHeight;
+	frameState.captureTextureWidth = input.captureTextureWidth;
+	frameState.inputPixelFormat = input.inputPixelFormat;
+	frameState.historyCap = input.historyCap;
+	frameState.layerStates.clear();
+
+	if (input.useCommittedLayerStates)
+	{
+		frameState.layerStates = ComposeLayerStates(committedLayerStates, liveState, false, input.oscSmoothing, commitRequests);
+		mRuntimeSnapshotProvider.RefreshDynamicRenderStateFields(frameState.layerStates);
+		return true;
+	}
+
+	const RuntimeSnapshotVersions versions = mRuntimeSnapshotProvider.GetVersions();
+	const bool renderStateCacheValid =
+		!mCachedLayerRenderStates.empty() &&
+		mCachedRenderStateVersion == versions.renderStateVersion &&
+		mCachedRenderStateWidth == input.renderWidth &&
+		mCachedRenderStateHeight == input.renderHeight;
+
+	if (renderStateCacheValid)
+	{
+		RuntimeRenderStateSnapshot renderSnapshot;
+		renderSnapshot.outputWidth = input.renderWidth;
+		renderSnapshot.outputHeight = input.renderHeight;
+		renderSnapshot.versions.renderStateVersion = mCachedRenderStateVersion;
+		renderSnapshot.versions.parameterStateVersion = mCachedParameterStateVersion;
+		renderSnapshot.states = mCachedLayerRenderStates;
+
+		renderSnapshot.states = ComposeLayerStates(renderSnapshot.states, liveState, true, input.oscSmoothing, commitRequests);
+		if (mCachedParameterStateVersion != versions.parameterStateVersion &&
+			mRuntimeSnapshotProvider.TryRefreshPublishedSnapshotParameters(renderSnapshot))
+		{
+			mCachedParameterStateVersion = renderSnapshot.versions.parameterStateVersion;
+			renderSnapshot.states = ComposeLayerStates(renderSnapshot.states, liveState, true, input.oscSmoothing, commitRequests);
+		}
+
+		mCachedLayerRenderStates = renderSnapshot.states;
+		frameState.layerStates = renderSnapshot.states;
+		mRuntimeSnapshotProvider.RefreshDynamicRenderStateFields(frameState.layerStates);
+		return true;
+	}
+
+	RuntimeRenderStateSnapshot renderSnapshot;
+	if (mRuntimeSnapshotProvider.TryPublishRenderStateSnapshot(input.renderWidth, input.renderHeight, renderSnapshot))
+	{
+		mCachedLayerRenderStates = renderSnapshot.states;
+		mCachedRenderStateVersion = renderSnapshot.versions.renderStateVersion;
+		mCachedParameterStateVersion = renderSnapshot.versions.parameterStateVersion;
+		mCachedRenderStateWidth = renderSnapshot.outputWidth;
+		mCachedRenderStateHeight = renderSnapshot.outputHeight;
+		mCachedLayerRenderStates = ComposeLayerStates(mCachedLayerRenderStates, liveState, true, input.oscSmoothing, commitRequests);
+		frameState.layerStates = mCachedLayerRenderStates;
+		return true;
+	}
+
+	frameState.layerStates = ComposeLayerStates(mCachedLayerRenderStates, liveState, true, input.oscSmoothing, commitRequests);
+	mRuntimeSnapshotProvider.RefreshDynamicRenderStateFields(frameState.layerStates);
+	return !frameState.layerStates.empty();
+}
+
+std::vector<RuntimeRenderState> RenderFrameStateResolver::ComposeLayerStates(
+	const std::vector<RuntimeRenderState>& baseStates,
+	RuntimeLiveState& liveState,
+	bool allowCommit,
+	double smoothing,
+	std::vector<RuntimeLiveOscCommitRequest>* commitRequests) const
+{
+	RenderStateCompositionInput input;
+	input.baseLayerStates = &baseStates;
+	input.liveState = &liveState;
+	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)
+	{
+		for (const RuntimeLiveOscCommitRequest& request : result.commitRequests)
+			commitRequests->push_back(request);
+	}
+	return result.layerStates;
+}

apps/LoopThroughWithOpenGLCompositing/gl/RenderFrameStateResolver.h

@@ -0,0 +1,40 @@
+#pragma once
+
+#include "RenderFrameState.h"
+#include "RenderStateComposer.h"
+#include "RuntimeSnapshotProvider.h"
+
+#include <cstdint>
+#include <vector>
+
+class RenderFrameStateResolver
+{
+public:
+	explicit RenderFrameStateResolver(RuntimeSnapshotProvider& runtimeSnapshotProvider);
+
+	void StoreCommittedSnapshot(
+		const RuntimeRenderStateSnapshot& snapshot,
+		const std::vector<RuntimeRenderState>& committedLayerStates);
+	bool Resolve(
+		const RenderFrameInput& input,
+		const std::vector<RuntimeRenderState>& committedLayerStates,
+		RuntimeLiveState& liveState,
+		std::vector<RuntimeLiveOscCommitRequest>* commitRequests,
+		RenderFrameState& frameState);
+
+private:
+	std::vector<RuntimeRenderState> ComposeLayerStates(
+		const std::vector<RuntimeRenderState>& baseStates,
+		RuntimeLiveState& liveState,
+		bool allowCommit,
+		double smoothing,
+		std::vector<RuntimeLiveOscCommitRequest>* commitRequests) const;
+
+	RuntimeSnapshotProvider& mRuntimeSnapshotProvider;
+	RenderStateComposer mRenderStateComposer;
+	std::vector<RuntimeRenderState> mCachedLayerRenderStates;
+	uint64_t mCachedRenderStateVersion = 0;
+	uint64_t mCachedParameterStateVersion = 0;
+	unsigned mCachedRenderStateWidth = 0;
+	unsigned mCachedRenderStateHeight = 0;
+};