step 3

apps/LoopThroughWithOpenGLCompositing/runtime/coordination/RuntimeCoordinator.cpp

@@ -56,6 +56,11 @@ RuntimeCoordinatorResult RuntimeCoordinator::RemoveLayer(const std::string& laye
 	}
 
 	RuntimeCoordinatorResult result = ApplyStoreMutation(mRuntimeStore.DeleteStoredLayer(layerId, error), error, true, true, true);
+	if (result.accepted)
+	{
+		result.transientOscInvalidation = RuntimeCoordinatorTransientOscInvalidation::Layer;
+		result.transientOscLayerKey = layerId;
+	}
 	PublishCoordinatorResult("RemoveLayer", result);
 	return result;
 }
@@ -205,7 +210,8 @@ RuntimeCoordinatorResult RuntimeCoordinator::ResetLayerParameters(const std::str
 		return result;
 	}
 
-	result.clearTransientOscState = true;
+	result.transientOscInvalidation = RuntimeCoordinatorTransientOscInvalidation::Layer;
+	result.transientOscLayerKey = layerId;
 	result.renderResetScope = RuntimeCoordinatorRenderResetScope::TemporalHistoryAndFeedback;
 	PublishCoordinatorResult("ResetLayerParameters", result);
 	return result;
@@ -538,7 +544,7 @@ void RuntimeCoordinator::PublishCoordinatorResult(const std::string& action, con
 		mutation.runtimeStateBroadcastRequired = result.runtimeStateBroadcastRequired;
 		mutation.shaderBuildRequested = result.shaderBuildRequested;
 		mutation.persistenceRequested = result.persistenceRequested;
-		mutation.clearTransientOscState = result.clearTransientOscState;
+		mutation.clearTransientOscState = result.transientOscInvalidation != RuntimeCoordinatorTransientOscInvalidation::None;
 		mutation.renderResetScope = ToRuntimeEventRenderResetScope(result.renderResetScope);
 		mutation.errorMessage = result.errorMessage;
 		mRuntimeEventDispatcher.PublishPayload(mutation, "RuntimeCoordinator");

apps/LoopThroughWithOpenGLCompositing/runtime/coordination/RuntimeCoordinator.h

@@ -25,18 +25,26 @@ enum class RuntimeCoordinatorRenderResetScope
 	TemporalHistoryAndFeedback
 };
 
+enum class RuntimeCoordinatorTransientOscInvalidation
+{
+	None,
+	Layer,
+	All
+};
+
 struct RuntimeCoordinatorResult
 {
 	bool accepted = false;
 	bool runtimeStateBroadcastRequired = false;
 	bool shaderBuildRequested = false;
 	bool persistenceRequested = false;
-	bool clearTransientOscState = false;
 	bool compileStatusChanged = false;
 	bool compileStatusSucceeded = false;
 	bool clearReloadRequest = false;
 	RuntimeCoordinatorCommittedStateMode committedStateMode = RuntimeCoordinatorCommittedStateMode::Unchanged;
 	RuntimeCoordinatorRenderResetScope renderResetScope = RuntimeCoordinatorRenderResetScope::None;
+	RuntimeCoordinatorTransientOscInvalidation transientOscInvalidation = RuntimeCoordinatorTransientOscInvalidation::None;
+	std::string transientOscLayerKey;
 	std::string compileStatusMessage;
 	std::string errorMessage;
 };

apps/LoopThroughWithOpenGLCompositing/runtime/live/RuntimeLiveState.cpp

@@ -74,6 +74,7 @@ JsonValue BuildOscCommitValue(const ShaderParameterDefinition& definition, const
 
 	return JsonValue();
 }
+
 }
 
 void RuntimeLiveState::Clear()
@@ -81,6 +82,47 @@ void RuntimeLiveState::Clear()
 	mOscOverlayStates.clear();
 }
 
