OSC fixes

apps/LoopThroughWithOpenGLCompositing/gl/OpenGLComposite.cpp

@@ -8,19 +8,74 @@
 #include "OpenGLShaderPrograms.h"
 #include "OpenGLVideoIOBridge.h"
 #include "PngScreenshotWriter.h"
+#include "RuntimeParameterUtils.h"
 #include "RuntimeServices.h"
 #include "ShaderBuildQueue.h"
 
 #include <algorithm>
+#include <cctype>
 #include <chrono>
 #include <ctime>
 #include <filesystem>
 #include <iomanip>
 #include <memory>
+#include <set>
 #include <sstream>
 #include <string>
 #include <vector>
 
+namespace
+{
+constexpr auto kOscOverlayCommitDelay = std::chrono::milliseconds(150);
+
+std::string SimplifyOscControlKey(const std::string& text)
+{
+	std::string simplified;
+	for (unsigned char ch : text)
+	{
+		if (std::isalnum(ch))
+			simplified.push_back(static_cast<char>(std::tolower(ch)));
+	}
+	return simplified;
+}
+
+bool MatchesOscControlKey(const std::string& candidate, const std::string& key)
+{
+	return candidate == key || SimplifyOscControlKey(candidate) == SimplifyOscControlKey(key);
+}
+
+double ClampOscAlpha(double value)
+{
+	return (std::max)(0.0, (std::min)(1.0, value));
+}
+
+JsonValue BuildOscCommitValue(const ShaderParameterDefinition& definition, const ShaderParameterValue& value)
+{
+	switch (definition.type)
+	{
+	case ShaderParameterType::Boolean:
+		return JsonValue(value.booleanValue);
+	case ShaderParameterType::Enum:
+		return JsonValue(value.enumValue);
+	case ShaderParameterType::Text:
+		return JsonValue(value.textValue);
+	case ShaderParameterType::Trigger:
+	case ShaderParameterType::Float:
+		return JsonValue(value.numberValues.empty() ? 0.0 : value.numberValues.front());
+	case ShaderParameterType::Vec2:
+	case ShaderParameterType::Color:
+	{
+		JsonValue array = JsonValue::MakeArray();
+		for (double number : value.numberValues)
+			array.pushBack(JsonValue(number));
+		return array;
+	}
+	}
+
+	return JsonValue();
+}
+}
+
 OpenGLComposite::OpenGLComposite(HWND hWnd, HDC hDC, HGLRC hRC) :
 	hGLWnd(hWnd), hGLDC(hDC), hGLRC(hRC),
 	mVideoIO(std::make_unique<DeckLinkSession>()),
