further phase 1

apps/LoopThroughWithOpenGLCompositing/runtime/RuntimeCoordinator.cpp

@@ -98,6 +98,7 @@ RuntimeCoordinatorResult RuntimeCoordinator::HandleRuntimePollFailure(const std:
 RuntimeCoordinatorResult RuntimeCoordinator::HandlePreparedShaderBuildFailure(const std::string& error)
 {
 	mPreserveFeedbackOnNextShaderBuild = false;
+	mUseCommittedLayerStates = true;
 
 	RuntimeCoordinatorResult result;
 	result.accepted = true;
@@ -111,6 +112,8 @@ RuntimeCoordinatorResult RuntimeCoordinator::HandlePreparedShaderBuildFailure(co
 
 RuntimeCoordinatorResult RuntimeCoordinator::HandlePreparedShaderBuildSuccess()
 {
+	mUseCommittedLayerStates = false;
+
 	RuntimeCoordinatorResult result;
 	result.accepted = true;
 	result.runtimeStateBroadcastRequired = true;
@@ -127,6 +130,27 @@ RuntimeCoordinatorResult RuntimeCoordinator::HandleRuntimeReloadRequest()
 	return BuildQueuedReloadResult(false);
 }
 
+void RuntimeCoordinator::ApplyCommittedStateMode(RuntimeCoordinatorCommittedStateMode mode)
+{
+	switch (mode)
+	{
+	case RuntimeCoordinatorCommittedStateMode::UseCommittedStates:
+		mUseCommittedLayerStates = true;
+		break;
+	case RuntimeCoordinatorCommittedStateMode::UseLiveSnapshots:
+		mUseCommittedLayerStates = false;
+		break;
+	case RuntimeCoordinatorCommittedStateMode::Unchanged:
+	default:
+		break;
+	}
+}
+
+bool RuntimeCoordinator::UseCommittedLayerStates() const
+{
+	return mUseCommittedLayerStates.load();
+}
+
 bool RuntimeCoordinator::PreserveFeedbackOnNextShaderBuild() const
 {
 	return mPreserveFeedbackOnNextShaderBuild;
@@ -151,6 +175,7 @@ RuntimeCoordinatorResult RuntimeCoordinator::ApplyStoreMutation(bool succeeded,
 RuntimeCoordinatorResult RuntimeCoordinator::BuildQueuedReloadResult(bool preserveFeedbackState)
 {
 	mPreserveFeedbackOnNextShaderBuild = preserveFeedbackState;
+	mUseCommittedLayerStates = true;
 
 	RuntimeCoordinatorResult result;
 	result.accepted = true;

apps/LoopThroughWithOpenGLCompositing/runtime/RuntimeCoordinator.h

@@ -2,6 +2,7 @@
 
 #include "RuntimeJson.h"
 
+#include <atomic>
 #include <cstddef>
 #include <string>
 
@@ -58,6 +59,8 @@ public:
 	RuntimeCoordinatorResult HandlePreparedShaderBuildFailure(const std::string& error);
 	RuntimeCoordinatorResult HandlePreparedShaderBuildSuccess();
 	RuntimeCoordinatorResult HandleRuntimeReloadRequest();
+	void ApplyCommittedStateMode(RuntimeCoordinatorCommittedStateMode mode);
+	bool UseCommittedLayerStates() const;
 	bool PreserveFeedbackOnNextShaderBuild() const;
 
 private:
@@ -67,4 +70,5 @@ private:
 
 	RuntimeStore& mRuntimeStore;
 	bool mPreserveFeedbackOnNextShaderBuild = false;
+	std::atomic<bool> mUseCommittedLayerStates{ false };
 };

apps/LoopThroughWithOpenGLCompositing/runtime/RuntimeHost.cpp

@@ -3,7 +3,6 @@
 
 #include "RuntimeClock.h"
 #include "RuntimeParameterUtils.h"
-#include "ShaderCompiler.h"
 #include "ShaderPackageRegistry.h"
 
 #include <algorithm>
@@ -212,42 +211,6 @@ bool ParseShaderParameterType(const std::string& typeName, ShaderParameterType&
 	return false;
 }
 
-bool TextureAssetsEqual(const std::vector<ShaderTextureAsset>& left, const std::vector<ShaderTextureAsset>& right)
-{
-	if (left.size() != right.size())
-		return false;
-
-	for (std::size_t index = 0; index < left.size(); ++index)
-	{
-		if (left[index].id != right[index].id ||
-			left[index].path != right[index].path ||
-			left[index].writeTime != right[index].writeTime)
-		{
-			return false;
-		}
-	}
-
-	return true;
-}
-
-bool FontAssetsEqual(const std::vector<ShaderFontAsset>& left, const std::vector<ShaderFontAsset>& right)
-{
-	if (left.size() != right.size())
-		return false;
-
-	for (std::size_t index = 0; index < left.size(); ++index)
-	{
-		if (left[index].id != right[index].id ||
-			left[index].path != right[index].path ||
-			left[index].writeTime != right[index].writeTime)
-		{
-			return false;
-		}
-	}
-
-	return true;
-}
-
 std::string ManifestPathMessage(const std::filesystem::path& manifestPath)
 {
 	return manifestPath.string();
@@ -712,126 +675,6 @@ RuntimeHost::RuntimeHost()
 {
 }
 
-bool RuntimeHost::PollFileChanges(bool& registryChanged, bool& reloadRequested, std::string& error)
-{
-	try
-	{
-		std::lock_guard<std::mutex> lock(mMutex);
-		registryChanged = false;
-		reloadRequested = false;
-
-		if (!mAutoReloadEnabled)
-		{
-			reloadRequested = mReloadRequested;
-			return true;
-		}
-
-		const auto now = std::chrono::steady_clock::now();
-		if (mLastScanTime != std::chrono::steady_clock::time_point::min() &&
-			std::chrono::duration_cast<std::chrono::milliseconds>(now - mLastScanTime).count() < 250)
-		{
-			reloadRequested = mReloadRequested;
-			return true;
-		}
-
-		mLastScanTime = now;
-
-		std::string scanError;
-		std::map<std::string, ShaderPackage> previousPackages = mPackagesById;
-		std::vector<std::string> previousOrder = mPackageOrder;
-		std::map<std::string, std::pair<std::filesystem::file_time_type, std::filesystem::file_time_type>> previousLayerShaderTimes;
-		for (const LayerPersistentState& layer : mPersistentState.layers)
-		{
-			auto previous = previousPackages.find(layer.shaderId);
-			if (previous != previousPackages.end())
-				previousLayerShaderTimes[layer.id] = std::make_pair(previous->second.shaderWriteTime, previous->second.manifestWriteTime);
-		}
-
-		if (!ScanShaderPackages(scanError))
-		{
-			error = scanError;
-			return false;
-		}
-
-		registryChanged = previousOrder != mPackageOrder;
-		if (!registryChanged && previousPackages.size() == mPackagesById.size())
-		{
-			for (const auto& item : mPackagesById)
-			{
-				auto previous = previousPackages.find(item.first);
-				if (previous == previousPackages.end())
-				{
-					registryChanged = true;
-					break;
-				}
-				if (previous->second.shaderWriteTime != item.second.shaderWriteTime ||
-					previous->second.manifestWriteTime != item.second.manifestWriteTime ||
-					!TextureAssetsEqual(previous->second.textureAssets, item.second.textureAssets) ||
-					!FontAssetsEqual(previous->second.fontAssets, item.second.fontAssets))
-				{
-					registryChanged = true;
-					break;
-				}
-			}
-		}
-
-		for (LayerPersistentState& layer : mPersistentState.layers)
-		{
-			auto active = mPackagesById.find(layer.shaderId);
-			auto previous = previousLayerShaderTimes.find(layer.id);
-			if (active == mPackagesById.end())
-				continue;
-			EnsureLayerDefaultsLocked(layer, active->second);
-			if (previous != previousLayerShaderTimes.end())
-			{
-				auto previousPackage = previousPackages.find(layer.shaderId);
-				if (previous->second.first != active->second.shaderWriteTime ||
-					previous->second.second != active->second.manifestWriteTime ||
-					(previousPackage != previousPackages.end() &&
-						(!TextureAssetsEqual(previousPackage->second.textureAssets, active->second.textureAssets) ||
-							!FontAssetsEqual(previousPackage->second.fontAssets, active->second.fontAssets))))
-				{
-					mReloadRequested = true;
-				}
-			}
-		}
-
-		reloadRequested = mReloadRequested;
-		if (registryChanged || reloadRequested)
-			MarkRenderStateDirtyLocked();
-		return true;
-	}
-	catch (const std::exception& exception)
-	{
-		error = std::string("RuntimeHost::PollFileChanges exception: ") + exception.what();
-		return false;
-	}
-	catch (...)
-	{
-		error = "RuntimeHost::PollFileChanges threw a non-standard exception.";
-		return false;
-	}
-}
-
-bool RuntimeHost::ManualReloadRequested()
-{
-	std::lock_guard<std::mutex> lock(mMutex);
-	return mReloadRequested;
-}
-
-void RuntimeHost::ClearReloadRequest()
-{
-	std::lock_guard<std::mutex> lock(mMutex);
-	mReloadRequested = false;
-}
-
-void RuntimeHost::SetCompileStatus(bool succeeded, const std::string& message)
-{
-	std::lock_guard<std::mutex> lock(mMutex);
-	mCompileSucceeded = succeeded;
-	mCompileMessage = message;
-}
-
 void RuntimeHost::SetSignalStatus(bool hasSignal, unsigned width, unsigned height, const std::string& modeName)
 {
 	const HealthTelemetry::SignalStatusSnapshot previousStatus = mHealthTelemetry.GetSignalStatusSnapshot();
@@ -921,69 +764,6 @@ bool RuntimeHost::TrySetFramePacingStats(double completionIntervalMilliseconds,
 		maxCompletionIntervalMilliseconds, lateFrameCount, droppedFrameCount, flushedFrameCount);
 }
 
-void RuntimeHost::AdvanceFrame()
-{
-	++mFrameCounter;
-}
-
-bool RuntimeHost::TryAdvanceFrame()
-{
-	++mFrameCounter;
-	return true;
-}
-
-bool RuntimeHost::BuildLayerPassFragmentShaderSources(const std::string& layerId, std::vector<ShaderPassBuildSource>& passSources, std::string& error)
-{
-	try
-	{
-		ShaderPackage shaderPackage;
-		{
-			std::lock_guard<std::mutex> lock(mMutex);
-			const LayerPersistentState* layer = FindLayerById(layerId);
-			if (!layer)
-			{
-				error = "Unknown layer id: " + layerId;
-				return false;
-			}
-
-			auto it = mPackagesById.find(layer->shaderId);
-			if (it == mPackagesById.end())
-			{
-				error = "Unknown shader id: " + layer->shaderId;
-				return false;
-			}
-			shaderPackage = it->second;
-		}
-
-		ShaderCompiler compiler(mRepoRoot, mWrapperPath, mGeneratedGlslPath, mPatchedGlslPath, mConfig.maxTemporalHistoryFrames);
-		// Compile every declared pass while the caller remains backend-neutral.
-		// The GL layer decides how the resulting pass sources are routed.
-		passSources.clear();
-		passSources.reserve(shaderPackage.passes.size());
-		for (const ShaderPassDefinition& pass : shaderPackage.passes)
-		{
-			ShaderPassBuildSource passSource;
-			passSource.passId = pass.id;
-			passSource.inputNames = pass.inputNames;
-			passSource.outputName = pass.outputName;
-			if (!compiler.BuildPassFragmentShaderSource(shaderPackage, pass, passSource.fragmentShaderSource, error))
-				return false;
-			passSources.push_back(std::move(passSource));
-		}
-		return true;
-	}
-	catch (const std::exception& exception)
-	{
-		error = std::string("RuntimeHost::BuildLayerPassFragmentShaderSources exception: ") + exception.what();
-		return false;
-	}
-	catch (...)
-	{
-		error = "RuntimeHost::BuildLayerPassFragmentShaderSources threw a non-standard exception.";
-		return false;
-	}
-}
-
 void RuntimeHost::SetServerPort(unsigned short port)
 {
 	std::lock_guard<std::mutex> lock(mMutex);

apps/LoopThroughWithOpenGLCompositing/runtime/RuntimeHost.h

@@ -20,12 +20,6 @@ class RuntimeHost
 {
 public:
 	RuntimeHost();
-
-	bool PollFileChanges(bool& registryChanged, bool& reloadRequested, std::string& error);
-	bool ManualReloadRequested();
-	void ClearReloadRequest();
-
-	void SetCompileStatus(bool succeeded, const std::string& message);
 	void SetSignalStatus(bool hasSignal, unsigned width, unsigned height, const std::string& modeName);
 	bool TrySetSignalStatus(bool hasSignal, unsigned width, unsigned height, const std::string& modeName);
 	void SetDeckLinkOutputStatus(const std::string& modelName, bool supportsInternalKeying, bool supportsExternalKeying,
@@ -38,15 +32,9 @@ public:
 		double maxCompletionIntervalMilliseconds, uint64_t lateFrameCount, uint64_t droppedFrameCount, uint64_t flushedFrameCount);
 	bool TrySetFramePacingStats(double completionIntervalMilliseconds, double smoothedCompletionIntervalMilliseconds,
 		double maxCompletionIntervalMilliseconds, uint64_t lateFrameCount, uint64_t droppedFrameCount, uint64_t flushedFrameCount);
-	void AdvanceFrame();
-	bool TryAdvanceFrame();
 	HealthTelemetry& GetHealthTelemetry() { return mHealthTelemetry; }
 	const HealthTelemetry& GetHealthTelemetry() const { return mHealthTelemetry; }
 
-	bool BuildLayerPassFragmentShaderSources(const std::string& layerId, std::vector<ShaderPassBuildSource>& passSources, std::string& error);
-	uint64_t GetRenderStateVersion() const { return mRenderStateVersion.load(std::memory_order_relaxed); }
-	uint64_t GetParameterStateVersion() const { return mParameterStateVersion.load(std::memory_order_relaxed); }
-
 	const std::filesystem::path& GetRepoRoot() const { return mRepoRoot; }
 	const std::filesystem::path& GetUiRoot() const { return mUiRoot; }
 	const std::filesystem::path& GetDocsRoot() const { return mDocsRoot; }

apps/LoopThroughWithOpenGLCompositing/runtime/RuntimeSnapshotProvider.cpp

@@ -1,6 +1,7 @@
 #include "RuntimeSnapshotProvider.h"
 
 #include "RuntimeClock.h"
+#include "ShaderCompiler.h"
 
 #include <algorithm>
 #include <mutex>
@@ -13,7 +14,57 @@ RuntimeSnapshotProvider::RuntimeSnapshotProvider(RuntimeHost& runtimeHost) :
 
 bool RuntimeSnapshotProvider::BuildLayerPassFragmentShaderSources(const std::string& layerId, std::vector<ShaderPassBuildSource>& passSources, std::string& error) const
 {
-	return mRuntimeHost.BuildLayerPassFragmentShaderSources(layerId, passSources, error);
+	try
+	{
+		ShaderPackage shaderPackage;
+		{
+			std::lock_guard<std::mutex> lock(mRuntimeHost.mMutex);
+			const RuntimeHost::LayerPersistentState* layer = mRuntimeHost.FindLayerById(layerId);
+			if (!layer)
+			{
+				error = "Unknown layer id: " + layerId;
+				return false;
+			}
+
+			auto it = mRuntimeHost.mPackagesById.find(layer->shaderId);
+			if (it == mRuntimeHost.mPackagesById.end())
+			{
+				error = "Unknown shader id: " + layer->shaderId;
+				return false;
+			}
+			shaderPackage = it->second;
+		}
+
+		ShaderCompiler compiler(
+			mRuntimeHost.mRepoRoot,
+			mRuntimeHost.mWrapperPath,
+			mRuntimeHost.mGeneratedGlslPath,
+			mRuntimeHost.mPatchedGlslPath,
+			mRuntimeHost.mConfig.maxTemporalHistoryFrames);
+		passSources.clear();
+		passSources.reserve(shaderPackage.passes.size());
+		for (const ShaderPassDefinition& pass : shaderPackage.passes)
+		{
+			ShaderPassBuildSource passSource;
+			passSource.passId = pass.id;
+			passSource.inputNames = pass.inputNames;
+			passSource.outputName = pass.outputName;
+			if (!compiler.BuildPassFragmentShaderSource(shaderPackage, pass, passSource.fragmentShaderSource, error))
+				return false;
+			passSources.push_back(std::move(passSource));
+		}
+		return true;
+	}
+	catch (const std::exception& exception)
+	{
+		error = std::string("RuntimeSnapshotProvider::BuildLayerPassFragmentShaderSources exception: ") + exception.what();
+		return false;
+	}
+	catch (...)
+	{
+		error = "RuntimeSnapshotProvider::BuildLayerPassFragmentShaderSources threw a non-standard exception.";
+		return false;
+	}
 }
 
 unsigned RuntimeSnapshotProvider::GetMaxTemporalHistoryFrames() const
@@ -24,8 +75,8 @@ unsigned RuntimeSnapshotProvider::GetMaxTemporalHistoryFrames() const
 RuntimeSnapshotVersions RuntimeSnapshotProvider::GetVersions() const
 {
 	RuntimeSnapshotVersions versions;
-	versions.renderStateVersion = mRuntimeHost.GetRenderStateVersion();
-	versions.parameterStateVersion = mRuntimeHost.GetParameterStateVersion();
+	versions.renderStateVersion = mRuntimeHost.mRenderStateVersion.load(std::memory_order_relaxed);
+	versions.parameterStateVersion = mRuntimeHost.mParameterStateVersion.load(std::memory_order_relaxed);
 	return versions;
 }
 
@@ -46,12 +97,13 @@ RuntimeRenderFrameContext RuntimeSnapshotProvider::GetFrameContext() const
 
 void RuntimeSnapshotProvider::AdvanceFrame()
 {
-	mRuntimeHost.AdvanceFrame();
+	++mRuntimeHost.mFrameCounter;
 }
 
 bool RuntimeSnapshotProvider::TryAdvanceFrame()
 {
-	return mRuntimeHost.TryAdvanceFrame();
+	++mRuntimeHost.mFrameCounter;
+	return true;
 }
 
 RuntimeRenderStateSnapshot RuntimeSnapshotProvider::GetRenderStateSnapshot(unsigned outputWidth, unsigned outputHeight) const

apps/LoopThroughWithOpenGLCompositing/runtime/RuntimeStore.cpp

@@ -30,6 +30,42 @@ bool MatchesControlKey(const std::string& candidate, const std::string& key)
 {
 	return candidate == key || SimplifyControlKey(candidate) == SimplifyControlKey(key);
 }
+
+bool TextureAssetsEqual(const std::vector<ShaderTextureAsset>& left, const std::vector<ShaderTextureAsset>& right)
+{
+	if (left.size() != right.size())
+		return false;
+
+	for (std::size_t index = 0; index < left.size(); ++index)
+	{
+		if (left[index].id != right[index].id ||
+			left[index].path != right[index].path ||
+			left[index].writeTime != right[index].writeTime)
+		{
+			return false;
+		}
+	}
+
+	return true;
+}
+
+bool FontAssetsEqual(const std::vector<ShaderFontAsset>& left, const std::vector<ShaderFontAsset>& right)
+{
+	if (left.size() != right.size())
+		return false;
+
+	for (std::size_t index = 0; index < left.size(); ++index)
+	{
+		if (left[index].id != right[index].id ||
+			left[index].path != right[index].path ||
+			left[index].writeTime != right[index].writeTime)
+		{
+			return false;
+		}
+	}
+
+	return true;
+}
 }
 
 RuntimeStore::RuntimeStore(RuntimeHost& runtimeHost) :
@@ -94,6 +130,107 @@ std::string RuntimeStore::BuildPersistentStateJson() const
 	return SerializeJson(BuildRuntimeStateValue(), true);
 }
 
+bool RuntimeStore::PollStoredFileChanges(bool& registryChanged, bool& reloadRequested, std::string& error)
+{
+	try
+	{
+		std::lock_guard<std::mutex> lock(mRuntimeHost.mMutex);
+		registryChanged = false;
+		reloadRequested = false;
+
+		if (!mRuntimeHost.mAutoReloadEnabled)
+		{
+			reloadRequested = mRuntimeHost.mReloadRequested;
+			return true;
+		}
+
+		const auto now = std::chrono::steady_clock::now();
+		if (mRuntimeHost.mLastScanTime != std::chrono::steady_clock::time_point::min() &&
+			std::chrono::duration_cast<std::chrono::milliseconds>(now - mRuntimeHost.mLastScanTime).count() < 250)
+		{
+			reloadRequested = mRuntimeHost.mReloadRequested;
+			return true;
+		}
+
+		mRuntimeHost.mLastScanTime = now;
+
+		std::string scanError;
+		std::map<std::string, ShaderPackage> previousPackages = mRuntimeHost.mPackagesById;
+		std::vector<std::string> previousOrder = mRuntimeHost.mPackageOrder;
+		std::map<std::string, std::pair<std::filesystem::file_time_type, std::filesystem::file_time_type>> previousLayerShaderTimes;
+		for (const RuntimeHost::LayerPersistentState& layer : mRuntimeHost.mPersistentState.layers)
+		{
+			auto previous = previousPackages.find(layer.shaderId);
+			if (previous != previousPackages.end())
+				previousLayerShaderTimes[layer.id] = std::make_pair(previous->second.shaderWriteTime, previous->second.manifestWriteTime);
+		}
+
+		if (!mRuntimeHost.ScanShaderPackages(scanError))
+		{
+			error = scanError;
+			return false;
+		}
+
+		registryChanged = previousOrder != mRuntimeHost.mPackageOrder;
+		if (!registryChanged && previousPackages.size() == mRuntimeHost.mPackagesById.size())
+		{
+			for (const auto& item : mRuntimeHost.mPackagesById)
+			{
+				auto previous = previousPackages.find(item.first);
+				if (previous == previousPackages.end())
+				{
+					registryChanged = true;
+					break;
+				}
+				if (previous->second.shaderWriteTime != item.second.shaderWriteTime ||
+					previous->second.manifestWriteTime != item.second.manifestWriteTime ||
+					!TextureAssetsEqual(previous->second.textureAssets, item.second.textureAssets) ||
+					!FontAssetsEqual(previous->second.fontAssets, item.second.fontAssets))
+				{
+					registryChanged = true;
+					break;
+				}
+			}
+		}
+
+		for (RuntimeHost::LayerPersistentState& layer : mRuntimeHost.mPersistentState.layers)
+		{
+			auto active = mRuntimeHost.mPackagesById.find(layer.shaderId);
+			auto previous = previousLayerShaderTimes.find(layer.id);
+			if (active == mRuntimeHost.mPackagesById.end())
+				continue;
+			mRuntimeHost.EnsureLayerDefaultsLocked(layer, active->second);
+			if (previous != previousLayerShaderTimes.end())
+			{
+				auto previousPackage = previousPackages.find(layer.shaderId);
+				if (previous->second.first != active->second.shaderWriteTime ||
+					previous->second.second != active->second.manifestWriteTime ||
+					(previousPackage != previousPackages.end() &&
+						(!TextureAssetsEqual(previousPackage->second.textureAssets, active->second.textureAssets) ||
+							!FontAssetsEqual(previousPackage->second.fontAssets, active->second.fontAssets))))
+				{
+					mRuntimeHost.mReloadRequested = true;
+				}
+			}
+		}
+
+		reloadRequested = mRuntimeHost.mReloadRequested;
+		if (registryChanged || reloadRequested)
+			mRuntimeHost.MarkRenderStateDirtyLocked();
+		return true;
+	}
+	catch (const std::exception& exception)
+	{
+		error = std::string("RuntimeStore::PollStoredFileChanges exception: ") + exception.what();
+		return false;
+	}
+	catch (...)
+	{
+		error = "RuntimeStore::PollStoredFileChanges threw a non-standard exception.";
+		return false;
+	}
+}
+
 bool RuntimeStore::CreateStoredLayer(const std::string& shaderId, std::string& error)
 {
 	std::lock_guard<std::mutex> lock(mRuntimeHost.mMutex);
@@ -465,12 +602,15 @@ const std::string& RuntimeStore::GetConfiguredOutputFrameRate() const
 
 void RuntimeStore::SetCompileStatus(bool succeeded, const std::string& message)
 {
-	mRuntimeHost.SetCompileStatus(succeeded, message);
+	std::lock_guard<std::mutex> lock(mRuntimeHost.mMutex);
+	mRuntimeHost.mCompileSucceeded = succeeded;
+	mRuntimeHost.mCompileMessage = message;
 }
 
 void RuntimeStore::ClearReloadRequest()
 {
-	mRuntimeHost.ClearReloadRequest();
+	std::lock_guard<std::mutex> lock(mRuntimeHost.mMutex);
+	mRuntimeHost.mReloadRequested = false;
 }
 
 JsonValue RuntimeStore::BuildRuntimeStateValue() const

apps/LoopThroughWithOpenGLCompositing/runtime/RuntimeStore.h

@@ -12,6 +12,7 @@ public:
 
 	bool InitializeStore(std::string& error);
 	std::string BuildPersistentStateJson() const;
+	bool PollStoredFileChanges(bool& registryChanged, bool& reloadRequested, std::string& error);
 
 	bool CreateStoredLayer(const std::string& shaderId, std::string& error);
 	bool DeleteStoredLayer(const std::string& layerId, std::string& error);