+void RuntimeLiveState::ClearForLayerKey(const std::string& layerKey)
+{
+	for (auto it = mOscOverlayStates.begin(); it != mOscOverlayStates.end();)
+	{
+		if (OverlayMatchesLayerKey(it->second, layerKey))
+			it = mOscOverlayStates.erase(it);
+		else
+			++it;
+	}
+}
+
+bool RuntimeLiveState::OverlayMatchesLayerKey(const OscOverlayState& overlay, const std::string& layerKey)
+{
+	return MatchesOscControlKey(overlay.layerKey, layerKey);
+}
+
+bool RuntimeLiveState::TryResolveOverlayTarget(
+	const OscOverlayState& overlay,
+	const std::vector<RuntimeRenderState>& states,
+	std::vector<RuntimeRenderState>::const_iterator& stateIt,
+	std::vector<ShaderParameterDefinition>::const_iterator& definitionIt)
+{
+	stateIt = std::find_if(states.begin(), states.end(),
+		[&overlay](const RuntimeRenderState& state)
+		{
+			return MatchesOscControlKey(state.layerId, overlay.layerKey) ||
+				MatchesOscControlKey(state.shaderId, overlay.layerKey) ||
+				MatchesOscControlKey(state.shaderName, overlay.layerKey);
+		});
+	if (stateIt == states.end())
+		return false;
+
+	definitionIt = std::find_if(stateIt->parameterDefinitions.begin(), stateIt->parameterDefinitions.end(),
+		[&overlay](const ShaderParameterDefinition& definition)
+		{
+			return MatchesOscControlKey(definition.id, overlay.parameterKey) ||
+				MatchesOscControlKey(definition.label, overlay.parameterKey);
+		});
+	return definitionIt != stateIt->parameterDefinitions.end();
+}
+
 std::size_t RuntimeLiveState::OverlayCount() const
 {
 	return mOscOverlayStates.size();
@@ -131,6 +173,27 @@ void RuntimeLiveState::ApplyOscCommitCompletions(const std::vector<RuntimeLiveOs
 	}
 }
 
+void RuntimeLiveState::PruneIncompatibleOverlays(const std::vector<RuntimeRenderState>& states)
+{
+	for (auto it = mOscOverlayStates.begin(); it != mOscOverlayStates.end();)
+	{
+		std::vector<RuntimeRenderState>::const_iterator stateIt;
+		std::vector<ShaderParameterDefinition>::const_iterator definitionIt;
+		if (TryResolveOverlayTarget(it->second, states, stateIt, definitionIt))
+		{
+			ShaderParameterValue targetValue;
+			std::string normalizeError;
+			if (NormalizeAndValidateParameterValue(*definitionIt, it->second.targetValue, targetValue, normalizeError))
+			{
+				++it;
+				continue;
+			}
+		}
+
+		it = mOscOverlayStates.erase(it);
+	}
+}
+
 void RuntimeLiveState::ApplyToLayerStates(
 	std::vector<RuntimeRenderState>& states,
 	const RuntimeLiveStateApplyOptions& options,
@@ -139,6 +202,10 @@ void RuntimeLiveState::ApplyToLayerStates(
 	if (states.empty() || mOscOverlayStates.empty())
 		return;
 
+	PruneIncompatibleOverlays(states);
+	if (mOscOverlayStates.empty())
+		return;
+
 	const auto now = options.now;
 	const double clampedSmoothing = ClampOscAlpha(options.smoothing);
 	std::vector<std::string> overlayKeysToRemove;

apps/LoopThroughWithOpenGLCompositing/runtime/live/RuntimeLiveState.h

@@ -44,9 +44,11 @@ class RuntimeLiveState
 {
 public:
 	void Clear();
+	void ClearForLayerKey(const std::string& layerKey);
 	std::size_t OverlayCount() const;
 	void ApplyOscUpdates(const std::vector<RuntimeLiveOscUpdate>& updates);
 	void ApplyOscCommitCompletions(const std::vector<RuntimeLiveOscCommitCompletion>& completedCommits);
+	void PruneIncompatibleOverlays(const std::vector<RuntimeRenderState>& states);
 	void ApplyToLayerStates(
 		std::vector<RuntimeRenderState>& states,
 		const RuntimeLiveStateApplyOptions& options,
@@ -67,5 +69,12 @@ private:
 		bool commitQueued = false;
 	};
 
+	static bool OverlayMatchesLayerKey(const OscOverlayState& overlay, const std::string& layerKey);
+	static bool TryResolveOverlayTarget(
+		const OscOverlayState& overlay,
+		const std::vector<RuntimeRenderState>& states,
+		std::vector<RuntimeRenderState>::const_iterator& stateIt,
+		std::vector<ShaderParameterDefinition>::const_iterator& definitionIt);
+
 	std::map<std::string, OscOverlayState> mOscOverlayStates;
 };