@@ -322,12 +377,158 @@ bool OpenGLComposite::RequestScreenshot(std::string& error)
 void OpenGLComposite::renderEffect()
 {
 	ProcessRuntimePollResults();
+	std::vector<RuntimeServices::AppliedOscUpdate> appliedOscUpdates;
+	if (mRuntimeHost && mRuntimeServices)
+	{
+		std::string oscError;
+		if (!mRuntimeServices->ApplyPendingOscUpdates(appliedOscUpdates, oscError) && !oscError.empty())
+			OutputDebugStringA(("OSC apply failed: " + oscError + "\n").c_str());
+	}
+
+	std::set<std::string> pendingOscRouteKeys;
+	const auto oscNow = std::chrono::steady_clock::now();
+	for (const RuntimeServices::AppliedOscUpdate& update : appliedOscUpdates)
+	{
+		const std::string routeKey = update.layerKey + "\n" + update.parameterKey;
+		auto overlayIt = mOscOverlayStates.find(routeKey);
+		if (overlayIt == mOscOverlayStates.end())
+		{
+			OscOverlayState overlay;
+			overlay.layerKey = update.layerKey;
+			overlay.parameterKey = update.parameterKey;
+			overlay.targetValue = update.targetValue;
+			overlay.lastUpdatedTime = oscNow;
+			mOscOverlayStates[routeKey] = std::move(overlay);
+		}
+		else
+		{
+			overlayIt->second.targetValue = update.targetValue;
+			overlayIt->second.lastUpdatedTime = oscNow;
+		}
+		pendingOscRouteKeys.insert(routeKey);
+	}
+
+	const auto applyOscOverlays = [&](std::vector<RuntimeRenderState>& states, bool allowCommit)
+	{
+		if (states.empty() || mOscOverlayStates.empty() || !mRuntimeHost)
+			return;
+
+		const double smoothing = ClampOscAlpha(mRuntimeHost->GetOscSmoothing());
+		std::vector<std::string> overlayKeysToRemove;
+		for (auto& item : mOscOverlayStates)
+		{
+			OscOverlayState& overlay = item.second;
+			auto 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())
+				continue;
+
+			auto 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);
+				});
+			if (definitionIt == stateIt->parameterDefinitions.end())
+				continue;
+
+			if (definitionIt->type == ShaderParameterType::Trigger)
+			{
+				if (pendingOscRouteKeys.find(item.first) == pendingOscRouteKeys.end())
+					continue;
+
+				ShaderParameterValue& value = stateIt->parameterValues[definitionIt->id];
+				const double previousCount = value.numberValues.empty() ? 0.0 : value.numberValues[0];
+				const double triggerTime = stateIt->timeSeconds;
+				value.numberValues = { previousCount + 1.0, triggerTime };
+				overlayKeysToRemove.push_back(item.first);
+				continue;
+			}
+
+			ShaderParameterValue targetValue;
+			std::string normalizeError;
+			if (!NormalizeAndValidateParameterValue(*definitionIt, overlay.targetValue, targetValue, normalizeError))
+				continue;
+
+			const bool smoothable =
+				smoothing > 0.0 &&
+				(definitionIt->type == ShaderParameterType::Float ||
+					definitionIt->type == ShaderParameterType::Vec2 ||
+					definitionIt->type == ShaderParameterType::Color);
+			if (!smoothable)
+			{
+				overlay.currentValue = targetValue;
+				overlay.hasCurrentValue = true;
+				stateIt->parameterValues[definitionIt->id] = overlay.currentValue;
+				if (allowCommit && oscNow - overlay.lastUpdatedTime >= kOscOverlayCommitDelay)
+				{
+					std::string commitError;
+					if (mRuntimeHost->UpdateLayerParameterByControlKey(overlay.layerKey, overlay.parameterKey, overlay.targetValue, false, commitError))
+						overlayKeysToRemove.push_back(item.first);
+				}
+				continue;
+			}
+
+			if (!overlay.hasCurrentValue)
+			{
+				overlay.currentValue = DefaultValueForDefinition(*definitionIt);
+				auto currentIt = stateIt->parameterValues.find(definitionIt->id);
+				if (currentIt != stateIt->parameterValues.end())
+					overlay.currentValue = currentIt->second;
+				overlay.hasCurrentValue = true;
+			}
+
+			if (overlay.currentValue.numberValues.size() != targetValue.numberValues.size())
+				overlay.currentValue.numberValues = targetValue.numberValues;
+
+			ShaderParameterValue nextValue = targetValue;
+			bool converged = true;
+			for (std::size_t index = 0; index < targetValue.numberValues.size(); ++index)
+			{
+				const double currentNumber = overlay.currentValue.numberValues[index];
+				const double targetNumber = targetValue.numberValues[index];
+				const double delta = targetNumber - currentNumber;
+				double nextNumber = currentNumber + delta * smoothing;
+				if (std::fabs(delta) <= 0.0005)
+					nextNumber = targetNumber;
+				else
+					converged = false;
+				nextValue.numberValues[index] = nextNumber;
+			}
+
+			if (converged)
+				nextValue.numberValues = targetValue.numberValues;
+
+			overlay.currentValue = nextValue;
+			overlay.hasCurrentValue = true;
+			stateIt->parameterValues[definitionIt->id] = overlay.currentValue;
+			if (allowCommit && converged && oscNow - overlay.lastUpdatedTime >= kOscOverlayCommitDelay)
+			{
+				std::string commitError;
+				JsonValue committedValue = BuildOscCommitValue(*definitionIt, overlay.currentValue);
+				if (mRuntimeHost->UpdateLayerParameterByControlKey(overlay.layerKey, overlay.parameterKey, committedValue, false, commitError))
+					overlayKeysToRemove.push_back(item.first);
+			}
+		}
+
+		if (allowCommit)
+		{
+			for (const std::string& overlayKey : overlayKeysToRemove)
+				mOscOverlayStates.erase(overlayKey);
+		}
+	};
 
 	const bool hasInputSource = mVideoIO->HasInputSource();
 	std::vector<RuntimeRenderState> layerStates;
 	if (mUseCommittedLayerStates)
 	{
 		layerStates = mShaderPrograms->CommittedLayerStates();
+		applyOscOverlays(layerStates, false);
 		if (mRuntimeHost)
 			mRuntimeHost->RefreshDynamicRenderStateFields(layerStates);
 	}
@@ -336,6 +537,7 @@ void OpenGLComposite::renderEffect()
 		const unsigned renderWidth = mVideoIO->InputFrameWidth();
 		const unsigned renderHeight = mVideoIO->InputFrameHeight();
 		const uint64_t renderStateVersion = mRuntimeHost->GetRenderStateVersion();
+		const uint64_t parameterStateVersion = mRuntimeHost->GetParameterStateVersion();
 		const bool renderStateCacheValid =
 			!mCachedLayerRenderStates.empty() &&
 			mCachedRenderStateVersion == renderStateVersion &&
@@ -344,6 +546,13 @@ void OpenGLComposite::renderEffect()
 
 		if (renderStateCacheValid)
 		{
+			applyOscOverlays(mCachedLayerRenderStates, true);
+			if (mCachedParameterStateVersion != parameterStateVersion &&
+				mRuntimeHost->TryRefreshCachedLayerStates(mCachedLayerRenderStates))
+			{
+				mCachedParameterStateVersion = parameterStateVersion;
+				applyOscOverlays(mCachedLayerRenderStates, true);
+			}
 			layerStates = mCachedLayerRenderStates;
 			mRuntimeHost->RefreshDynamicRenderStateFields(layerStates);
 		}
@@ -353,11 +562,15 @@ void OpenGLComposite::renderEffect()
 			{
 				mCachedLayerRenderStates = layerStates;
 				mCachedRenderStateVersion = renderStateVersion;
+				mCachedParameterStateVersion = parameterStateVersion;
 				mCachedRenderStateWidth = renderWidth;
 				mCachedRenderStateHeight = renderHeight;
+				applyOscOverlays(mCachedLayerRenderStates, true);
+				layerStates = mCachedLayerRenderStates;
 			}
 			else
 			{
+				applyOscOverlays(mCachedLayerRenderStates, true);
 				layerStates = mCachedLayerRenderStates;
 				mRuntimeHost->RefreshDynamicRenderStateFields(layerStates);
 			}

apps/LoopThroughWithOpenGLCompositing/gl/OpenGLComposite.h

@@ -73,6 +73,15 @@ private:
 	bool CheckOpenGLExtensions();
 	void PublishVideoIOStatus(const std::string& statusMessage);
 	using LayerProgram = OpenGLRenderer::LayerProgram;
+	struct OscOverlayState
+	{
+		std::string layerKey;
+		std::string parameterKey;
+		JsonValue targetValue;
+		ShaderParameterValue currentValue;
+		bool hasCurrentValue = false;
+		std::chrono::steady_clock::time_point lastUpdatedTime;
+	};
 
 	HWND									hGLWnd;
 	HDC										hGLDC;
@@ -90,8 +99,10 @@ private:
 	std::unique_ptr<RuntimeServices>		mRuntimeServices;
 	std::vector<RuntimeRenderState>			mCachedLayerRenderStates;
 	uint64_t								mCachedRenderStateVersion = 0;
+	uint64_t								mCachedParameterStateVersion = 0;
 	unsigned								mCachedRenderStateWidth = 0;
 	unsigned								mCachedRenderStateHeight = 0;
+	std::map<std::string, OscOverlayState>	mOscOverlayStates;
 	std::atomic<bool>						mUseCommittedLayerStates;
 	std::atomic<bool>						mScreenshotRequested;
 	std::chrono::steady_clock::time_point	mLastPreviewPresentTime;