Preroll udpate

This reverts commit 98f5cbe309.

CMakeLists.txt

@@ -65,6 +65,8 @@ set(APP_SOURCES
 	"${APP_DIR}/gl/pipeline/OpenGLRenderPipeline.cpp"
 	"${APP_DIR}/gl/pipeline/OpenGLRenderPipeline.h"
 	"${APP_DIR}/gl/pipeline/RenderPassDescriptor.h"
+	"${APP_DIR}/gl/pipeline/ShaderFeedbackBuffers.cpp"
+	"${APP_DIR}/gl/pipeline/ShaderFeedbackBuffers.h"
 	"${APP_DIR}/gl/renderer/OpenGLRenderer.cpp"
 	"${APP_DIR}/gl/renderer/OpenGLRenderer.h"
 	"${APP_DIR}/gl/renderer/RenderTargetPool.cpp"
@@ -347,7 +349,7 @@ install(FILES "${SLANG_LICENSE_FILE}"
 	RENAME "SLANG_LICENSE.txt"
 )
 
-install(FILES "${CMAKE_CURRENT_SOURCE_DIR}/SHADER_CONTRACT.md"
+install(FILES "${CMAKE_CURRENT_SOURCE_DIR}/shaders/SHADER_CONTRACT.md"
 	DESTINATION "."
 )
 

OSC/Test.json

@@ -36,7 +36,7 @@
     "preArgs": "",
     "typeTags": "",
     "decimals": 2,
-    "target": "127.0.0.1:9000",
+    "target": "192.168.1.46:9000",
     "ignoreDefaults": false,
     "bypass": false,
     "onCreate": "",
@@ -53,8 +53,8 @@
         "visible": true,
         "interaction": true,
         "comments": "XY control for Fisheye Reproject pan and tilt.",
-        "width": 420,
-        "height": 420,
+        "width": 460,
+        "height": 250,
         "expand": false,
         "colorText": "auto",
         "colorWidget": "auto",
@@ -70,14 +70,14 @@
         "css": "",
         "pips": true,
         "snap": false,
-        "spring": false,
+        "spring": true,
         "rangeX": {
-          "min": -60,
-          "max": 60
+          "min": -1,
+          "max": 1
         },
         "rangeY": {
-          "min": 45,
-          "max": -45
+          "min": 1,
+          "max": -1
         },
         "logScaleX": false,
         "logScaleY": false,
@@ -94,13 +94,13 @@
         "address": "/VideoShaderToys/fisheye-reproject/xy",
         "preArgs": "",
         "typeTags": "",
-        "decimals": "2f",
-        "target": "127.0.0.1:9000",
+        "decimals": "3f",
+        "target": "192.168.1.46:9000",
         "ignoreDefaults": false,
         "bypass": true,
-        "onCreate": "",
-        "onValue": "var pan = Array.isArray(value) ? Number(value[0]) : 0;\nvar tilt = Array.isArray(value) ? Number(value[1]) : 0;\nsend('127.0.0.1:9000', '/VideoShaderToys/fisheye-reproject/panDegrees', {type: 'f', value: pan});\nsend('127.0.0.1:9000', '/VideoShaderToys/fisheye-reproject/tiltDegrees', {type: 'f', value: tilt});",
-        "onTouch": "",
+        "onCreate": "var state = globalThis.__fisheyePanTiltStick = globalThis.__fisheyePanTiltStick || {};\nstate.target = '192.168.1.46:9000';\nstate.panAddress = '/VideoShaderToys/fisheye-reproject/panDegrees';\nstate.tiltAddress = '/VideoShaderToys/fisheye-reproject/tiltDegrees';\nstate.minPan = -60;\nstate.maxPan = 60;\nstate.minTilt = -45;\nstate.maxTilt = 45;\nstate.pan = 0;\nstate.tilt = 0;\nstate.stickX = 0;\nstate.stickY = 0;\nstate.tickMs = 16;\nstate.stepPan = 0.75;\nstate.stepTilt = 0.75;\nstate.deadzone = 0.14;\nstate.applyCurve = function(input) {\n  var amount = Math.abs(input);\n  if (amount <= state.deadzone) {\n    return 0;\n  }\n  var normalized = (amount - state.deadzone) / (1 - state.deadzone);\n  var softened = normalized * normalized * (3 - (2 * normalized));\n  return (input < 0 ? -1 : 1) * softened;\n};\nif (state.timer) {\n  clearInterval(state.timer);\n  state.timer = null;\n}",
+        "onValue": "var state = globalThis.__fisheyePanTiltStick = globalThis.__fisheyePanTiltStick || {};\nvar stickX = Array.isArray(value) ? Number(value[0]) : 0;\nvar stickY = Array.isArray(value) ? Number(value[1]) : 0;\nstate.stickX = isFinite(stickX) ? state.applyCurve(stickX) : 0;\nstate.stickY = isFinite(stickY) ? state.applyCurve(stickY) : 0;",
+        "onTouch": "var state = globalThis.__fisheyePanTiltStick = globalThis.__fisheyePanTiltStick || {};\nif (value) {\n  if (!state.timer) {\n    state.timer = setInterval(function() {\n      if (!state.stickX && !state.stickY) {\n        return;\n      }\n      state.pan = Math.max(state.minPan, Math.min(state.maxPan, state.pan + (state.stickX * state.stepPan)));\n      state.tilt = Math.max(state.minTilt, Math.min(state.maxTilt, state.tilt + (state.stickY * state.stepTilt)));\n      send(state.target, state.panAddress, {type: 'f', value: state.pan});\n      send(state.target, state.tiltAddress, {type: 'f', value: state.tilt});\n    }, state.tickMs);\n  }\n} else {\n  state.stickX = 0;\n  state.stickY = 0;\n  if (state.timer) {\n    clearInterval(state.timer);\n    state.timer = null;\n  }\n}",
         "pointSize": 20,
         "ephemeral": false,
         "label": "",
@@ -121,7 +121,7 @@
         "interaction": true,
         "comments": "",
         "width": 90,
-        "height": 420,
+        "height": 250,
         "expand": false,
         "colorText": "auto",
         "colorWidget": "auto",
@@ -144,90 +144,29 @@
         "gradient": [],
         "snap": false,
         "touchZone": "all",
-        "spring": false,
+        "spring": true,
         "doubleTap": false,
         "range": {
-          "min": 100,
-          "max": 10
+          "min": -1,
+          "max": 1
         },
         "logScale": false,
         "sensitivity": 1,
         "steps": "",
         "origin": "auto",
-        "value": "",
-        "default": 90,
+        "value": 0,
+        "default": 0,
         "linkId": "",
         "address": "/VideoShaderToys/fisheye-reproject/virtualFovDegrees",
         "preArgs": "",
         "typeTags": "",
-        "decimals": 2,
-        "target": "127.0.0.1:9000",
-        "ignoreDefaults": false,
-        "bypass": false,
-        "onCreate": "",
-        "onValue": "",
-        "onTouch": ""
-      },
-      {
-        "type": "xy",
-        "top": 700,
-        "left": 190,
-        "lock": false,
-        "id": "Pan Pad",
-        "visible": true,
-        "interaction": true,
-        "comments": "",
-        "width": "auto",
-        "height": "auto",
-        "expand": false,
-        "colorText": "auto",
-        "colorWidget": "auto",
-        "colorStroke": "auto",
-        "colorFill": "auto",
-        "alphaStroke": "auto",
-        "alphaFillOff": "auto",
-        "alphaFillOn": "auto",
-        "lineWidth": "auto",
-        "borderRadius": "auto",
-        "padding": "auto",
-        "html": "",
-        "css": "",
-        "pointSize": 20,
-        "ephemeral": false,
-        "pips": true,
-        "label": "",
-        "snap": false,
-        "spring": false,
-        "rangeX": {
-          "min": -1,
-          "max": 1
-        },
-        "rangeY": {
-          "min": -1,
-          "max": 1
-        },
-        "logScaleX": false,
-        "logScaleY": false,
-        "stepsX": false,
-        "stepsY": false,
-        "clipX": "",
-        "clipY": "",
-        "axisLock": "",
-        "doubleTap": false,
-        "sensitivity": 1,
-        "value": "",
-        "default": "",
-        "linkId": "",
-        "address": "/VideoShaderToys/video-transform/pan",
-        "preArgs": "",
-        "typeTags": "",
-        "decimals": 2,
-        "target": "",
+        "decimals": "3f",
+        "target": "192.168.1.46:9000",
         "ignoreDefaults": false,
         "bypass": true,
-        "onCreate": "",
-        "onValue": "var x = Array.isArray(value) ? Number(value[0]) : 0;\nvar y = Array.isArray(value) ? Number(value[1]) : 0;\nsend('127.0.0.1:9000', '/VideoShaderToys/video-transform/pan', {type: 'f', value: x}, {type: 'f', value: y});",
-        "onTouch": ""
+        "onCreate": "var state = globalThis.__fisheyeFovStick = globalThis.__fisheyeFovStick || {};\nstate.target = '192.168.1.46:9000';\nstate.address = '/VideoShaderToys/fisheye-reproject/virtualFovDegrees';\nstate.minFov = 10;\nstate.maxFov = 100;\nstate.fov = 90;\nstate.stick = 0;\nstate.tickMs = 16;\nstate.stepFov = 0.6;\nstate.deadzone = 0.14;\nstate.applyCurve = function(input) {\n  var amount = Math.abs(input);\n  if (amount <= state.deadzone) {\n    return 0;\n  }\n  var normalized = (amount - state.deadzone) / (1 - state.deadzone);\n  var softened = normalized * normalized * (3 - (2 * normalized));\n  return (input < 0 ? -1 : 1) * softened;\n};\nif (state.timer) {\n  clearInterval(state.timer);\n  state.timer = null;\n}",
+        "onValue": "var state = globalThis.__fisheyeFovStick = globalThis.__fisheyeFovStick || {};\nvar stick = Number(value);\nstate.stick = isFinite(stick) ? state.applyCurve(stick) : 0;",
+        "onTouch": "var state = globalThis.__fisheyeFovStick = globalThis.__fisheyeFovStick || {};\nif (value) {\n  if (!state.timer) {\n    state.timer = setInterval(function() {\n      if (!state.stick) {\n        return;\n      }\n      state.fov = Math.max(state.minFov, Math.min(state.maxFov, state.fov - (state.stick * state.stepFov)));\n      send(state.target, state.address, {type: 'f', value: state.fov});\n    }, state.tickMs);\n  }\n} else {\n  state.stick = 0;\n  if (state.timer) {\n    clearInterval(state.timer);\n    state.timer = null;\n  }\n}"
       }
     ],
     "tabs": []

README.md

@@ -141,7 +141,9 @@ Current native test coverage includes:
 {
   "shaderLibrary": "shaders",
   "serverPort": 8080,
+  "oscBindAddress": "127.0.0.1",
   "oscPort": 9000,
+  "oscSmoothing": 0.18,
   "inputVideoFormat": "1080p",
   "inputFrameRate": "59.94",
   "outputVideoFormat": "1080p",
@@ -203,13 +205,13 @@ runtime/screenshots/
 
 ## OSC Control
 
-The native host also listens for local OSC parameter control on the configured `oscPort`:
+The native host also listens for OSC parameter control on the configured `oscBindAddress` and `oscPort`:
 
 ```text
 /VideoShaderToys/{LayerNameOrID}/{ParameterNameOrID}
 ```
 
-For example, `/VideoShaderToys/VHS/intensity` updates the `intensity` parameter on the first matching `VHS` layer. The listener accepts float, integer, string, and boolean OSC values, and validates them through the same shader parameter path as the REST API. See `docs/OSC_CONTROL.md` for details.
+For example, `/VideoShaderToys/VHS/intensity` updates the `intensity` parameter on the first matching `VHS` layer. The listener accepts float, integer, string, and boolean OSC values, and validates them through the same shader parameter path as the REST API. OSC updates are coalesced and applied once per render tick, UI state broadcasts are throttled, and OSC-driven parameter changes are not autosaved to `runtime/runtime_state.json`. `oscSmoothing` adds a small per-frame easing amount for numeric OSC controls such as floats, `vec2`, and `color`, while booleans, enums, text, and triggers stay immediate. The default bind address is `127.0.0.1`; set `oscBindAddress` to `0.0.0.0` to accept OSC on all IPv4 interfaces. See `docs/OSC_CONTROL.md` for details.
 
 ## Shader Packages
 
@@ -273,3 +275,6 @@ If `SLANG_ROOT` is not set, the workflow falls back to the repo-local default un
 - compute shaders or a small 1x1 or nx1 RGBA16f render target for arbitrary data storage
 - allow shaders to read other shaders data store based on name? or output over OSC
 - Mipmapping for shader-declared textures
+- Anotate included shaders
+- allow 3 vector exposed controls
+- add nearest sampling to the extra shader pass

apps/LoopThroughWithOpenGLCompositing/LoopThroughWithOpenGLCompositing.cpp

@@ -531,7 +531,7 @@ LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
 				if (!sInteractiveResize && pOpenGLComposite)
 				{
 					wglMakeCurrent(hDC, hRC);
-					pOpenGLComposite->paintGL();
+					pOpenGLComposite->paintGL(true);
 					wglMakeCurrent( NULL, NULL );
 					RaiseStatusControls(sStatusStrip);
 				}

apps/LoopThroughWithOpenGLCompositing/control/ControlServer.cpp

@@ -17,6 +17,7 @@
 namespace
 {
 constexpr DWORD kStateBroadcastIntervalMs = 250;
+constexpr DWORD kStateBroadcastThrottleMs = 50;
 
 bool InitializeWinsock(std::string& error)
 {
@@ -75,7 +76,7 @@ std::string GuessContentType(const std::filesystem::path& assetPath)
 }
 
 ControlServer::ControlServer()
-	: mPort(0), mRunning(false)
+	: mPort(0), mRunning(false), mBroadcastPending(false)
 {
 }
 
@@ -161,10 +162,16 @@ void ControlServer::Stop()
 
 void ControlServer::BroadcastState()
 {
+	mBroadcastPending = false;
 	std::lock_guard<std::mutex> lock(mMutex);
 	BroadcastStateLocked();
 }
 
+void ControlServer::RequestBroadcastState()
+{
+	mBroadcastPending = true;
+}
+
 void ControlServer::ServerLoop()
 {
 	DWORD lastStateBroadcastMs = GetTickCount();
@@ -173,7 +180,12 @@ void ControlServer::ServerLoop()
 		TryAcceptClient();
 
 		const DWORD nowMs = GetTickCount();
-		if (nowMs - lastStateBroadcastMs >= kStateBroadcastIntervalMs)
+		if (mBroadcastPending && nowMs - lastStateBroadcastMs >= kStateBroadcastThrottleMs)
+		{
+			BroadcastState();
+			lastStateBroadcastMs = nowMs;
+		}
+		else if (nowMs - lastStateBroadcastMs >= kStateBroadcastIntervalMs)
 		{
 			BroadcastState();
 			lastStateBroadcastMs = nowMs;
@@ -469,6 +481,7 @@ bool ControlServer::HandleWebSocketUpgrade(UniqueSocket clientSocket, const Http
 		client.socket.reset(clientSocket.release());
 		client.websocket = true;
 		mClients.push_back(std::move(client));
+		mBroadcastPending = false;
 		BroadcastStateLocked();
 	}
 	return true;
@@ -501,6 +514,9 @@ bool ControlServer::SendWebSocketText(SOCKET clientSocket, const std::string& pa
 
 void ControlServer::BroadcastStateLocked()
 {
+	if (mClients.empty())
+		return;
+
 	const std::string stateMessage = mCallbacks.getStateJson ? mCallbacks.getStateJson() : "{}";
 	for (auto it = mClients.begin(); it != mClients.end();)
 	{

apps/LoopThroughWithOpenGLCompositing/control/ControlServer.h

@@ -41,6 +41,7 @@ public:
 	bool Start(const std::filesystem::path& uiRoot, const std::filesystem::path& docsRoot, unsigned short preferredPort, const Callbacks& callbacks, std::string& error);
 	void Stop();
 	void BroadcastState();
+	void RequestBroadcastState();
 
 	unsigned short GetPort() const { return mPort; }
 
@@ -100,6 +101,7 @@ private:
 	unsigned short mPort;
 	std::thread mThread;
 	std::atomic<bool> mRunning;
+	std::atomic<bool> mBroadcastPending;
 	mutable std::mutex mMutex;
 	std::vector<ClientConnection> mClients;
 };

apps/LoopThroughWithOpenGLCompositing/control/OscServer.cpp

@@ -55,7 +55,7 @@ OscServer::~OscServer()
 	Stop();
 }
 
-bool OscServer::Start(unsigned short port, const Callbacks& callbacks, std::string& error)
+bool OscServer::Start(const std::string& bindAddress, unsigned short port, const Callbacks& callbacks, std::string& error)
 {
 	if (port == 0)
 		return true;
@@ -78,11 +78,15 @@ bool OscServer::Start(unsigned short port, const Callbacks& callbacks, std::stri
 
 	sockaddr_in address = {};
 	address.sin_family = AF_INET;
-	address.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
+	if (!TryParseBindAddress(bindAddress, address.sin_addr, error))
+	{
+		mSocket.reset();
+		return false;
+	}
 	address.sin_port = htons(static_cast<u_short>(port));
 	if (bind(mSocket.get(), reinterpret_cast<sockaddr*>(&address), sizeof(address)) != 0)
 	{
-		error = "Could not bind OSC listener to UDP port " + std::to_string(port) + ".";
+		error = "Could not bind OSC listener to " + bindAddress + ":" + std::to_string(port) + ".";
 		mSocket.reset();
 		return false;
 	}
@@ -92,6 +96,24 @@ bool OscServer::Start(unsigned short port, const Callbacks& callbacks, std::stri
 	return true;
 }
 
+bool OscServer::TryParseBindAddress(const std::string& bindAddress, in_addr& address, std::string& error)
+{
+	if (bindAddress.empty())
+	{
+		error = "OSC bind address must not be empty.";
+		return false;
+	}
+
+	address = {};
+	if (InetPtonA(AF_INET, bindAddress.c_str(), &address) != 1)
+	{
+		error = "Invalid OSC bind address '" + bindAddress + "'. Use an IPv4 address such as 127.0.0.1 or 0.0.0.0.";
+		return false;
+	}
+
+	return true;
+}
+
 void OscServer::Stop()
 {
 	mRunning = false;

apps/LoopThroughWithOpenGLCompositing/control/OscServer.h

@@ -20,7 +20,7 @@ public:
 	OscServer();
 	~OscServer();
 
-	bool Start(unsigned short port, const Callbacks& callbacks, std::string& error);
+	bool Start(const std::string& bindAddress, unsigned short port, const Callbacks& callbacks, std::string& error);
 	void Stop();
 
 	unsigned short GetPort() const { return mPort; }
@@ -37,6 +37,7 @@ private:
 	void ServerLoop();
 	bool DecodeMessage(const char* data, int byteCount, OscMessage& message, std::string& error) const;
 	bool DispatchMessage(const OscMessage& message, std::string& error) const;
+	static bool TryParseBindAddress(const std::string& bindAddress, in_addr& address, std::string& error);
 	static bool DecodeArgument(const char* data, int byteCount, int& offset, char valueType, std::string& valueJson);
 	static bool ReadPaddedString(const char* data, int byteCount, int& offset, std::string& value);
 	static bool ReadInt32(const char* data, int byteCount, int& offset, int& value);

apps/LoopThroughWithOpenGLCompositing/control/RuntimeControlBridge.cpp

@@ -4,10 +4,12 @@
 #include "OpenGLComposite.h"
 #include "OscServer.h"
 #include "RuntimeHost.h"
+#include "RuntimeServices.h"
 
 bool StartRuntimeControlServices(
 	OpenGLComposite& composite,
 	RuntimeHost& runtimeHost,
+	RuntimeServices& runtimeServices,
 	ControlServer& controlServer,
 	OscServer& oscServer,
 	std::string& error)
@@ -41,10 +43,10 @@ bool StartRuntimeControlServices(
 	runtimeHost.SetServerPort(controlServer.GetPort());
 
 	OscServer::Callbacks oscCallbacks;
-	oscCallbacks.updateParameter = [&composite](const std::string& layerKey, const std::string& parameterKey, const std::string& valueJson, std::string& actionError) {
-		return composite.UpdateLayerParameterByControlKeyJson(layerKey, parameterKey, valueJson, actionError);
+	oscCallbacks.updateParameter = [&runtimeServices](const std::string& layerKey, const std::string& parameterKey, const std::string& valueJson, std::string& actionError) {
+		return runtimeServices.QueueOscUpdate(layerKey, parameterKey, valueJson, actionError);
 	};
-	if (runtimeHost.GetOscPort() > 0 && !oscServer.Start(runtimeHost.GetOscPort(), oscCallbacks, error))
+	if (runtimeHost.GetOscPort() > 0 && !oscServer.Start(runtimeHost.GetOscBindAddress(), runtimeHost.GetOscPort(), oscCallbacks, error))
 		return false;
 
 	return true;

apps/LoopThroughWithOpenGLCompositing/control/RuntimeControlBridge.h

@@ -6,10 +6,12 @@ class ControlServer;
 class OpenGLComposite;
 class OscServer;
 class RuntimeHost;
+class RuntimeServices;
 
 bool StartRuntimeControlServices(
 	OpenGLComposite& composite,
 	RuntimeHost& runtimeHost,
+	RuntimeServices& runtimeServices,
 	ControlServer& controlServer,
 	OscServer& oscServer,
 	std::string& error);

apps/LoopThroughWithOpenGLCompositing/control/RuntimeServices.cpp

@@ -4,7 +4,6 @@
 #include "OscServer.h"
 #include "RuntimeControlBridge.h"
 #include "RuntimeHost.h"
-
 #include <windows.h>
 
 RuntimeServices::RuntimeServices() :
@@ -26,7 +25,7 @@ bool RuntimeServices::Start(OpenGLComposite& composite, RuntimeHost& runtimeHost
 {
 	Stop();
 
-	if (!StartRuntimeControlServices(composite, runtimeHost, *mControlServer, *mOscServer, error))
+	if (!StartRuntimeControlServices(composite, runtimeHost, *this, *mControlServer, *mOscServer, error))
 	{
 		Stop();
 		return false;
@@ -57,6 +56,108 @@ void RuntimeServices::BroadcastState()
 		mControlServer->BroadcastState();
 }
 
+void RuntimeServices::RequestBroadcastState()
+{
+	if (mControlServer)
+		mControlServer->RequestBroadcastState();
+}
+
+bool RuntimeServices::QueueOscUpdate(const std::string& layerKey, const std::string& parameterKey, const std::string& valueJson, std::string& error)
+{
+	(void)error;
+
+	PendingOscUpdate update;
+	update.layerKey = layerKey;
+	update.parameterKey = parameterKey;
+	update.valueJson = valueJson;
+
+	const std::string routeKey = layerKey + "\n" + parameterKey;
+	{
+		std::lock_guard<std::mutex> lock(mPendingOscMutex);
+		mPendingOscUpdates[routeKey] = std::move(update);
+	}
+	return true;
+}
+
+bool RuntimeServices::ApplyPendingOscUpdates(std::vector<AppliedOscUpdate>& appliedUpdates, std::string& error)
+{
+	appliedUpdates.clear();
+
+	std::map<std::string, PendingOscUpdate> pending;
+	{
+		std::lock_guard<std::mutex> lock(mPendingOscMutex);
+		if (mPendingOscUpdates.empty())
+			return true;
+		pending.swap(mPendingOscUpdates);
+	}
+
+	for (const auto& entry : pending)
+	{
+		JsonValue targetValue;
+		std::string parseError;
+		if (!ParseJson(entry.second.valueJson, targetValue, parseError))
+		{
+			OutputDebugStringA(("OSC queued value parse failed: " + parseError + "\n").c_str());
+			continue;
+		}
+
+		AppliedOscUpdate appliedUpdate;
+		appliedUpdate.routeKey = entry.first;
+		appliedUpdate.layerKey = entry.second.layerKey;
+		appliedUpdate.parameterKey = entry.second.parameterKey;
+		appliedUpdate.targetValue = targetValue;
+		appliedUpdates.push_back(std::move(appliedUpdate));
+	}
+
+	(void)error;
+	return true;
+}
+
+bool RuntimeServices::QueueOscCommit(const std::string& routeKey, const std::string& layerKey, const std::string& parameterKey, const JsonValue& value, uint64_t generation, std::string& error)
+{
+	(void)error;
+
+	PendingOscCommit commit;
+	commit.routeKey = routeKey;
+	commit.layerKey = layerKey;
+	commit.parameterKey = parameterKey;
+	commit.value = value;
+	commit.generation = generation;
+
+	{
+		std::lock_guard<std::mutex> lock(mPendingOscCommitMutex);
+		mPendingOscCommits[routeKey] = std::move(commit);
+	}
+	return true;
+}
+
+void RuntimeServices::ClearOscState()
+{
+	{
+		std::lock_guard<std::mutex> lock(mPendingOscMutex);
+		mPendingOscUpdates.clear();
+	}
+	{
+		std::lock_guard<std::mutex> lock(mPendingOscCommitMutex);
+		mPendingOscCommits.clear();
+	}
+	{
+		std::lock_guard<std::mutex> lock(mCompletedOscCommitMutex);
+		mCompletedOscCommits.clear();
+	}
+}
+
+void RuntimeServices::ConsumeCompletedOscCommits(std::vector<CompletedOscCommit>& completedCommits)
+{
+	completedCommits.clear();
+
+	std::lock_guard<std::mutex> lock(mCompletedOscCommitMutex);
+	if (mCompletedOscCommits.empty())
+		return;
+
+	completedCommits.swap(mCompletedOscCommits);
+}
+
 RuntimePollEvents RuntimeServices::ConsumePollEvents()
 {
 	RuntimePollEvents events;
@@ -94,6 +195,33 @@ void RuntimeServices::PollLoop(RuntimeHost& runtimeHost)
 {
 	while (mPollRunning)
 	{
+		std::map<std::string, PendingOscCommit> pendingCommits;
+		{
+			std::lock_guard<std::mutex> lock(mPendingOscCommitMutex);
+			pendingCommits.swap(mPendingOscCommits);
+		}
+		for (const auto& entry : pendingCommits)
+		{
+			std::string commitError;
+			if (runtimeHost.UpdateLayerParameterByControlKey(
+				entry.second.layerKey,
+				entry.second.parameterKey,
+				entry.second.value,
+				false,
+				commitError))
+			{
+				CompletedOscCommit completedCommit;
+				completedCommit.routeKey = entry.second.routeKey;
+				completedCommit.generation = entry.second.generation;
+				std::lock_guard<std::mutex> lock(mCompletedOscCommitMutex);
+				mCompletedOscCommits.push_back(std::move(completedCommit));
+			}
+			else if (!commitError.empty())
+			{
+				OutputDebugStringA(("OSC commit failed: " + commitError + "\n").c_str());
+			}
+		}
+
 		bool registryChanged = false;
 		bool reloadRequested = false;
 		std::string runtimeError;

apps/LoopThroughWithOpenGLCompositing/control/RuntimeServices.h

@@ -1,6 +1,10 @@
 #pragma once
 
+#include "RuntimeJson.h"
+#include "ShaderTypes.h"
+
 #include <atomic>
+#include <map>
 #include <memory>
 #include <mutex>
 #include <string>
@@ -22,6 +26,20 @@ struct RuntimePollEvents
 class RuntimeServices
 {
 public:
+	struct AppliedOscUpdate
+	{
+		std::string routeKey;
+		std::string layerKey;
+		std::string parameterKey;
+		JsonValue targetValue;
+	};
+
+	struct CompletedOscCommit
+	{
+		std::string routeKey;
+		uint64_t generation = 0;
+	};
+
 	RuntimeServices();
 	~RuntimeServices();
 
@@ -29,9 +47,31 @@ public:
 	void BeginPolling(RuntimeHost& runtimeHost);
 	void Stop();
 	void BroadcastState();
+	void RequestBroadcastState();
+	bool QueueOscUpdate(const std::string& layerKey, const std::string& parameterKey, const std::string& valueJson, std::string& error);
+	bool ApplyPendingOscUpdates(std::vector<AppliedOscUpdate>& appliedUpdates, std::string& error);
+	bool QueueOscCommit(const std::string& routeKey, const std::string& layerKey, const std::string& parameterKey, const JsonValue& value, uint64_t generation, std::string& error);
+	void ClearOscState();
+	void ConsumeCompletedOscCommits(std::vector<CompletedOscCommit>& completedCommits);
 	RuntimePollEvents ConsumePollEvents();
 
 private:
+	struct PendingOscUpdate
+	{
+		std::string layerKey;
+		std::string parameterKey;
+		std::string valueJson;
+	};
+
+	struct PendingOscCommit
+	{
+		std::string routeKey;
+		std::string layerKey;
+		std::string parameterKey;
+		JsonValue value;
+		uint64_t generation = 0;
+	};
+
 	void StartPolling(RuntimeHost& runtimeHost);
 	void StopPolling();
 	void PollLoop(RuntimeHost& runtimeHost);
@@ -45,4 +85,10 @@ private:
 	std::atomic<bool> mPollFailed;
 	std::mutex mPollErrorMutex;
 	std::string mPollError;
+	std::mutex mPendingOscMutex;
+	std::map<std::string, PendingOscUpdate> mPendingOscUpdates;
+	std::mutex mPendingOscCommitMutex;
+	std::map<std::string, PendingOscCommit> mPendingOscCommits;
+	std::mutex mCompletedOscCommitMutex;
+	std::vector<CompletedOscCommit> mCompletedOscCommits;
 };

apps/LoopThroughWithOpenGLCompositing/gl/OpenGLComposite.cpp

@@ -8,19 +8,93 @@
 #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 <cmath>
 #include <ctime>
 #include <filesystem>
 #include <iomanip>
 #include <memory>
+#include <set>
 #include <sstream>
 #include <string>
 #include <vector>
 
+namespace
+{
+constexpr auto kOscOverlayCommitDelay = std::chrono::milliseconds(150);
+constexpr double kOscSmoothingReferenceFps = 60.0;
+constexpr double kOscSmoothingMaxStepSeconds = 0.25;
+
+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));
+}
+
+double ComputeTimeBasedOscAlpha(double smoothing, double deltaSeconds)
+{
+	const double clampedSmoothing = ClampOscAlpha(smoothing);
+	if (clampedSmoothing <= 0.0)
+		return 0.0;
+	if (clampedSmoothing >= 1.0)
+		return 1.0;
+
+	const double clampedDeltaSeconds = (std::max)(0.0, (std::min)(kOscSmoothingMaxStepSeconds, deltaSeconds));
+	if (clampedDeltaSeconds <= 0.0)
+		return 0.0;
+
+	const double frameScale = clampedDeltaSeconds * kOscSmoothingReferenceFps;
+	return ClampOscAlpha(1.0 - std::pow(1.0 - clampedSmoothing, frameScale));
+}
+
+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>()),
@@ -35,7 +109,7 @@ OpenGLComposite::OpenGLComposite(HWND hWnd, HDC hDC, HGLRC hRC) :
 		*mRuntimeHost,
 		[this]() { renderEffect(); },
 		[this]() { ProcessScreenshotRequest(); },
-		[this]() { paintGL(); });
+		[this]() { paintGL(false); });
 	mVideoIOBridge = std::make_unique<OpenGLVideoIOBridge>(
 		*mVideoIO,
 		*mRenderer,
@@ -156,8 +230,26 @@ error:
 	return false;
 }
 
-void OpenGLComposite::paintGL()
+void OpenGLComposite::paintGL(bool force)
 {
+	if (!force)
+	{
+		if (IsIconic(hGLWnd))
+			return;
+
+		const unsigned previewFps = mRuntimeHost ? mRuntimeHost->GetPreviewFps() : 30u;
+		if (previewFps == 0)
+			return;
+
+		const auto now = std::chrono::steady_clock::now();
+		const auto minimumInterval = std::chrono::microseconds(1000000 / (previewFps == 0 ? 1u : previewFps));
+		if (mLastPreviewPresentTime != std::chrono::steady_clock::time_point() &&
+			now - mLastPreviewPresentTime < minimumInterval)
+		{
+			return;
+		}
+	}
+
 	if (!TryEnterCriticalSection(&pMutex))
 	{
 		ValidateRect(hGLWnd, NULL);
@@ -165,6 +257,7 @@ void OpenGLComposite::paintGL()
 	}
 
 	mRenderer->PresentToWindow(hGLDC, mVideoIO->OutputFrameWidth(), mVideoIO->OutputFrameHeight());
+	mLastPreviewPresentTime = std::chrono::steady_clock::now();
 	ValidateRect(hGLWnd, NULL);
 	LeaveCriticalSection(&pMutex);
 }
@@ -235,15 +328,6 @@ bool OpenGLComposite::InitOpenGLState()
 		return false;
 	}
 
-	if (!mShaderPrograms->CompileLayerPrograms(mVideoIO->InputFrameWidth(), mVideoIO->InputFrameHeight(), sizeof(compilerErrorMessage), compilerErrorMessage))
-	{
-		MessageBoxA(NULL, compilerErrorMessage, "OpenGL shader failed to load or compile", MB_OK);
-		return false;
-	}
-	mCachedLayerRenderStates = mShaderPrograms->CommittedLayerStates();
-	mUseCommittedLayerStates = false;
-	mShaderPrograms->ResetTemporalHistoryState();
-
 	std::string rendererError;
 	if (!mRenderer->InitializeResources(
 		mVideoIO->InputFrameWidth(),
@@ -258,6 +342,17 @@ bool OpenGLComposite::InitOpenGLState()
 		return false;
 	}
 
+	if (!mShaderPrograms->CompileLayerPrograms(mVideoIO->InputFrameWidth(), mVideoIO->InputFrameHeight(), sizeof(compilerErrorMessage), compilerErrorMessage))
+	{
+		MessageBoxA(NULL, compilerErrorMessage, "OpenGL shader failed to load or compile", MB_OK);
+		return false;
+	}
+	mCachedLayerRenderStates = mShaderPrograms->CommittedLayerStates();
+	mUseCommittedLayerStates = false;
+
+	mShaderPrograms->ResetTemporalHistoryState();
+	mShaderPrograms->ResetShaderFeedbackState();
+
 	broadcastRuntimeState();
 	mRuntimeServices->BeginPolling(*mRuntimeHost);
 	return true;
@@ -281,8 +376,9 @@ bool OpenGLComposite::Stop()
 	return true;
 }
 
-bool OpenGLComposite::ReloadShader()
+bool OpenGLComposite::ReloadShader(bool preserveFeedbackState)
 {
+	mPreserveFeedbackOnNextShaderBuild = preserveFeedbackState;
 	if (mRuntimeHost)
 	{
 		mRuntimeHost->SetCompileStatus(true, "Shader rebuild queued.");
@@ -303,25 +399,243 @@ bool OpenGLComposite::RequestScreenshot(std::string& error)
 void OpenGLComposite::renderEffect()
 {
 	ProcessRuntimePollResults();
+	std::vector<RuntimeServices::AppliedOscUpdate> appliedOscUpdates;
+	std::vector<RuntimeServices::CompletedOscCommit> completedOscCommits;
+	if (mRuntimeHost && mRuntimeServices)
+	{
+		std::string oscError;
+		if (!mRuntimeServices->ApplyPendingOscUpdates(appliedOscUpdates, oscError) && !oscError.empty())
+			OutputDebugStringA(("OSC apply failed: " + oscError + "\n").c_str());
+		mRuntimeServices->ConsumeCompletedOscCommits(completedOscCommits);
+	}
+
+	for (const RuntimeServices::CompletedOscCommit& completedCommit : completedOscCommits)
+	{
+		auto overlayIt = mOscOverlayStates.find(completedCommit.routeKey);
+		if (overlayIt == mOscOverlayStates.end())
+			continue;
+
+		OscOverlayState& overlay = overlayIt->second;
+		if (overlay.commitQueued &&
+			overlay.pendingCommitGeneration == completedCommit.generation &&
+			overlay.generation == completedCommit.generation)
+		{
+			mOscOverlayStates.erase(overlayIt);
+		}
+	}
+
+	std::set<std::string> pendingOscRouteKeys;
+	const auto oscNow = std::chrono::steady_clock::now();
+	for (const RuntimeServices::AppliedOscUpdate& update : appliedOscUpdates)
+	{
+		const std::string routeKey = update.routeKey;
+		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;
+			overlay.lastAppliedTime = oscNow;
+			overlay.generation = 1;
+			mOscOverlayStates[routeKey] = std::move(overlay);
+		}
+		else
+		{
+			overlayIt->second.targetValue = update.targetValue;
+			overlayIt->second.lastUpdatedTime = oscNow;
+			overlayIt->second.generation += 1;
+			overlayIt->second.commitQueued = false;
+		}
+		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 &&
+					!overlay.commitQueued &&
+					oscNow - overlay.lastUpdatedTime >= kOscOverlayCommitDelay &&
+					mRuntimeServices)
+				{
+					std::string commitError;
+					if (mRuntimeServices->QueueOscCommit(item.first, overlay.layerKey, overlay.parameterKey, overlay.targetValue, overlay.generation, commitError))
+					{
+						overlay.pendingCommitGeneration = overlay.generation;
+						overlay.commitQueued = true;
+					}
+				}
+				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;
+
+			double smoothingAlpha = smoothing;
+			if (overlay.lastAppliedTime != std::chrono::steady_clock::time_point())
+			{
+				const double deltaSeconds =
+					std::chrono::duration_cast<std::chrono::duration<double>>(oscNow - overlay.lastAppliedTime).count();
+				smoothingAlpha = ComputeTimeBasedOscAlpha(smoothing, deltaSeconds);
+			}
+			overlay.lastAppliedTime = oscNow;
+
+			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 * smoothingAlpha;
+				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 &&
+				!overlay.commitQueued &&
+				oscNow - overlay.lastUpdatedTime >= kOscOverlayCommitDelay &&
+				mRuntimeServices)
+			{
+				std::string commitError;
+				JsonValue committedValue = BuildOscCommitValue(*definitionIt, overlay.currentValue);
+				if (mRuntimeServices->QueueOscCommit(item.first, overlay.layerKey, overlay.parameterKey, committedValue, overlay.generation, commitError))
+				{
+					overlay.pendingCommitGeneration = overlay.generation;
+					overlay.commitQueued = true;
+				}
+			}
+		}
+
+		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);
 	}
 	else if (mRuntimeHost)
 	{
-		if (mRuntimeHost->TryGetLayerRenderStates(mVideoIO->InputFrameWidth(), mVideoIO->InputFrameHeight(), layerStates))
+		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 &&
+			mCachedRenderStateWidth == renderWidth &&
+			mCachedRenderStateHeight == renderHeight;
+
+		if (renderStateCacheValid)
 		{
-			mCachedLayerRenderStates = layerStates;
+			applyOscOverlays(mCachedLayerRenderStates, true);
+			if (mCachedParameterStateVersion != parameterStateVersion &&
+				mRuntimeHost->TryRefreshCachedLayerStates(mCachedLayerRenderStates))
+			{
+				mCachedParameterStateVersion = parameterStateVersion;
+				applyOscOverlays(mCachedLayerRenderStates, true);
+			}
+			layerStates = mCachedLayerRenderStates;
+			mRuntimeHost->RefreshDynamicRenderStateFields(layerStates);
 		}
 		else
 		{
-			layerStates = mCachedLayerRenderStates;
-			mRuntimeHost->RefreshDynamicRenderStateFields(layerStates);
+			if (mRuntimeHost->TryGetLayerRenderStates(renderWidth, renderHeight, layerStates))
+			{
+				mCachedLayerRenderStates = layerStates;
+				mCachedRenderStateVersion = renderStateVersion;
+				mCachedParameterStateVersion = parameterStateVersion;
+				mCachedRenderStateWidth = renderWidth;
+				mCachedRenderStateHeight = renderHeight;
+				applyOscOverlays(mCachedLayerRenderStates, true);
+				layerStates = mCachedLayerRenderStates;
+			}
+			else
+			{
+				applyOscOverlays(mCachedLayerRenderStates, true);
+				layerStates = mCachedLayerRenderStates;
+				mRuntimeHost->RefreshDynamicRenderStateFields(layerStates);
+			}
 		}
 	}
 	const unsigned historyCap = mRuntimeHost ? mRuntimeHost->GetMaxTemporalHistoryFrames() : 0;
@@ -336,8 +650,8 @@ void OpenGLComposite::renderEffect()
 		[this](const RuntimeRenderState& state, LayerProgram::TextBinding& textBinding, std::string& error) {
 			return mShaderPrograms->UpdateTextBindingTexture(state, textBinding, error);
 		},
-		[this](const RuntimeRenderState& state, unsigned availableSourceHistoryLength, unsigned availableTemporalHistoryLength) {
-			return mShaderPrograms->UpdateGlobalParamsBuffer(state, availableSourceHistoryLength, availableTemporalHistoryLength);
+		[this](const RuntimeRenderState& state, unsigned availableSourceHistoryLength, unsigned availableTemporalHistoryLength, bool feedbackAvailable) {
+			return mShaderPrograms->UpdateGlobalParamsBuffer(state, availableSourceHistoryLength, availableTemporalHistoryLength, feedbackAvailable);
 		});
 }
 
@@ -431,6 +745,7 @@ bool OpenGLComposite::ProcessRuntimePollResults()
 		{
 			mRuntimeHost->SetCompileStatus(false, compilerErrorMessage);
 			mUseCommittedLayerStates = true;
+			mPreserveFeedbackOnNextShaderBuild = false;
 			broadcastRuntimeState();
 			return false;
 		}
@@ -438,11 +753,15 @@ bool OpenGLComposite::ProcessRuntimePollResults()
 		mUseCommittedLayerStates = false;
 		mCachedLayerRenderStates = mShaderPrograms->CommittedLayerStates();
 		mShaderPrograms->ResetTemporalHistoryState();
+		if (!mPreserveFeedbackOnNextShaderBuild)
+			mShaderPrograms->ResetShaderFeedbackState();
+		mPreserveFeedbackOnNextShaderBuild = false;
 		broadcastRuntimeState();
 		return true;
 	}
 
 	mRuntimeHost->SetCompileStatus(true, "Shader rebuild queued.");
+	mPreserveFeedbackOnNextShaderBuild = false;
 	RequestShaderBuild();
 	broadcastRuntimeState();
 	return true;
@@ -468,6 +787,7 @@ void OpenGLComposite::broadcastRuntimeState()
 void OpenGLComposite::resetTemporalHistoryState()
 {
 	mShaderPrograms->ResetTemporalHistoryState();
+	mShaderPrograms->ResetShaderFeedbackState();
 }
 
 bool OpenGLComposite::CheckOpenGLExtensions()

apps/LoopThroughWithOpenGLCompositing/gl/OpenGLComposite.h

@@ -23,6 +23,7 @@
 #include <string>
 #include <vector>
 #include <deque>
+#include <chrono>
 
 class VideoIODevice;
 class OpenGLVideoIOBridge;
@@ -43,7 +44,7 @@ public:
 	bool InitVideoIO();
 	bool Start();
 	bool Stop();
-	bool ReloadShader();
+	bool ReloadShader(bool preserveFeedbackState = false);
 	std::string GetRuntimeStateJson() const;
 	bool AddLayer(const std::string& shaderId, std::string& error);
 	bool RemoveLayer(const std::string& layerId, std::string& error);
@@ -59,18 +60,32 @@ public:
 	bool RequestScreenshot(std::string& error);
 	unsigned short GetControlServerPort() const;
 	unsigned short GetOscPort() const;
+	std::string GetOscBindAddress() const;
 	std::string GetControlUrl() const;
 	std::string GetDocsUrl() const;
 	std::string GetOscAddress() const;
 
 	void resizeGL(WORD width, WORD height);
-	void paintGL();
+	void paintGL(bool force = false);
 
 private:
 	void resizeWindow(int width, int height);
 	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;
+		std::chrono::steady_clock::time_point lastAppliedTime;
+		uint64_t generation = 0;
+		uint64_t pendingCommitGeneration = 0;
+		bool commitQueued = false;
+	};
 
 	HWND									hGLWnd;
 	HDC										hGLDC;
@@ -87,8 +102,15 @@ private:
 	std::unique_ptr<ShaderBuildQueue>		mShaderBuildQueue;
 	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;
+	bool									mPreserveFeedbackOnNextShaderBuild = false;
 
 	bool InitOpenGLState();
 	void renderEffect();

apps/LoopThroughWithOpenGLCompositing/gl/OpenGLCompositeRuntimeControls.cpp

@@ -1,4 +1,5 @@
 #include "OpenGLComposite.h"
+#include "RuntimeServices.h"
 
 std::string OpenGLComposite::GetRuntimeStateJson() const
 {
@@ -15,6 +16,11 @@ unsigned short OpenGLComposite::GetOscPort() const
 	return mRuntimeHost ? mRuntimeHost->GetOscPort() : 0;
 }
 
+std::string OpenGLComposite::GetOscBindAddress() const
+{
+	return mRuntimeHost ? mRuntimeHost->GetOscBindAddress() : "127.0.0.1";
+}
+
 std::string OpenGLComposite::GetControlUrl() const
 {
 	return "http://127.0.0.1:" + std::to_string(GetControlServerPort()) + "/";
@@ -27,7 +33,7 @@ std::string OpenGLComposite::GetDocsUrl() const
 
 std::string OpenGLComposite::GetOscAddress() const
 {
-	return "udp://127.0.0.1:" + std::to_string(GetOscPort()) + " /VideoShaderToys/{Layer}/{Parameter}";
+	return "udp://" + GetOscBindAddress() + ":" + std::to_string(GetOscPort()) + " /VideoShaderToys/{Layer}/{Parameter}";
 }
 
 bool OpenGLComposite::AddLayer(const std::string& shaderId, std::string& error)
@@ -35,7 +41,7 @@ bool OpenGLComposite::AddLayer(const std::string& shaderId, std::string& error)
 	if (!mRuntimeHost->AddLayer(shaderId, error))
 		return false;
 
-	ReloadShader();
+	ReloadShader(true);
 	broadcastRuntimeState();
 	return true;
 }
@@ -45,7 +51,7 @@ bool OpenGLComposite::RemoveLayer(const std::string& layerId, std::string& error
 	if (!mRuntimeHost->RemoveLayer(layerId, error))
 		return false;
 
-	ReloadShader();
+	ReloadShader(true);
 	broadcastRuntimeState();
 	return true;
 }
@@ -55,7 +61,7 @@ bool OpenGLComposite::MoveLayer(const std::string& layerId, int direction, std::
 	if (!mRuntimeHost->MoveLayer(layerId, direction, error))
 		return false;
 
-	ReloadShader();
+	ReloadShader(true);
 	broadcastRuntimeState();
 	return true;
 }
@@ -65,7 +71,7 @@ bool OpenGLComposite::MoveLayerToIndex(const std::string& layerId, std::size_t t
 	if (!mRuntimeHost->MoveLayerToIndex(layerId, targetIndex, error))
 		return false;
 
-	ReloadShader();
+	ReloadShader(true);
 	broadcastRuntimeState();
 	return true;
 }
@@ -121,6 +127,11 @@ bool OpenGLComposite::ResetLayerParameters(const std::string& layerId, std::stri
 	if (!mRuntimeHost->ResetLayerParameters(layerId, error))
 		return false;
 
+	mOscOverlayStates.clear();
+	if (mRuntimeServices)
+		mRuntimeServices->ClearOscState();
+	resetTemporalHistoryState();
+
 	broadcastRuntimeState();
 	return true;
 }

apps/LoopThroughWithOpenGLCompositing/gl/pipeline/OpenGLRenderPass.cpp

@@ -45,7 +45,7 @@ void OpenGLRenderPass::Render(
 	}
 	else
 	{
-		const std::vector<RenderPassDescriptor> passes = BuildLayerPassDescriptors(layerStates, layerPrograms);
+		const std::vector<RenderPassDescriptor>& passes = BuildLayerPassDescriptors(layerStates, layerPrograms);
 		for (const RenderPassDescriptor& pass : passes)
 		{
 			RenderLayerPass(
@@ -59,6 +59,7 @@ void OpenGLRenderPass::Render(
 	}
 
 	mRenderer.TemporalHistory().PushSourceFramebuffer(mRenderer.DecodeFramebuffer(), inputFrameWidth, inputFrameHeight);
+	mRenderer.FeedbackBuffers().FinalizeFrame();
 }
 
 void OpenGLRenderPass::RenderDecodePass(unsigned inputFrameWidth, unsigned inputFrameHeight, unsigned captureTextureWidth, VideoIOPixelFormat inputPixelFormat)
@@ -71,9 +72,9 @@ void OpenGLRenderPass::RenderDecodePass(unsigned inputFrameWidth, unsigned input
 	glBindVertexArray(mRenderer.FullscreenVertexArray());
 	glUseProgram(mRenderer.DecodeProgram());
 
-	const GLint packedResolutionLocation = glGetUniformLocation(mRenderer.DecodeProgram(), "uPackedVideoResolution");
-	const GLint decodedResolutionLocation = glGetUniformLocation(mRenderer.DecodeProgram(), "uDecodedVideoResolution");
-	const GLint inputPixelFormatLocation = glGetUniformLocation(mRenderer.DecodeProgram(), "uInputPixelFormat");
+	const GLint packedResolutionLocation = mRenderer.DecodePackedResolutionLocation();
+	const GLint decodedResolutionLocation = mRenderer.DecodeDecodedResolutionLocation();
+	const GLint inputPixelFormatLocation = mRenderer.DecodeInputPixelFormatLocation();
 	if (packedResolutionLocation >= 0)
 		glUniform2f(packedResolutionLocation, static_cast<float>(captureTextureWidth), static_cast<float>(inputFrameHeight));
 	if (decodedResolutionLocation >= 0)
@@ -96,7 +97,8 @@ std::vector<RenderPassDescriptor> OpenGLRenderPass::BuildLayerPassDescriptors(
 	// Flatten the layer stack into concrete GL passes. A layer may now contain
 	// several shader passes, but the outer stack still sees one visible output
 	// per layer.
-	std::vector<RenderPassDescriptor> passes;
+	std::vector<RenderPassDescriptor>& passes = mPassScratch;
+	passes.clear();
 	const std::size_t passCount = layerStates.size() < layerPrograms.size() ? layerStates.size() : layerPrograms.size();
 	std::size_t descriptorCount = 0;
 	for (std::size_t index = 0; index < passCount; ++index)
@@ -186,6 +188,7 @@ std::vector<RenderPassDescriptor> OpenGLRenderPass::BuildLayerPassDescriptors(
 			pass.passId = passProgram.passId;
 			pass.layerId = state.layerId;
 			pass.shaderId = state.shaderId;
+			pass.layerInputTexture = layerInputTexture;
 			pass.sourceTexture = passSourceTexture;
 			pass.sourceFramebuffer = passIndex == 0 ? layerInputFramebuffer : passSourceFramebuffer;
 			pass.destinationTexture = passDestinationTexture;
@@ -194,6 +197,7 @@ std::vector<RenderPassDescriptor> OpenGLRenderPass::BuildLayerPassDescriptors(
 			pass.passProgram = &passProgram;
 			pass.layerState = &state;
 			pass.capturePreLayerHistory = passIndex == 0 && state.temporalHistorySource == TemporalHistorySource::PreLayerInput;
+			pass.captureFeedbackWrite = state.feedback.enabled && passProgram.passId == state.feedback.writePassId;
 			passes.push_back(pass);
 
 			// A later pass can reference either the explicit output name or the
@@ -223,6 +227,7 @@ void OpenGLRenderPass::RenderLayerPass(
 		return;
 
 	RenderShaderProgram(
+		pass.layerInputTexture,
 		pass.sourceTexture,
 		pass.destinationFramebuffer,
 		*pass.passProgram,
@@ -235,9 +240,12 @@ void OpenGLRenderPass::RenderLayerPass(
 
 	if (pass.capturePreLayerHistory)
 		mRenderer.TemporalHistory().PushPreLayerFramebuffer(pass.layerId, pass.sourceFramebuffer, inputFrameWidth, inputFrameHeight);
+	if (pass.captureFeedbackWrite)
+		mRenderer.FeedbackBuffers().CaptureFeedbackFramebuffer(pass.layerId, pass.destinationFramebuffer, inputFrameWidth, inputFrameHeight);
 }
 
 void OpenGLRenderPass::RenderShaderProgram(
+	GLuint layerInputTexture,
 	GLuint sourceTexture,
 	GLuint destinationFrameBuffer,
 	PassProgram& passProgram,
@@ -260,14 +268,19 @@ void OpenGLRenderPass::RenderShaderProgram(
 	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 	const std::vector<GLuint> sourceHistoryTextures = mRenderer.TemporalHistory().ResolveSourceHistoryTextures(sourceTexture, state.isTemporal ? historyCap : 0);
 	const std::vector<GLuint> temporalHistoryTextures = mRenderer.TemporalHistory().ResolveTemporalHistoryTextures(state, sourceTexture, state.isTemporal ? historyCap : 0);
+	const GLuint feedbackTexture = mRenderer.FeedbackBuffers().ResolveReadTexture(state);
 	const ShaderTextureBindings::RuntimeTextureBindingPlan texturePlan =
-		mTextureBindings.BuildLayerRuntimeBindingPlan(passProgram, sourceTexture, sourceHistoryTextures, temporalHistoryTextures);
+		mTextureBindings.BuildLayerRuntimeBindingPlan(passProgram, sourceTexture, layerInputTexture, state, feedbackTexture, sourceHistoryTextures, temporalHistoryTextures);
 	mTextureBindings.BindRuntimeTexturePlan(texturePlan);
 	glBindVertexArray(mRenderer.FullscreenVertexArray());
 	glUseProgram(passProgram.program);
 	// The UBO is shared by every pass in a layer; texture routing is what
 	// changes from pass to pass.
-	updateGlobalParams(state, mRenderer.TemporalHistory().SourceAvailableCount(), mRenderer.TemporalHistory().AvailableCountForLayer(state.layerId));
+	updateGlobalParams(
+		state,
+		mRenderer.TemporalHistory().SourceAvailableCount(),
+		mRenderer.TemporalHistory().AvailableCountForLayer(state.layerId),
+		mRenderer.FeedbackBuffers().FeedbackAvailable(state));
 	glDrawArrays(GL_TRIANGLES, 0, 3);
 	glUseProgram(0);
 	glBindVertexArray(0);

apps/LoopThroughWithOpenGLCompositing/gl/pipeline/OpenGLRenderPass.h

@@ -16,7 +16,7 @@ public:
 	using LayerProgram = OpenGLRenderer::LayerProgram;
 	using PassProgram = OpenGLRenderer::LayerProgram::PassProgram;
 	using TextBindingUpdater = std::function<bool(const RuntimeRenderState&, LayerProgram::TextBinding&, std::string&)>;
-	using GlobalParamsUpdater = std::function<bool(const RuntimeRenderState&, unsigned, unsigned)>;
+	using GlobalParamsUpdater = std::function<bool(const RuntimeRenderState&, unsigned, unsigned, bool)>;
 
 	explicit OpenGLRenderPass(OpenGLRenderer& renderer);
 
@@ -44,6 +44,7 @@ private:
 		const TextBindingUpdater& updateTextBinding,
 		const GlobalParamsUpdater& updateGlobalParams);
 	void RenderShaderProgram(
+		GLuint layerInputTexture,
 		GLuint sourceTexture,
 		GLuint destinationFrameBuffer,
 		PassProgram& passProgram,
@@ -56,4 +57,5 @@ private:
 
 	OpenGLRenderer& mRenderer;
 	ShaderTextureBindings mTextureBindings;
+	mutable std::vector<RenderPassDescriptor> mPassScratch;
 };

apps/LoopThroughWithOpenGLCompositing/gl/pipeline/OpenGLRenderPipeline.cpp

@@ -4,6 +4,8 @@
 #include "RuntimeHost.h"
 #include "VideoIOFormat.h"
 
+#include <cstring>
+
 #include <chrono>
 #include <gl/gl.h>
 
@@ -21,6 +23,11 @@ OpenGLRenderPipeline::OpenGLRenderPipeline(
 {
 }
 
+OpenGLRenderPipeline::~OpenGLRenderPipeline()
+{
+	ResetAsyncReadbackState();
+}
+
 bool OpenGLRenderPipeline::RenderFrame(const RenderPipelineFrameContext& context, VideoIOOutputFrame& outputFrame)
 {
 	const VideoIOState& state = context.videoState;
@@ -62,9 +69,9 @@ void OpenGLRenderPipeline::PackOutputFor10Bit(const VideoIOState& state)
 	glBindVertexArray(mRenderer.FullscreenVertexArray());
 	glUseProgram(mRenderer.OutputPackProgram());
 
-	const GLint outputResolutionLocation = glGetUniformLocation(mRenderer.OutputPackProgram(), "uOutputVideoResolution");
-	const GLint activeWordsLocation = glGetUniformLocation(mRenderer.OutputPackProgram(), "uActiveV210Words");
-	const GLint packFormatLocation = glGetUniformLocation(mRenderer.OutputPackProgram(), "uOutputPackFormat");
+	const GLint outputResolutionLocation = mRenderer.OutputPackResolutionLocation();
+	const GLint activeWordsLocation = mRenderer.OutputPackActiveWordsLocation();
+	const GLint packFormatLocation = mRenderer.OutputPackFormatLocation();
 	if (outputResolutionLocation >= 0)
 		glUniform2f(outputResolutionLocation, static_cast<float>(state.outputFrameSize.width), static_cast<float>(state.outputFrameSize.height));
 	if (activeWordsLocation >= 0)
@@ -78,18 +85,195 @@ void OpenGLRenderPipeline::PackOutputFor10Bit(const VideoIOState& state)
 	glBindTexture(GL_TEXTURE_2D, 0);
 }
 
-void OpenGLRenderPipeline::ReadOutputFrame(const VideoIOState& state, VideoIOOutputFrame& outputFrame)
+bool OpenGLRenderPipeline::EnsureAsyncReadbackBuffers(std::size_t requiredBytes)
 {
+	if (requiredBytes == 0)
+		return false;
+
+	if (mAsyncReadbackBytes == requiredBytes && mAsyncReadbackSlots[0].pixelPackBuffer != 0)
+		return true;
+
+	ResetAsyncReadbackState();
+	mAsyncReadbackBytes = requiredBytes;
+	for (AsyncReadbackSlot& slot : mAsyncReadbackSlots)
+	{
+		glGenBuffers(1, &slot.pixelPackBuffer);
+		glBindBuffer(GL_PIXEL_PACK_BUFFER, slot.pixelPackBuffer);
+		glBufferData(GL_PIXEL_PACK_BUFFER, static_cast<GLsizeiptr>(requiredBytes), nullptr, GL_STREAM_READ);
+		slot.sizeBytes = requiredBytes;
+		slot.inFlight = false;
+	}
+	glBindBuffer(GL_PIXEL_PACK_BUFFER, 0);
+	mAsyncReadbackWriteIndex = 0;
+	mAsyncReadbackReadIndex = 0;
+	return true;
+}
+
+void OpenGLRenderPipeline::ResetAsyncReadbackState()
+{
+	FlushAsyncReadbackPipeline();
+	for (AsyncReadbackSlot& slot : mAsyncReadbackSlots)
+		slot.sizeBytes = 0;
+
+	if (mAsyncReadbackSlots[0].pixelPackBuffer != 0)
+	{
+		for (AsyncReadbackSlot& slot : mAsyncReadbackSlots)
+		{
+			if (slot.pixelPackBuffer != 0)
+			{
+				glDeleteBuffers(1, &slot.pixelPackBuffer);
+				slot.pixelPackBuffer = 0;
+			}
+		}
+	}
+
+	mAsyncReadbackWriteIndex = 0;
+	mAsyncReadbackReadIndex = 0;
+	mAsyncReadbackBytes = 0;
+}
+
+void OpenGLRenderPipeline::FlushAsyncReadbackPipeline()
+{
+	for (AsyncReadbackSlot& slot : mAsyncReadbackSlots)
+	{
+		if (slot.fence != nullptr)
+		{
+			glDeleteSync(slot.fence);
+			slot.fence = nullptr;
+		}
+		slot.inFlight = false;
+	}
+
+	mAsyncReadbackWriteIndex = 0;
+	mAsyncReadbackReadIndex = 0;
+}
+
+void OpenGLRenderPipeline::QueueAsyncReadback(const VideoIOState& state)
+{
+	const bool usePackedOutput = state.outputPixelFormat == VideoIOPixelFormat::V210 || state.outputPixelFormat == VideoIOPixelFormat::Yuva10;
+	const std::size_t requiredBytes = static_cast<std::size_t>(state.outputFrameRowBytes) * state.outputFrameSize.height;
+	const GLenum format = usePackedOutput ? GL_RGBA : GL_BGRA;
+	const GLenum type = usePackedOutput ? GL_UNSIGNED_BYTE : GL_UNSIGNED_INT_8_8_8_8_REV;
+	const GLuint framebuffer = usePackedOutput ? mRenderer.OutputPackFramebuffer() : mRenderer.OutputFramebuffer();
+	const GLsizei readWidth = static_cast<GLsizei>(usePackedOutput ? state.outputPackTextureWidth : state.outputFrameSize.width);
+	const GLsizei readHeight = static_cast<GLsizei>(state.outputFrameSize.height);
+
+	if (requiredBytes == 0)
+		return;
+
+	if (mAsyncReadbackBytes != requiredBytes
+		|| mAsyncReadbackFormat != format
+		|| mAsyncReadbackType != type
+		|| mAsyncReadbackFramebuffer != framebuffer)
+	{
+		mAsyncReadbackFormat = format;
+		mAsyncReadbackType = type;
+		mAsyncReadbackFramebuffer = framebuffer;
+		if (!EnsureAsyncReadbackBuffers(requiredBytes))
+			return;
+	}
+
+	AsyncReadbackSlot& slot = mAsyncReadbackSlots[mAsyncReadbackWriteIndex];
+	if (slot.fence != nullptr)
+	{
+		glDeleteSync(slot.fence);
+		slot.fence = nullptr;
+	}
+
 	glPixelStorei(GL_PACK_ALIGNMENT, 4);
 	glPixelStorei(GL_PACK_ROW_LENGTH, 0);
-	if (state.outputPixelFormat == VideoIOPixelFormat::V210 || state.outputPixelFormat == VideoIOPixelFormat::Yuva10)
+	glBindFramebuffer(GL_READ_FRAMEBUFFER, framebuffer);
+	glBindBuffer(GL_PIXEL_PACK_BUFFER, slot.pixelPackBuffer);
+	glBufferData(GL_PIXEL_PACK_BUFFER, static_cast<GLsizeiptr>(requiredBytes), nullptr, GL_STREAM_READ);
+	glReadPixels(0, 0, readWidth, readHeight, format, type, nullptr);
+	slot.fence = glFenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 0);
+	slot.inFlight = slot.fence != nullptr;
+	glBindBuffer(GL_PIXEL_PACK_BUFFER, 0);
+
+	mAsyncReadbackWriteIndex = (mAsyncReadbackWriteIndex + 1) % mAsyncReadbackSlots.size();
+}
+
+bool OpenGLRenderPipeline::TryConsumeAsyncReadback(VideoIOOutputFrame& outputFrame, GLuint64 timeoutNanoseconds)
+{
+	if (mAsyncReadbackBytes == 0 || outputFrame.bytes == nullptr)
+		return false;
+
+	AsyncReadbackSlot& slot = mAsyncReadbackSlots[mAsyncReadbackReadIndex];
+	if (!slot.inFlight || slot.fence == nullptr || slot.pixelPackBuffer == 0)
+		return false;
+
+	const GLenum waitFlags = timeoutNanoseconds > 0 ? GL_SYNC_FLUSH_COMMANDS_BIT : 0;
+	const GLenum waitResult = glClientWaitSync(slot.fence, waitFlags, timeoutNanoseconds);
+	if (waitResult != GL_ALREADY_SIGNALED && waitResult != GL_CONDITION_SATISFIED)
+		return false;
+
+	glDeleteSync(slot.fence);
+	slot.fence = nullptr;
+
+	glBindBuffer(GL_PIXEL_PACK_BUFFER, slot.pixelPackBuffer);
+	void* mappedBytes = glMapBuffer(GL_PIXEL_PACK_BUFFER, GL_READ_ONLY);
+	if (mappedBytes == nullptr)
+	{
+		glBindBuffer(GL_PIXEL_PACK_BUFFER, 0);
+		slot.inFlight = false;
+		mAsyncReadbackReadIndex = (mAsyncReadbackReadIndex + 1) % mAsyncReadbackSlots.size();
+		return false;
+	}
+
+	std::memcpy(outputFrame.bytes, mappedBytes, slot.sizeBytes);
+	glUnmapBuffer(GL_PIXEL_PACK_BUFFER);
+	glBindBuffer(GL_PIXEL_PACK_BUFFER, 0);
+
+	slot.inFlight = false;
+	mAsyncReadbackReadIndex = (mAsyncReadbackReadIndex + 1) % mAsyncReadbackSlots.size();
+	CacheOutputFrame(outputFrame);
+	return true;
+}
+
+void OpenGLRenderPipeline::CacheOutputFrame(const VideoIOOutputFrame& outputFrame)
+{
+	if (outputFrame.bytes == nullptr || outputFrame.height == 0 || outputFrame.rowBytes <= 0)
+		return;
+
+	const std::size_t byteCount = static_cast<std::size_t>(outputFrame.rowBytes) * outputFrame.height;
+	mCachedOutputFrame.resize(byteCount);
+	std::memcpy(mCachedOutputFrame.data(), outputFrame.bytes, byteCount);
+}
+
+void OpenGLRenderPipeline::ReadOutputFrameSynchronously(const VideoIOState& state, void* destinationBytes)
+{
+	const bool usePackedOutput = state.outputPixelFormat == VideoIOPixelFormat::V210 || state.outputPixelFormat == VideoIOPixelFormat::Yuva10;
+
+	glPixelStorei(GL_PACK_ALIGNMENT, 4);
+	glPixelStorei(GL_PACK_ROW_LENGTH, 0);
+	if (usePackedOutput)
 	{
 		glBindFramebuffer(GL_READ_FRAMEBUFFER, mRenderer.OutputPackFramebuffer());
-		glReadPixels(0, 0, state.outputPackTextureWidth, state.outputFrameSize.height, GL_RGBA, GL_UNSIGNED_BYTE, outputFrame.bytes);
+		glReadPixels(0, 0, state.outputPackTextureWidth, state.outputFrameSize.height, GL_RGBA, GL_UNSIGNED_BYTE, destinationBytes);
 	}
 	else
 	{
 		glBindFramebuffer(GL_READ_FRAMEBUFFER, mRenderer.OutputFramebuffer());
-		glReadPixels(0, 0, state.outputFrameSize.width, state.outputFrameSize.height, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, outputFrame.bytes);
+		glReadPixels(0, 0, state.outputFrameSize.width, state.outputFrameSize.height, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, destinationBytes);
 	}
 }
+
+void OpenGLRenderPipeline::ReadOutputFrame(const VideoIOState& state, VideoIOOutputFrame& outputFrame)
+{
+	if (TryConsumeAsyncReadback(outputFrame, 500000))
+	{
+		QueueAsyncReadback(state);
+		return;
+	}
+
+	// If async readback misses the playout deadline, prefer a fresh synchronous
+	// frame over reusing stale cached output, then restart the async pipeline.
+	if (outputFrame.bytes != nullptr)
+	{
+		ReadOutputFrameSynchronously(state, outputFrame.bytes);
+		CacheOutputFrame(outputFrame);
+	}
+
+	FlushAsyncReadbackPipeline();
+	QueueAsyncReadback(state);
+}

apps/LoopThroughWithOpenGLCompositing/gl/pipeline/OpenGLRenderPipeline.h

@@ -1,8 +1,11 @@
 #pragma once
 
+#include "GLExtensions.h"
 #include "VideoIOTypes.h"
 
+#include <array>
 #include <functional>
+#include <vector>
 
 class OpenGLRenderer;
 class RuntimeHost;
@@ -26,10 +29,26 @@ public:
 		RenderEffectCallback renderEffect,
 		OutputReadyCallback outputReady,
 		PaintCallback paint);
+	~OpenGLRenderPipeline();
 
 	bool RenderFrame(const RenderPipelineFrameContext& context, VideoIOOutputFrame& outputFrame);
 
 private:
+	struct AsyncReadbackSlot
+	{
+		GLuint pixelPackBuffer = 0;
+		GLsync fence = nullptr;
+		std::size_t sizeBytes = 0;
+		bool inFlight = false;
+	};
+
+	bool EnsureAsyncReadbackBuffers(std::size_t requiredBytes);
+	void ResetAsyncReadbackState();
+	void FlushAsyncReadbackPipeline();
+	void QueueAsyncReadback(const VideoIOState& state);
+	bool TryConsumeAsyncReadback(VideoIOOutputFrame& outputFrame, GLuint64 timeoutNanoseconds);
+	void CacheOutputFrame(const VideoIOOutputFrame& outputFrame);
+	void ReadOutputFrameSynchronously(const VideoIOState& state, void* destinationBytes);
 	void PackOutputFor10Bit(const VideoIOState& state);
 	void ReadOutputFrame(const VideoIOState& state, VideoIOOutputFrame& outputFrame);
 
@@ -38,4 +57,12 @@ private:
 	RenderEffectCallback mRenderEffect;
 	OutputReadyCallback mOutputReady;
 	PaintCallback mPaint;
+	std::array<AsyncReadbackSlot, 3> mAsyncReadbackSlots;
+	std::size_t mAsyncReadbackWriteIndex = 0;
+	std::size_t mAsyncReadbackReadIndex = 0;
+	std::size_t mAsyncReadbackBytes = 0;
+	GLenum mAsyncReadbackFormat = GL_BGRA;
+	GLenum mAsyncReadbackType = GL_UNSIGNED_INT_8_8_8_8_REV;
+	GLuint mAsyncReadbackFramebuffer = 0;
+	std::vector<unsigned char> mCachedOutputFrame;
 };

apps/LoopThroughWithOpenGLCompositing/gl/pipeline/OpenGLVideoIOBridge.cpp

@@ -65,7 +65,10 @@ void OpenGLVideoIOBridge::VideoFrameArrived(const VideoIOFrame& inputFrame)
 
 	const long textureSize = inputFrame.rowBytes * static_cast<long>(inputFrame.height);
 
-	EnterCriticalSection(&mMutex);
+	// Never let input upload stall the playout/render callback. If the GL bridge
+	// is busy producing an output frame, skip this upload and use the next input.
+	if (!TryEnterCriticalSection(&mMutex))
+		return;
 
 	wglMakeCurrent(mHdc, mHglrc);		// make OpenGL context current in this thread
 
@@ -93,32 +96,29 @@ void OpenGLVideoIOBridge::PlayoutFrameCompleted(const VideoIOCompletion& complet
 {
 	RecordFramePacing(completion.result);
 
-	EnterCriticalSection(&mMutex);
-
 	VideoIOOutputFrame outputFrame;
 	if (!mVideoIO.BeginOutputFrame(outputFrame))
-	{
-		LeaveCriticalSection(&mMutex);
 		return;
-	}
 	const VideoIOState& state = mVideoIO.State();
 	RenderPipelineFrameContext frameContext;
 	frameContext.videoState = state;
 	frameContext.completion = completion;
 
+	EnterCriticalSection(&mMutex);
+
 	// make GL context current in this thread
 	wglMakeCurrent(mHdc, mHglrc);
 
 	mRenderPipeline.RenderFrame(frameContext, outputFrame);
+	wglMakeCurrent(NULL, NULL);
+
+	LeaveCriticalSection(&mMutex);
 
 	mVideoIO.EndOutputFrame(outputFrame);
 
 	mVideoIO.AccountForCompletionResult(completion.result);
 
-	// Schedule the next frame for playout
+	// Schedule the next frame for playout after the GL bridge is released so
+	// input uploads are not blocked by non-GL output bookkeeping.
 	mVideoIO.ScheduleOutputFrame(outputFrame);
-
-	wglMakeCurrent(NULL, NULL);
-
-	LeaveCriticalSection(&mMutex);
 }

apps/LoopThroughWithOpenGLCompositing/gl/pipeline/RenderPassDescriptor.h

@@ -28,6 +28,7 @@ struct RenderPassDescriptor
 	std::string passId;
 	std::string layerId;
 	std::string shaderId;
+	GLuint layerInputTexture = 0;
 	GLuint sourceTexture = 0;
 	GLuint sourceFramebuffer = 0;
 	GLuint destinationTexture = 0;
@@ -36,4 +37,5 @@ struct RenderPassDescriptor
 	OpenGLRenderer::LayerProgram::PassProgram* passProgram = nullptr;
 	const RuntimeRenderState* layerState = nullptr;
 	bool capturePreLayerHistory = false;
+	bool captureFeedbackWrite = false;
 };

apps/LoopThroughWithOpenGLCompositing/gl/pipeline/ShaderFeedbackBuffers.cpp

@@ -0,0 +1,202 @@
+#include "ShaderFeedbackBuffers.h"
+
+#include <set>
+
+namespace
+{
+void ConfigureFeedbackTexture(unsigned frameWidth, unsigned frameHeight)
+{
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA16F, frameWidth, frameHeight, 0, GL_RGBA, GL_FLOAT, NULL);
+}
+}
+
+bool ShaderFeedbackBuffers::EnsureResources(const std::vector<RuntimeRenderState>& layerStates, unsigned frameWidth, unsigned frameHeight, std::string& error)
+{
+	if (!EnsureZeroTexture())
+	{
+		error = "Failed to initialize shader feedback fallback texture.";
+		return false;
+	}
+
+	std::set<std::string> requiredLayerIds;
+	for (const RuntimeRenderState& state : layerStates)
+	{
+		if (!state.feedback.enabled)
+			continue;
+
+		requiredLayerIds.insert(state.layerId);
+		auto surfaceIt = mSurfacesByLayerId.find(state.layerId);
+		if (surfaceIt == mSurfacesByLayerId.end() ||
+			surfaceIt->second.width != frameWidth ||
+			surfaceIt->second.height != frameHeight)
+		{
+			Surface replacement;
+			if (!CreateSurface(replacement, frameWidth, frameHeight, error))
+				return false;
+			mSurfacesByLayerId[state.layerId] = std::move(replacement);
+		}
+	}
+
+	for (auto it = mSurfacesByLayerId.begin(); it != mSurfacesByLayerId.end();)
+	{
+		if (requiredLayerIds.find(it->first) == requiredLayerIds.end())
+		{
+			DestroySurface(it->second);
+			it = mSurfacesByLayerId.erase(it);
+		}
+		else
+		{
+			++it;
+		}
+	}
+
+	return true;
+}
+
+void ShaderFeedbackBuffers::DestroyResources()
+{
+	for (auto& entry : mSurfacesByLayerId)
+		DestroySurface(entry.second);
+	mSurfacesByLayerId.clear();
+
+	if (mZeroTexture != 0)
+	{
+		glDeleteTextures(1, &mZeroTexture);
+		mZeroTexture = 0;
+	}
+}
+
+void ShaderFeedbackBuffers::ResetState()
+{
+	for (auto& entry : mSurfacesByLayerId)
+		ClearSurfaceState(entry.second);
+}
+
+GLuint ShaderFeedbackBuffers::ResolveReadTexture(const RuntimeRenderState& state) const
+{
+	if (!state.feedback.enabled)
+		return mZeroTexture;
+
+	auto surfaceIt = mSurfacesByLayerId.find(state.layerId);
+	if (surfaceIt == mSurfacesByLayerId.end() || !surfaceIt->second.hasData)
+		return mZeroTexture;
+
+	return surfaceIt->second.slots[surfaceIt->second.readIndex].texture != 0
+		? surfaceIt->second.slots[surfaceIt->second.readIndex].texture
+		: mZeroTexture;
+}
+
+bool ShaderFeedbackBuffers::FeedbackAvailable(const RuntimeRenderState& state) const
+{
+	if (!state.feedback.enabled)
+		return false;
+
+	auto surfaceIt = mSurfacesByLayerId.find(state.layerId);
+	return surfaceIt != mSurfacesByLayerId.end() && surfaceIt->second.hasData;
+}
+
+void ShaderFeedbackBuffers::CaptureFeedbackFramebuffer(const std::string& layerId, GLuint sourceFramebuffer, unsigned frameWidth, unsigned frameHeight)
+{
+	auto surfaceIt = mSurfacesByLayerId.find(layerId);
+	if (surfaceIt == mSurfacesByLayerId.end())
+		return;
+
+	Surface& surface = surfaceIt->second;
+	const unsigned writeIndex = 1u - surface.readIndex;
+	glBindFramebuffer(GL_READ_FRAMEBUFFER, sourceFramebuffer);
+	glBindFramebuffer(GL_DRAW_FRAMEBUFFER, surface.slots[writeIndex].framebuffer);
+	glBlitFramebuffer(0, 0, frameWidth, frameHeight, 0, 0, frameWidth, frameHeight, GL_COLOR_BUFFER_BIT, GL_LINEAR);
+	surface.pendingWrite = true;
+}
+
+void ShaderFeedbackBuffers::FinalizeFrame()
+{
+	for (auto& entry : mSurfacesByLayerId)
+	{
+		Surface& surface = entry.second;
+		if (!surface.pendingWrite)
+			continue;
+
+		surface.readIndex = 1u - surface.readIndex;
+		surface.hasData = true;
+		surface.pendingWrite = false;
+	}
+}
+
+bool ShaderFeedbackBuffers::EnsureZeroTexture()
+{
+	if (mZeroTexture != 0)
+		return true;
+
+	glGenTextures(1, &mZeroTexture);
+	glBindTexture(GL_TEXTURE_2D, mZeroTexture);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+	const float zeroPixel[4] = { 0.0f, 0.0f, 0.0f, 0.0f };
+	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA16F, 1, 1, 0, GL_RGBA, GL_FLOAT, zeroPixel);
+	glBindTexture(GL_TEXTURE_2D, 0);
+	return mZeroTexture != 0;
+}
+
+bool ShaderFeedbackBuffers::CreateSurface(Surface& surface, unsigned frameWidth, unsigned frameHeight, std::string& error)
+{
+	DestroySurface(surface);
+
+	surface.width = frameWidth;
+	surface.height = frameHeight;
+	for (Slot& slot : surface.slots)
+	{
+		glGenTextures(1, &slot.texture);
+		glBindTexture(GL_TEXTURE_2D, slot.texture);
+		ConfigureFeedbackTexture(frameWidth, frameHeight);
+
+		glGenFramebuffers(1, &slot.framebuffer);
+		glBindFramebuffer(GL_FRAMEBUFFER, slot.framebuffer);
+		glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, slot.texture, 0);
+		if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
+		{
+			error = "Failed to initialize a shader feedback framebuffer.";
+			glBindFramebuffer(GL_FRAMEBUFFER, 0);
+			glBindTexture(GL_TEXTURE_2D, 0);
+			DestroySurface(surface);
+			return false;
+		}
+	}
+
+	glBindFramebuffer(GL_FRAMEBUFFER, 0);
+	glBindTexture(GL_TEXTURE_2D, 0);
+	ClearSurfaceState(surface);
+	return true;
+}
+
+void ShaderFeedbackBuffers::DestroySurface(Surface& surface)
+{
+	for (Slot& slot : surface.slots)
+	{
+		if (slot.framebuffer != 0)
+			glDeleteFramebuffers(1, &slot.framebuffer);
+		if (slot.texture != 0)
+			glDeleteTextures(1, &slot.texture);
+		slot.framebuffer = 0;
+		slot.texture = 0;
+	}
+
+	surface.width = 0;
+	surface.height = 0;
+	surface.readIndex = 0;
+	surface.hasData = false;
+	surface.pendingWrite = false;
+}
+
+void ShaderFeedbackBuffers::ClearSurfaceState(Surface& surface)
+{
+	surface.readIndex = 0;
+	surface.hasData = false;
+	surface.pendingWrite = false;
+}

apps/LoopThroughWithOpenGLCompositing/gl/pipeline/ShaderFeedbackBuffers.h

@@ -0,0 +1,46 @@
+#pragma once
+
+#include "GLExtensions.h"
+#include "ShaderTypes.h"
+
+#include <map>
+#include <string>
+#include <vector>
+
+class ShaderFeedbackBuffers
+{
+public:
+	struct Slot
+	{
+		GLuint texture = 0;
+		GLuint framebuffer = 0;
+	};
+
+	struct Surface
+	{
+		Slot slots[2];
+		unsigned width = 0;
+		unsigned height = 0;
+		unsigned readIndex = 0;
+		bool hasData = false;
+		bool pendingWrite = false;
+	};
+
+	bool EnsureResources(const std::vector<RuntimeRenderState>& layerStates, unsigned frameWidth, unsigned frameHeight, std::string& error);
+	void DestroyResources();
+	void ResetState();
+	GLuint ResolveReadTexture(const RuntimeRenderState& state) const;
+	bool FeedbackAvailable(const RuntimeRenderState& state) const;
+	void CaptureFeedbackFramebuffer(const std::string& layerId, GLuint sourceFramebuffer, unsigned frameWidth, unsigned frameHeight);
+	void FinalizeFrame();
+
+private:
+	bool EnsureZeroTexture();
+	bool CreateSurface(Surface& surface, unsigned frameWidth, unsigned frameHeight, std::string& error);
+	void DestroySurface(Surface& surface);
+	void ClearSurfaceState(Surface& surface);
+
+private:
+	std::map<std::string, Surface> mSurfacesByLayerId;
+	GLuint mZeroTexture = 0;
+};

apps/LoopThroughWithOpenGLCompositing/gl/pipeline/TemporalHistoryBuffers.cpp

@@ -19,7 +19,8 @@ bool TemporalHistoryBuffers::ValidateTextureUnitBudget(const std::vector<Runtime
 				++textTextureCount;
 		}
 		const unsigned totalShaderTextures = static_cast<unsigned>(state.textureAssets.size()) + textTextureCount;
-		const unsigned layerRequiredUnits = kSourceHistoryTextureUnitBase + (state.isTemporal ? historyCap + historyCap : 0u) + totalShaderTextures;
+		const unsigned feedbackTextureCount = state.feedback.enabled ? 1u : 0u;
+		const unsigned layerRequiredUnits = kSourceHistoryTextureUnitBase + (state.isTemporal ? historyCap + historyCap : 0u) + feedbackTextureCount + totalShaderTextures;
 		if (layerRequiredUnits > requiredUnits)
 			requiredUnits = layerRequiredUnits;
 	}

apps/LoopThroughWithOpenGLCompositing/gl/renderer/GLExtensions.cpp

@@ -62,6 +62,8 @@ PFNGLGENBUFFERSPROC glGenBuffers;
 PFNGLDELETEBUFFERSPROC glDeleteBuffers;
 PFNGLBINDBUFFERPROC glBindBuffer;
 PFNGLBUFFERDATAPROC glBufferData;
+PFNGLMAPBUFFERPROC glMapBuffer;
+PFNGLUNMAPBUFFERPROC glUnmapBuffer;
 PFNGLBUFFERSUBDATAPROC glBufferSubData;
 PFNGLBINDBUFFERBASEPROC glBindBufferBase;
 PFNGLACTIVETEXTUREPROC glActiveTexture;
@@ -131,6 +133,8 @@ bool ResolveGLExtensions()
 	glDeleteBuffers = (PFNGLDELETEBUFFERSPROC) wglGetProcAddress("glDeleteBuffers");
 	glBindBuffer = (PFNGLBINDBUFFERPROC) wglGetProcAddress("glBindBuffer");
 	glBufferData = (PFNGLBUFFERDATAPROC) wglGetProcAddress("glBufferData");
+	glMapBuffer = (PFNGLMAPBUFFERPROC) wglGetProcAddress("glMapBuffer");
+	glUnmapBuffer = (PFNGLUNMAPBUFFERPROC) wglGetProcAddress("glUnmapBuffer");
 	glBufferSubData = (PFNGLBUFFERSUBDATAPROC) wglGetProcAddress("glBufferSubData");
 	glBindBufferBase = (PFNGLBINDBUFFERBASEPROC) wglGetProcAddress("glBindBufferBase");
 	glActiveTexture = (PFNGLACTIVETEXTUREPROC) wglGetProcAddress("glActiveTexture");
@@ -176,6 +180,8 @@ bool ResolveGLExtensions()
 			&& glDeleteBuffers
 			&& glBindBuffer
 			&& glBufferData
+			&& glMapBuffer
+			&& glUnmapBuffer
 			&& glBufferSubData
 			&& glBindBufferBase
 			&& glActiveTexture

apps/LoopThroughWithOpenGLCompositing/gl/renderer/GLExtensions.h

@@ -89,6 +89,11 @@
 #define GL_EXTERNAL_VIRTUAL_MEMORY_BUFFER_AMD	0x9160
 #define GL_SYNC_GPU_COMMANDS_COMPLETE			0x9117
 #define GL_SYNC_FLUSH_COMMANDS_BIT				0x00000001
+#define GL_ALREADY_SIGNALED						0x911A
+#define GL_TIMEOUT_EXPIRED						0x911B
+#define GL_CONDITION_SATISFIED					0x911C
+#define GL_WAIT_FAILED							0x911D
+#define GL_READ_ONLY							0x88B8
 
 typedef struct __GLsync *GLsync;
 typedef unsigned __int64 GLuint64;
@@ -100,6 +105,8 @@ typedef void (APIENTRYP PFNGLBINDBUFFERPROC) (GLenum target, GLuint buffer);
 typedef void (APIENTRYP PFNGLDELETEBUFFERSPROC) (GLsizei n, const GLuint *buffers);
 typedef void (APIENTRYP PFNGLGENBUFFERSPROC) (GLsizei n, GLuint *buffers);
 typedef void (APIENTRYP PFNGLBUFFERDATAPROC) (GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage);
+typedef GLvoid* (APIENTRYP PFNGLMAPBUFFERPROC) (GLenum target, GLenum access);
+typedef GLboolean (APIENTRYP PFNGLUNMAPBUFFERPROC) (GLenum target);
 typedef void (APIENTRYP PFNGLATTACHSHADERPROC) (GLuint program, GLuint shader);
 typedef void (APIENTRYP PFNGLCOMPILESHADERPROC) (GLuint shader);
 typedef GLuint (APIENTRYP PFNGLCREATEPROGRAMPROC) (void);
@@ -159,6 +166,8 @@ extern PFNGLGENBUFFERSPROC glGenBuffers;
 extern PFNGLDELETEBUFFERSPROC glDeleteBuffers;
 extern PFNGLBINDBUFFERPROC glBindBuffer;
 extern PFNGLBUFFERDATAPROC glBufferData;
+extern PFNGLMAPBUFFERPROC glMapBuffer;
+extern PFNGLUNMAPBUFFERPROC glUnmapBuffer;
 extern PFNGLBUFFERSUBDATAPROC glBufferSubData;
 extern PFNGLBINDBUFFERBASEPROC glBindBufferBase;
 extern PFNGLACTIVETEXTUREPROC glActiveTexture;

apps/LoopThroughWithOpenGLCompositing/gl/renderer/GlRenderConstants.h

@@ -2,8 +2,9 @@
 
 #include <gl/gl.h>
 
+constexpr GLuint kLayerInputTextureUnit = 0;
 constexpr GLuint kDecodedVideoTextureUnit = 1;
 constexpr GLuint kSourceHistoryTextureUnitBase = 2;
 constexpr GLuint kPackedVideoTextureUnit = 2;
 constexpr GLuint kGlobalParamsBindingPoint = 0;
-constexpr unsigned kPrerollFrameCount = 8;
+constexpr unsigned kPrerollFrameCount = 12;

apps/LoopThroughWithOpenGLCompositing/gl/renderer/OpenGLRenderer.cpp

@@ -63,6 +63,7 @@ bool OpenGLRenderer::InitializeResources(unsigned inputFrameWidth, unsigned inpu
 	glBindBufferBase(GL_UNIFORM_BUFFER, kGlobalParamsBindingPoint, mGlobalParamsUBO);
 	glBindBuffer(GL_UNIFORM_BUFFER, 0);
 
+	mResourcesInitialized = true;
 	return true;
 }
 
@@ -71,6 +72,9 @@ void OpenGLRenderer::SetDecodeShaderProgram(GLuint program, GLuint vertexShader,
 	mDecodeProgram = program;
 	mDecodeVertexShader = vertexShader;
 	mDecodeFragmentShader = fragmentShader;
+	mDecodePackedResolutionLocation = program != 0 ? glGetUniformLocation(program, "uPackedVideoResolution") : -1;
+	mDecodeDecodedResolutionLocation = program != 0 ? glGetUniformLocation(program, "uDecodedVideoResolution") : -1;
+	mDecodeInputPixelFormatLocation = program != 0 ? glGetUniformLocation(program, "uInputPixelFormat") : -1;
 }
 
 void OpenGLRenderer::SetOutputPackShaderProgram(GLuint program, GLuint vertexShader, GLuint fragmentShader)
@@ -78,6 +82,9 @@ void OpenGLRenderer::SetOutputPackShaderProgram(GLuint program, GLuint vertexSha
 	mOutputPackProgram = program;
 	mOutputPackVertexShader = vertexShader;
 	mOutputPackFragmentShader = fragmentShader;
+	mOutputPackResolutionLocation = program != 0 ? glGetUniformLocation(program, "uOutputVideoResolution") : -1;
+	mOutputPackActiveWordsLocation = program != 0 ? glGetUniformLocation(program, "uActiveV210Words") : -1;
+	mOutputPackFormatLocation = program != 0 ? glGetUniformLocation(program, "uOutputPackFormat") : -1;
 }
 
 bool OpenGLRenderer::ReserveTemporaryRenderTargets(std::size_t count, unsigned width, unsigned height, std::string& error)
@@ -151,8 +158,10 @@ void OpenGLRenderer::DestroyResources()
 	mCaptureTexture = 0;
 	mTextureUploadBuffer = 0;
 	mGlobalParamsUBOSize = 0;
+	mResourcesInitialized = false;
 
 	mTemporalHistory.DestroyResources();
+	mFeedbackBuffers.DestroyResources();
 	DestroyLayerPrograms();
 	DestroyDecodeShaderProgram();
 	DestroyOutputPackShaderProgram();
@@ -217,6 +226,9 @@ void OpenGLRenderer::DestroyDecodeShaderProgram()
 		glDeleteProgram(mDecodeProgram);
 		mDecodeProgram = 0;
 	}
+	mDecodePackedResolutionLocation = -1;
+	mDecodeDecodedResolutionLocation = -1;
+	mDecodeInputPixelFormatLocation = -1;
 
 	if (mDecodeFragmentShader != 0)
 	{
@@ -238,6 +250,9 @@ void OpenGLRenderer::DestroyOutputPackShaderProgram()
 		glDeleteProgram(mOutputPackProgram);
 		mOutputPackProgram = 0;
 	}
+	mOutputPackResolutionLocation = -1;
+	mOutputPackActiveWordsLocation = -1;
+	mOutputPackFormatLocation = -1;
 
 	if (mOutputPackFragmentShader != 0)
 	{

apps/LoopThroughWithOpenGLCompositing/gl/renderer/OpenGLRenderer.h

@@ -2,6 +2,7 @@
 
 #include "GLExtensions.h"
 #include "RenderTargetPool.h"
+#include "ShaderFeedbackBuffers.h"
 #include "ShaderTypes.h"
 #include "TemporalHistoryBuffers.h"
 
@@ -70,8 +71,15 @@ public:
 	GLuint GlobalParamsUBO() const { return mGlobalParamsUBO; }
 	GLuint DecodeProgram() const { return mDecodeProgram; }
 	GLuint OutputPackProgram() const { return mOutputPackProgram; }
+	GLint DecodePackedResolutionLocation() const { return mDecodePackedResolutionLocation; }
+	GLint DecodeDecodedResolutionLocation() const { return mDecodeDecodedResolutionLocation; }
+	GLint DecodeInputPixelFormatLocation() const { return mDecodeInputPixelFormatLocation; }
+	GLint OutputPackResolutionLocation() const { return mOutputPackResolutionLocation; }
+	GLint OutputPackActiveWordsLocation() const { return mOutputPackActiveWordsLocation; }
+	GLint OutputPackFormatLocation() const { return mOutputPackFormatLocation; }
 	GLsizeiptr GlobalParamsUBOSize() const { return mGlobalParamsUBOSize; }
 	void SetGlobalParamsUBOSize(GLsizeiptr size) { mGlobalParamsUBOSize = size; }
+	bool ResourcesInitialized() const { return mResourcesInitialized; }
 	void ReplaceLayerPrograms(std::vector<LayerProgram>& newPrograms) { mLayerPrograms.swap(newPrograms); }
 	std::vector<LayerProgram>& LayerPrograms() { return mLayerPrograms; }
 	const std::vector<LayerProgram>& LayerPrograms() const { return mLayerPrograms; }
@@ -80,6 +88,8 @@ public:
 	std::size_t TemporaryRenderTargetCount() const { return mRenderTargets.TemporaryTargetCount(); }
 	TemporalHistoryBuffers& TemporalHistory() { return mTemporalHistory; }
 	const TemporalHistoryBuffers& TemporalHistory() const { return mTemporalHistory; }
+	ShaderFeedbackBuffers& FeedbackBuffers() { return mFeedbackBuffers; }
+	const ShaderFeedbackBuffers& FeedbackBuffers() const { return mFeedbackBuffers; }
 	void SetDecodeShaderProgram(GLuint program, GLuint vertexShader, GLuint fragmentShader);
 	void SetOutputPackShaderProgram(GLuint program, GLuint vertexShader, GLuint fragmentShader);
 	bool InitializeResources(unsigned inputFrameWidth, unsigned inputFrameHeight, unsigned captureTextureWidth, unsigned outputFrameWidth, unsigned outputFrameHeight, unsigned outputPackTextureWidth, std::string& error);
@@ -101,13 +111,21 @@ private:
 	GLuint mDecodeProgram = 0;
 	GLuint mDecodeVertexShader = 0;
 	GLuint mDecodeFragmentShader = 0;
+	GLint mDecodePackedResolutionLocation = -1;
+	GLint mDecodeDecodedResolutionLocation = -1;
+	GLint mDecodeInputPixelFormatLocation = -1;
 	GLuint mOutputPackProgram = 0;
 	GLuint mOutputPackVertexShader = 0;
 	GLuint mOutputPackFragmentShader = 0;
+	GLint mOutputPackResolutionLocation = -1;
+	GLint mOutputPackActiveWordsLocation = -1;
+	GLint mOutputPackFormatLocation = -1;
 	GLsizeiptr mGlobalParamsUBOSize = 0;
+	bool mResourcesInitialized = false;
 	int mViewWidth = 0;
 	int mViewHeight = 0;
 	std::vector<LayerProgram> mLayerPrograms;
 	RenderTargetPool mRenderTargets;
 	TemporalHistoryBuffers mTemporalHistory;
+	ShaderFeedbackBuffers mFeedbackBuffers;
 };

apps/LoopThroughWithOpenGLCompositing/gl/shader/GlobalParamsBuffer.cpp

@@ -10,9 +10,10 @@ GlobalParamsBuffer::GlobalParamsBuffer(OpenGLRenderer& renderer) :
 {
 }
 
-bool GlobalParamsBuffer::Update(const RuntimeRenderState& state, unsigned availableSourceHistoryLength, unsigned availableTemporalHistoryLength)
+bool GlobalParamsBuffer::Update(const RuntimeRenderState& state, unsigned availableSourceHistoryLength, unsigned availableTemporalHistoryLength, bool feedbackAvailable)
 {
-	std::vector<unsigned char> buffer;
+	std::vector<unsigned char>& buffer = mScratchBuffer;
+	buffer.clear();
 	buffer.reserve(512);
 
 	AppendStd140Float(buffer, static_cast<float>(state.timeSeconds));
@@ -32,6 +33,7 @@ bool GlobalParamsBuffer::Update(const RuntimeRenderState& state, unsigned availa
 		: 0u;
 	AppendStd140Int(buffer, static_cast<int>(effectiveSourceHistoryLength));
 	AppendStd140Int(buffer, static_cast<int>(effectiveTemporalHistoryLength));
+	AppendStd140Int(buffer, feedbackAvailable ? 1 : 0);
 
 	for (const ShaderParameterDefinition& definition : state.parameterDefinitions)
 	{

apps/LoopThroughWithOpenGLCompositing/gl/shader/GlobalParamsBuffer.h

@@ -3,13 +3,16 @@
 #include "OpenGLRenderer.h"
 #include "ShaderTypes.h"
 
+#include <vector>
+
 class GlobalParamsBuffer
 {
 public:
 	explicit GlobalParamsBuffer(OpenGLRenderer& renderer);
 
-	bool Update(const RuntimeRenderState& state, unsigned availableSourceHistoryLength, unsigned availableTemporalHistoryLength);
+	bool Update(const RuntimeRenderState& state, unsigned availableSourceHistoryLength, unsigned availableTemporalHistoryLength, bool feedbackAvailable);
 
 private:
 	OpenGLRenderer& mRenderer;
+	std::vector<unsigned char> mScratchBuffer;
 };

apps/LoopThroughWithOpenGLCompositing/gl/shader/OpenGLShaderPrograms.cpp

@@ -52,6 +52,12 @@ bool OpenGLShaderPrograms::CompileLayerPrograms(unsigned inputFrameWidth, unsign
 		CopyErrorMessage(temporalError, errorMessageSize, errorMessage);
 		return false;
 	}
+	if (mRenderer.ResourcesInitialized() &&
+		!mRenderer.FeedbackBuffers().EnsureResources(layerStates, inputFrameWidth, inputFrameHeight, temporalError))
+	{
+		CopyErrorMessage(temporalError, errorMessageSize, errorMessage);
+		return false;
+	}
 
 	// Initial startup still compiles synchronously; auto-reload uses the build
 	// queue so Slang/file work stays off the playback path.
@@ -109,6 +115,12 @@ bool OpenGLShaderPrograms::CommitPreparedLayerPrograms(const PreparedShaderBuild
 		CopyErrorMessage(temporalError, errorMessageSize, errorMessage);
 		return false;
 	}
+	if (mRenderer.ResourcesInitialized() &&
+		!mRenderer.FeedbackBuffers().EnsureResources(preparedBuild.layerStates, inputFrameWidth, inputFrameHeight, temporalError))
+	{
+		CopyErrorMessage(temporalError, errorMessageSize, errorMessage);
+		return false;
+	}
 
 	// The prepared build already contains GLSL text for each pass. This commit
 	// step performs the short GL work on the render thread.
@@ -176,12 +188,17 @@ void OpenGLShaderPrograms::ResetTemporalHistoryState()
 	mRenderer.TemporalHistory().ResetState();
 }
 
+void OpenGLShaderPrograms::ResetShaderFeedbackState()
+{
+	mRenderer.FeedbackBuffers().ResetState();
+}
+
 bool OpenGLShaderPrograms::UpdateTextBindingTexture(const RuntimeRenderState& state, LayerProgram::TextBinding& textBinding, std::string& error)
 {
 	return mTextureBindings.UpdateTextBindingTexture(state, textBinding, error);
 }
 
-bool OpenGLShaderPrograms::UpdateGlobalParamsBuffer(const RuntimeRenderState& state, unsigned availableSourceHistoryLength, unsigned availableTemporalHistoryLength)
+bool OpenGLShaderPrograms::UpdateGlobalParamsBuffer(const RuntimeRenderState& state, unsigned availableSourceHistoryLength, unsigned availableTemporalHistoryLength, bool feedbackAvailable)
 {
-	return mGlobalParamsBuffer.Update(state, availableSourceHistoryLength, availableTemporalHistoryLength);
+	return mGlobalParamsBuffer.Update(state, availableSourceHistoryLength, availableTemporalHistoryLength, feedbackAvailable);
 }

apps/LoopThroughWithOpenGLCompositing/gl/shader/OpenGLShaderPrograms.h

@@ -25,9 +25,10 @@ public:
 	void DestroySingleLayerProgram(LayerProgram& layerProgram);
 	void DestroyDecodeShaderProgram();
 	void ResetTemporalHistoryState();
+	void ResetShaderFeedbackState();
 	const std::vector<RuntimeRenderState>& CommittedLayerStates() const { return mCommittedLayerStates; }
 	bool UpdateTextBindingTexture(const RuntimeRenderState& state, LayerProgram::TextBinding& textBinding, std::string& error);
-	bool UpdateGlobalParamsBuffer(const RuntimeRenderState& state, unsigned availableSourceHistoryLength, unsigned availableTemporalHistoryLength);
+	bool UpdateGlobalParamsBuffer(const RuntimeRenderState& state, unsigned availableSourceHistoryLength, unsigned availableTemporalHistoryLength, bool feedbackAvailable);
 
 private:
 	OpenGLRenderer& mRenderer;

apps/LoopThroughWithOpenGLCompositing/gl/shader/ShaderTextureBindings.cpp

@@ -103,16 +103,25 @@ GLint ShaderTextureBindings::FindSamplerUniformLocation(GLuint program, const st
 	return glGetUniformLocation(program, (samplerName + "_0").c_str());
 }
 
-GLuint ShaderTextureBindings::ResolveShaderTextureBase(const RuntimeRenderState& state, unsigned historyCap) const
+GLuint ShaderTextureBindings::ResolveFeedbackTextureUnit(const RuntimeRenderState& state, unsigned historyCap) const
 {
 	return state.isTemporal ? kSourceHistoryTextureUnitBase + historyCap + historyCap : kSourceHistoryTextureUnitBase;
 }
 
+GLuint ShaderTextureBindings::ResolveShaderTextureBase(const RuntimeRenderState& state, unsigned historyCap) const
+{
+	return ResolveFeedbackTextureUnit(state, historyCap) + (state.feedback.enabled ? 1u : 0u);
+}
+
 void ShaderTextureBindings::AssignLayerSamplerUniforms(GLuint program, const RuntimeRenderState& state, const PassProgram& passProgram, unsigned historyCap) const
 {
 	const GLuint shaderTextureBase = ResolveShaderTextureBase(state, historyCap);
 
-	const GLint videoInputLocation = glGetUniformLocation(program, "gVideoInput");
+	const GLint layerInputLocation = FindSamplerUniformLocation(program, "gLayerInput");
+	if (layerInputLocation >= 0)
+		glUniform1i(layerInputLocation, static_cast<GLint>(kLayerInputTextureUnit));
+
+	const GLint videoInputLocation = FindSamplerUniformLocation(program, "gVideoInput");
 	if (videoInputLocation >= 0)
 		glUniform1i(videoInputLocation, static_cast<GLint>(kDecodedVideoTextureUnit));
 
@@ -129,6 +138,13 @@ void ShaderTextureBindings::AssignLayerSamplerUniforms(GLuint program, const Run
 			glUniform1i(temporalSamplerLocation, static_cast<GLint>(kSourceHistoryTextureUnitBase + historyCap + index));
 	}
 
+	if (state.feedback.enabled)
+	{
+		const GLint feedbackSamplerLocation = FindSamplerUniformLocation(program, "gFeedbackState");
+		if (feedbackSamplerLocation >= 0)
+			glUniform1i(feedbackSamplerLocation, static_cast<GLint>(ResolveFeedbackTextureUnit(state, historyCap)));
+	}
+
 	for (std::size_t index = 0; index < passProgram.textureBindings.size(); ++index)
 	{
 		const GLint textureSamplerLocation = FindSamplerUniformLocation(program, passProgram.textureBindings[index].samplerName);
@@ -148,10 +164,14 @@ void ShaderTextureBindings::AssignLayerSamplerUniforms(GLuint program, const Run
 ShaderTextureBindings::RuntimeTextureBindingPlan ShaderTextureBindings::BuildLayerRuntimeBindingPlan(
 	const PassProgram& passProgram,
 	GLuint layerInputTexture,
+	GLuint originalLayerInputTexture,
+	const RuntimeRenderState& state,
+	GLuint feedbackTexture,
 	const std::vector<GLuint>& sourceHistoryTextures,
 	const std::vector<GLuint>& temporalHistoryTextures) const
 {
 	RuntimeTextureBindingPlan plan;
+	plan.bindings.push_back({ "originalLayerInput", "gLayerInput", originalLayerInputTexture, kLayerInputTextureUnit });
 	plan.bindings.push_back({ "layerInput", "gVideoInput", layerInputTexture, kDecodedVideoTextureUnit });
 
 	for (std::size_t index = 0; index < sourceHistoryTextures.size(); ++index)
@@ -175,7 +195,20 @@ ShaderTextureBindings::RuntimeTextureBindingPlan ShaderTextureBindings::BuildLay
 		});
 	}
 
-	const GLuint shaderTextureBase = passProgram.shaderTextureBase != 0 ? passProgram.shaderTextureBase : kSourceHistoryTextureUnitBase;
+	const GLuint feedbackTextureUnit = ResolveFeedbackTextureUnit(state, static_cast<unsigned>(sourceHistoryTextures.size()));
+	if (state.feedback.enabled)
+	{
+		plan.bindings.push_back({
+			"feedbackState",
+			"gFeedbackState",
+			feedbackTexture,
+			feedbackTextureUnit
+		});
+	}
+
+	const GLuint shaderTextureBase = passProgram.shaderTextureBase != 0
+		? passProgram.shaderTextureBase
+		: feedbackTextureUnit + (state.feedback.enabled ? 1u : 0u);
 	for (std::size_t index = 0; index < passProgram.textureBindings.size(); ++index)
 	{
 		const LayerProgram::TextureBinding& textureBinding = passProgram.textureBindings[index];

apps/LoopThroughWithOpenGLCompositing/gl/shader/ShaderTextureBindings.h

@@ -29,11 +29,15 @@ public:
 	void CreateTextBindings(const RuntimeRenderState& state, std::vector<LayerProgram::TextBinding>& textBindings);
 	bool UpdateTextBindingTexture(const RuntimeRenderState& state, LayerProgram::TextBinding& textBinding, std::string& error);
 	GLint FindSamplerUniformLocation(GLuint program, const std::string& samplerName) const;
+	GLuint ResolveFeedbackTextureUnit(const RuntimeRenderState& state, unsigned historyCap) const;
 	GLuint ResolveShaderTextureBase(const RuntimeRenderState& state, unsigned historyCap) const;
 	void AssignLayerSamplerUniforms(GLuint program, const RuntimeRenderState& state, const PassProgram& passProgram, unsigned historyCap) const;
 	RuntimeTextureBindingPlan BuildLayerRuntimeBindingPlan(
 		const PassProgram& passProgram,
 		GLuint layerInputTexture,
+		GLuint originalLayerInputTexture,
+		const RuntimeRenderState& state,
+		GLuint feedbackTexture,
 		const std::vector<GLuint>& sourceHistoryTextures,
 		const std::vector<GLuint>& temporalHistoryTextures) const;
 	void BindRuntimeTexturePlan(const RuntimeTextureBindingPlan& plan) const;

apps/LoopThroughWithOpenGLCompositing/runtime/RuntimeHost.cpp

@@ -33,6 +33,11 @@ bool IsFiniteNumber(double value)
 	return std::isfinite(value) != 0;
 }
 
+double Clamp01(double value)
+{
+	return std::max(0.0, std::min(1.0, value));
+}
+
 std::string ToLowerCopy(std::string text)
 {
 	std::transform(text.begin(), text.end(), text.begin(),
@@ -56,6 +61,20 @@ bool MatchesControlKey(const std::string& candidate, const std::string& key)
 	return candidate == key || SimplifyControlKey(candidate) == SimplifyControlKey(key);
 }
 
+bool JsonValueContainsOnlyNumbers(const JsonValue& value)
+{
+	if (!value.isArray())
+		return false;
+
+	for (const JsonValue& item : value.asArray())
+	{
+		if (!item.isNumber() || !IsFiniteNumber(item.asNumber()))
+			return false;
+	}
+
+	return true;
+}
+
 double GenerateStartupRandom()
 {
 	std::random_device randomDevice;
@@ -841,6 +860,8 @@ bool RuntimeHost::PollFileChanges(bool& registryChanged, bool& reloadRequested,
 		}
 
 		reloadRequested = mReloadRequested;
+		if (registryChanged || reloadRequested)
+			MarkRenderStateDirtyLocked();
 		return true;
 	}
 	catch (const std::exception& exception)
@@ -884,6 +905,7 @@ bool RuntimeHost::AddLayer(const std::string& shaderId, std::string& error)
 	EnsureLayerDefaultsLocked(layer, shaderIt->second);
 	mPersistentState.layers.push_back(layer);
 	mReloadRequested = true;
+	MarkRenderStateDirtyLocked();
 	return SavePersistentState(error);
 }
 
@@ -900,6 +922,7 @@ bool RuntimeHost::RemoveLayer(const std::string& layerId, std::string& error)
 
 	mPersistentState.layers.erase(it);
 	mReloadRequested = true;
+	MarkRenderStateDirtyLocked();
 	return SavePersistentState(error);
 }
 
@@ -921,6 +944,7 @@ bool RuntimeHost::MoveLayer(const std::string& layerId, int direction, std::stri
 
 	std::swap(mPersistentState.layers[index], mPersistentState.layers[newIndex]);
 	mReloadRequested = true;
+	MarkRenderStateDirtyLocked();
 	return SavePersistentState(error);
 }
 
@@ -949,6 +973,7 @@ bool RuntimeHost::MoveLayerToIndex(const std::string& layerId, std::size_t targe
 	mPersistentState.layers.erase(mPersistentState.layers.begin() + static_cast<std::ptrdiff_t>(sourceIndex));
 	mPersistentState.layers.insert(mPersistentState.layers.begin() + static_cast<std::ptrdiff_t>(targetIndex), movedLayer);
 	mReloadRequested = true;
+	MarkRenderStateDirtyLocked();
 	return SavePersistentState(error);
 }
 
@@ -964,6 +989,7 @@ bool RuntimeHost::SetLayerBypass(const std::string& layerId, bool bypassed, std:
 
 	layer->bypass = bypassed;
 	mReloadRequested = true;
+	MarkParameterStateDirtyLocked();
 	return SavePersistentState(error);
 }
 
@@ -988,6 +1014,7 @@ bool RuntimeHost::SetLayerShader(const std::string& layerId, const std::string&
 	layer->parameterValues.clear();
 	EnsureLayerDefaultsLocked(*layer, shaderIt->second);
 	mReloadRequested = true;
+	MarkRenderStateDirtyLocked();
 	return SavePersistentState(error);
 }
 
@@ -1024,6 +1051,7 @@ bool RuntimeHost::UpdateLayerParameter(const std::string& layerId, const std::st
 		const double previousCount = value.numberValues.empty() ? 0.0 : value.numberValues[0];
 		const double triggerTime = std::chrono::duration_cast<std::chrono::duration<double>>(std::chrono::steady_clock::now() - mStartTime).count();
 		value.numberValues = { previousCount + 1.0, triggerTime };
+		MarkParameterStateDirtyLocked();
 		return true;
 	}
 
@@ -1032,10 +1060,16 @@ bool RuntimeHost::UpdateLayerParameter(const std::string& layerId, const std::st
 		return false;
 
 	layer->parameterValues[parameterId] = normalized;
+	MarkParameterStateDirtyLocked();
 	return SavePersistentState(error);
 }
 
 bool RuntimeHost::UpdateLayerParameterByControlKey(const std::string& layerKey, const std::string& parameterKey, const JsonValue& newValue, std::string& error)
+{
+	return UpdateLayerParameterByControlKey(layerKey, parameterKey, newValue, true, error);
+}
+
+bool RuntimeHost::UpdateLayerParameterByControlKey(const std::string& layerKey, const std::string& parameterKey, const JsonValue& newValue, bool persistState, std::string& error)
 {
 	std::lock_guard<std::mutex> lock(mMutex);
 
@@ -1079,6 +1113,7 @@ bool RuntimeHost::UpdateLayerParameterByControlKey(const std::string& layerKey,
 		const double previousCount = value.numberValues.empty() ? 0.0 : value.numberValues[0];
 		const double triggerTime = std::chrono::duration_cast<std::chrono::duration<double>>(std::chrono::steady_clock::now() - mStartTime).count();
 		value.numberValues = { previousCount + 1.0, triggerTime };
+		MarkParameterStateDirtyLocked();
 		return true;
 	}
 
@@ -1087,7 +1122,141 @@ bool RuntimeHost::UpdateLayerParameterByControlKey(const std::string& layerKey,
 		return false;
 
 	matchedLayer->parameterValues[parameterIt->id] = normalized;
-	return SavePersistentState(error);
+	MarkParameterStateDirtyLocked();
+	return !persistState || SavePersistentState(error);
+}
+
+bool RuntimeHost::ApplyOscTargetByControlKey(const std::string& layerKey, const std::string& parameterKey, const JsonValue& targetValue, double smoothingAmount, bool& keepApplying, std::string& resolvedLayerId, std::string& resolvedParameterId, ShaderParameterValue& appliedValue, std::string& error)
+{
+	keepApplying = false;
+	resolvedLayerId.clear();
+	resolvedParameterId.clear();
+	appliedValue = ShaderParameterValue();
+
+	std::lock_guard<std::mutex> lock(mMutex);
+
+	LayerPersistentState* matchedLayer = nullptr;
+	const ShaderPackage* matchedPackage = nullptr;
+	for (LayerPersistentState& layer : mPersistentState.layers)
+	{
+		auto shaderIt = mPackagesById.find(layer.shaderId);
+		if (shaderIt == mPackagesById.end())
+			continue;
+
+		if (MatchesControlKey(layer.id, layerKey) || MatchesControlKey(shaderIt->second.id, layerKey) ||
+			MatchesControlKey(shaderIt->second.displayName, layerKey))
+		{
+			matchedLayer = &layer;
+			matchedPackage = &shaderIt->second;
+			break;
+		}
+	}
+
+	if (!matchedLayer || !matchedPackage)
+	{
+		error = "Unknown OSC layer key: " + layerKey;
+		return false;
+	}
+
+	resolvedLayerId = matchedLayer->id;
+
+	const auto parameterIt = std::find_if(matchedPackage->parameters.begin(), matchedPackage->parameters.end(),
+		[&parameterKey](const ShaderParameterDefinition& definition)
+		{
+			return MatchesControlKey(definition.id, parameterKey) || MatchesControlKey(definition.label, parameterKey);
+		});
+	if (parameterIt == matchedPackage->parameters.end())
+	{
+		error = "Unknown OSC parameter key: " + parameterKey;
+		return false;
+	}
+
+	resolvedParameterId = parameterIt->id;
+
+	if (parameterIt->type == ShaderParameterType::Trigger)
+	{
+		ShaderParameterValue& value = matchedLayer->parameterValues[parameterIt->id];
+		const double previousCount = value.numberValues.empty() ? 0.0 : value.numberValues[0];
+		const double triggerTime = std::chrono::duration_cast<std::chrono::duration<double>>(std::chrono::steady_clock::now() - mStartTime).count();
+		value.numberValues = { previousCount + 1.0, triggerTime };
+		MarkParameterStateDirtyLocked();
+		appliedValue = value;
+		return true;
+	}
+
+	ShaderParameterValue normalizedTarget;
+	if (!NormalizeAndValidateValue(*parameterIt, targetValue, normalizedTarget, error))
+		return false;
+
+	const bool smoothableType =
+		parameterIt->type == ShaderParameterType::Float ||
+		parameterIt->type == ShaderParameterType::Vec2 ||
+		parameterIt->type == ShaderParameterType::Color;
+	const bool smoothableInput = targetValue.isNumber() || JsonValueContainsOnlyNumbers(targetValue);
+	const double alpha = Clamp01(smoothingAmount);
+
+	if (!smoothableType || !smoothableInput || alpha <= 0.0)
+	{
+		matchedLayer->parameterValues[parameterIt->id] = normalizedTarget;
+		MarkParameterStateDirtyLocked();
+		appliedValue = normalizedTarget;
+		return true;
+	}
+
+	ShaderParameterValue currentValue = DefaultValueForDefinition(*parameterIt);
+	auto currentIt = matchedLayer->parameterValues.find(parameterIt->id);
+	if (currentIt != matchedLayer->parameterValues.end())
+		currentValue = currentIt->second;
+
+	ShaderParameterValue nextValue = normalizedTarget;
+	nextValue.numberValues = normalizedTarget.numberValues;
+
+	if (currentValue.numberValues.size() != normalizedTarget.numberValues.size())
+		currentValue.numberValues = normalizedTarget.numberValues;
+
+	bool changed = false;
+	bool converged = true;
+	for (std::size_t index = 0; index < normalizedTarget.numberValues.size(); ++index)
+	{
+		const double currentNumber = currentValue.numberValues[index];
+		const double targetNumber = normalizedTarget.numberValues[index];
+		const double delta = targetNumber - currentNumber;
+		double nextNumber = currentNumber + delta * alpha;
+
+		if (std::fabs(delta) <= 0.0005)
+		{
+			nextNumber = targetNumber;
+		}
+		else
+		{
+			converged = false;
+		}
+
+		if (std::fabs(nextNumber - currentNumber) > 0.0000001)
+			changed = true;
+
+		nextValue.numberValues[index] = nextNumber;
+	}
+
+	if (!converged)
+	{
+		keepApplying = true;
+	}
+	else
+	{
+		nextValue.numberValues = normalizedTarget.numberValues;
+	}
+
+	if (!changed && !keepApplying)
+	{
+		appliedValue = matchedLayer->parameterValues[parameterIt->id];
+		return true;
+	}
+
+	matchedLayer->parameterValues[parameterIt->id] = nextValue;
+	MarkParameterStateDirtyLocked();
+	appliedValue = nextValue;
+	return true;
 }
 
 bool RuntimeHost::ResetLayerParameters(const std::string& layerId, std::string& error)
@@ -1110,6 +1279,7 @@ bool RuntimeHost::ResetLayerParameters(const std::string& layerId, std::string&
 
 	layer->parameterValues.clear();
 	EnsureLayerDefaultsLocked(*layer, shaderIt->second);
+	MarkParameterStateDirtyLocked();
 	return SavePersistentState(error);
 }
 
@@ -1169,6 +1339,7 @@ bool RuntimeHost::LoadStackPreset(const std::string& presetName, std::string& er
 
 	mPersistentState.layers = nextLayers;
 	mReloadRequested = true;
+	MarkRenderStateDirtyLocked();
 	return SavePersistentState(error);
 }
 
@@ -1197,10 +1368,27 @@ bool RuntimeHost::TrySetSignalStatus(bool hasSignal, unsigned width, unsigned he
 
 void RuntimeHost::SetSignalStatusLocked(bool hasSignal, unsigned width, unsigned height, const std::string& modeName)
 {
+	const bool changed = mHasSignal != hasSignal ||
+		mSignalWidth != width ||
+		mSignalHeight != height ||
+		mSignalModeName != modeName;
 	mHasSignal = hasSignal;
 	mSignalWidth = width;
 	mSignalHeight = height;
 	mSignalModeName = modeName;
+	if (changed)
+		MarkRenderStateDirtyLocked();
+}
+
+void RuntimeHost::MarkRenderStateDirtyLocked()
+{
+	mRenderStateVersion.fetch_add(1, std::memory_order_relaxed);
+	mParameterStateVersion.fetch_add(1, std::memory_order_relaxed);
+}
+
+void RuntimeHost::MarkParameterStateDirtyLocked()
+{
+	mParameterStateVersion.fetch_add(1, std::memory_order_relaxed);
 }
 
 void RuntimeHost::SetDeckLinkOutputStatus(const std::string& modelName, bool supportsInternalKeying, bool supportsExternalKeying,
@@ -1363,6 +1551,34 @@ bool RuntimeHost::TryGetLayerRenderStates(unsigned outputWidth, unsigned outputH
 	return true;
 }
 
+bool RuntimeHost::TryRefreshCachedLayerStates(std::vector<RuntimeRenderState>& states) const
+{
+	std::unique_lock<std::mutex> lock(mMutex, std::try_to_lock);
+	if (!lock.owns_lock())
+		return false;
+
+	for (RuntimeRenderState& state : states)
+	{
+		const auto layerIt = std::find_if(mPersistentState.layers.begin(), mPersistentState.layers.end(),
+			[&state](const LayerPersistentState& layer) { return layer.id == state.layerId; });
+		if (layerIt == mPersistentState.layers.end())
+			continue;
+
+		state.bypass = layerIt->bypass ? 1.0 : 0.0;
+		state.parameterValues.clear();
+		for (const ShaderParameterDefinition& definition : state.parameterDefinitions)
+		{
+			ShaderParameterValue value = DefaultValueForDefinition(definition);
+			auto valueIt = layerIt->parameterValues.find(definition.id);
+			if (valueIt != layerIt->parameterValues.end())
+				value = valueIt->second;
+			state.parameterValues[definition.id] = value;
+		}
+	}
+
+	return true;
+}
+
 void RuntimeHost::RefreshDynamicRenderStateFields(std::vector<RuntimeRenderState>& states) const
 {
 	const RuntimeClockSnapshot clock = GetRuntimeClockSnapshot();
@@ -1390,6 +1606,7 @@ void RuntimeHost::BuildLayerRenderStatesLocked(unsigned outputWidth, unsigned ou
 		RuntimeRenderState state;
 		state.layerId = layer.id;
 		state.shaderId = layer.shaderId;
+		state.shaderName = shaderIt->second.displayName;
 		state.mixAmount = 1.0;
 		state.bypass = layer.bypass ? 1.0 : 0.0;
 		state.inputWidth = mSignalWidth;
@@ -1403,6 +1620,7 @@ void RuntimeHost::BuildLayerRenderStatesLocked(unsigned outputWidth, unsigned ou
 		state.temporalHistorySource = shaderIt->second.temporal.historySource;
 		state.requestedTemporalHistoryLength = shaderIt->second.temporal.requestedHistoryLength;
 		state.effectiveTemporalHistoryLength = shaderIt->second.temporal.effectiveHistoryLength;
+		state.feedback = shaderIt->second.feedback;
 
 		for (const ShaderParameterDefinition& definition : shaderIt->second.parameters)
 		{
@@ -1449,6 +1667,10 @@ bool RuntimeHost::LoadConfig(std::string& error)
 		mConfig.serverPort = static_cast<unsigned short>(serverPortValue->asNumber(mConfig.serverPort));
 	if (const JsonValue* oscPortValue = configJson.find("oscPort"))
 		mConfig.oscPort = static_cast<unsigned short>(oscPortValue->asNumber(mConfig.oscPort));
+	if (const JsonValue* oscBindAddressValue = configJson.find("oscBindAddress"))
+		mConfig.oscBindAddress = oscBindAddressValue->asString();
+	if (const JsonValue* oscSmoothingValue = configJson.find("oscSmoothing"))
+		mConfig.oscSmoothing = Clamp01(oscSmoothingValue->asNumber(mConfig.oscSmoothing));
 	if (const JsonValue* autoReloadValue = configJson.find("autoReload"))
 		mConfig.autoReload = autoReloadValue->asBoolean(mConfig.autoReload);
 	if (const JsonValue* maxTemporalHistoryFramesValue = configJson.find("maxTemporalHistoryFrames"))
@@ -1456,6 +1678,11 @@ bool RuntimeHost::LoadConfig(std::string& error)
 		const double configuredValue = maxTemporalHistoryFramesValue->asNumber(static_cast<double>(mConfig.maxTemporalHistoryFrames));
 		mConfig.maxTemporalHistoryFrames = configuredValue <= 0.0 ? 0u : static_cast<unsigned>(configuredValue);
 	}
+	if (const JsonValue* previewFpsValue = configJson.find("previewFps"))
+	{
+		const double configuredValue = previewFpsValue->asNumber(static_cast<double>(mConfig.previewFps));
+		mConfig.previewFps = configuredValue <= 0.0 ? 0u : static_cast<unsigned>(configuredValue);
+	}
 	if (const JsonValue* enableExternalKeyingValue = configJson.find("enableExternalKeying"))
 		mConfig.enableExternalKeying = enableExternalKeyingValue->asBoolean(mConfig.enableExternalKeying);
 	if (const JsonValue* videoFormatValue = configJson.find("videoFormat"))
@@ -1674,6 +1901,8 @@ bool RuntimeHost::ScanShaderPackages(std::string& error)
 			++it;
 	}
 
+	MarkRenderStateDirtyLocked();
+
 	return true;
 }
 
@@ -1838,8 +2067,11 @@ JsonValue RuntimeHost::BuildStateValue() const
 	JsonValue app = JsonValue::MakeObject();
 	app.set("serverPort", JsonValue(static_cast<double>(mServerPort)));
 	app.set("oscPort", JsonValue(static_cast<double>(mConfig.oscPort)));
+	app.set("oscBindAddress", JsonValue(mConfig.oscBindAddress));
+	app.set("oscSmoothing", JsonValue(mConfig.oscSmoothing));
 	app.set("autoReload", JsonValue(mAutoReloadEnabled));
 	app.set("maxTemporalHistoryFrames", JsonValue(static_cast<double>(mConfig.maxTemporalHistoryFrames)));
+	app.set("previewFps", JsonValue(static_cast<double>(mConfig.previewFps)));
 	app.set("enableExternalKeying", JsonValue(mConfig.enableExternalKeying));
 	app.set("inputVideoFormat", JsonValue(mConfig.inputVideoFormat));
 	app.set("inputFrameRate", JsonValue(mConfig.inputFrameRate));
@@ -1916,6 +2148,13 @@ JsonValue RuntimeHost::BuildStateValue() const
 			temporal.set("effectiveHistoryLength", JsonValue(static_cast<double>(shaderIt->second.temporal.effectiveHistoryLength)));
 			shader.set("temporal", temporal);
 		}
+		if (status.available && shaderIt != mPackagesById.end() && shaderIt->second.feedback.enabled)
+		{
+			JsonValue feedback = JsonValue::MakeObject();
+			feedback.set("enabled", JsonValue(true));
+			feedback.set("writePass", JsonValue(shaderIt->second.feedback.writePassId));
+			shader.set("feedback", feedback);
+		}
 		shaderLibrary.pushBack(shader);
 	}
 	root.set("shaders", shaderLibrary);
@@ -1953,6 +2192,13 @@ JsonValue RuntimeHost::SerializeLayerStackLocked() const
 			temporal.set("effectiveHistoryLength", JsonValue(static_cast<double>(shaderIt->second.temporal.effectiveHistoryLength)));
 			layerValue.set("temporal", temporal);
 		}
+		if (shaderIt->second.feedback.enabled)
+		{
+			JsonValue feedback = JsonValue::MakeObject();
+			feedback.set("enabled", JsonValue(true));
+			feedback.set("writePass", JsonValue(shaderIt->second.feedback.writePassId));
+			layerValue.set("feedback", feedback);
+		}
 
 		JsonValue parameters = JsonValue::MakeArray();
 		for (const ShaderParameterDefinition& definition : shaderIt->second.parameters)

apps/LoopThroughWithOpenGLCompositing/runtime/RuntimeHost.h

@@ -31,6 +31,8 @@ public:
 	bool SetLayerShader(const std::string& layerId, const std::string& shaderId, std::string& error);
 	bool UpdateLayerParameter(const std::string& layerId, const std::string& parameterId, const JsonValue& newValue, std::string& error);
 	bool UpdateLayerParameterByControlKey(const std::string& layerKey, const std::string& parameterKey, const JsonValue& newValue, std::string& error);
+	bool UpdateLayerParameterByControlKey(const std::string& layerKey, const std::string& parameterKey, const JsonValue& newValue, bool persistState, std::string& error);
+	bool ApplyOscTargetByControlKey(const std::string& layerKey, const std::string& parameterKey, const JsonValue& targetValue, double smoothingAmount, bool& keepApplying, std::string& resolvedLayerId, std::string& resolvedParameterId, ShaderParameterValue& appliedValue, std::string& error);
 	bool ResetLayerParameters(const std::string& layerId, std::string& error);
 	bool SaveStackPreset(const std::string& presetName, std::string& error) const;
 	bool LoadStackPreset(const std::string& presetName, std::string& error);
@@ -54,8 +56,11 @@ public:
 	bool BuildLayerPassFragmentShaderSources(const std::string& layerId, std::vector<ShaderPassBuildSource>& passSources, std::string& error);
 	std::vector<RuntimeRenderState> GetLayerRenderStates(unsigned outputWidth, unsigned outputHeight) const;
 	bool TryGetLayerRenderStates(unsigned outputWidth, unsigned outputHeight, std::vector<RuntimeRenderState>& states) const;
+	bool TryRefreshCachedLayerStates(std::vector<RuntimeRenderState>& states) const;
 	void RefreshDynamicRenderStateFields(std::vector<RuntimeRenderState>& states) const;
 	std::string BuildStateJson() const;
+	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; }
@@ -63,7 +68,10 @@ public:
 	const std::filesystem::path& GetRuntimeRoot() const { return mRuntimeRoot; }
 	unsigned short GetServerPort() const { return mServerPort; }
 	unsigned short GetOscPort() const { return mConfig.oscPort; }
+	const std::string& GetOscBindAddress() const { return mConfig.oscBindAddress; }
+	double GetOscSmoothing() const { return mConfig.oscSmoothing; }
 	unsigned GetMaxTemporalHistoryFrames() const { return mConfig.maxTemporalHistoryFrames; }
+	unsigned GetPreviewFps() const { return mConfig.previewFps; }
 	bool ExternalKeyingEnabled() const { return mConfig.enableExternalKeying; }
 	const std::string& GetInputVideoFormat() const { return mConfig.inputVideoFormat; }
 	const std::string& GetInputFrameRate() const { return mConfig.inputFrameRate; }
@@ -78,8 +86,11 @@ private:
 		std::string shaderLibrary = "shaders";
 		unsigned short serverPort = 8080;
 		unsigned short oscPort = 9000;
+		std::string oscBindAddress = "127.0.0.1";
+		double oscSmoothing = 0.18;
 		bool autoReload = true;
 		unsigned maxTemporalHistoryFrames = 4;
+		unsigned previewFps = 30;
 		bool enableExternalKeying = false;
 		std::string inputVideoFormat = "1080p";
 		std::string inputFrameRate = "59.94";
@@ -135,6 +146,8 @@ private:
 	const LayerPersistentState* FindLayerById(const std::string& layerId) const;
 	std::string GenerateLayerId();
 	void SetSignalStatusLocked(bool hasSignal, unsigned width, unsigned height, const std::string& modeName);
+	void MarkRenderStateDirtyLocked();
+	void MarkParameterStateDirtyLocked();
 	void SetPerformanceStatsLocked(double frameBudgetMilliseconds, double renderMilliseconds);
 	void SetFramePacingStatsLocked(double completionIntervalMilliseconds, double smoothedCompletionIntervalMilliseconds,
 		double maxCompletionIntervalMilliseconds, uint64_t lateFrameCount, uint64_t droppedFrameCount, uint64_t flushedFrameCount);
@@ -179,6 +192,8 @@ private:
 	bool mAutoReloadEnabled;
 	std::chrono::steady_clock::time_point mStartTime;
 	std::chrono::steady_clock::time_point mLastScanTime;
-	std::atomic<uint64_t> mFrameCounter;
+	std::atomic<uint64_t> mFrameCounter{ 0 };
+	std::atomic<uint64_t> mRenderStateVersion{ 0 };
+	std::atomic<uint64_t> mParameterStateVersion{ 0 };
 	uint64_t mNextLayerId;
 };

apps/LoopThroughWithOpenGLCompositing/shader/ShaderCompiler.cpp

@@ -178,6 +178,11 @@ bool ShaderCompiler::BuildWrapperSlangSource(const ShaderPackage& shaderPackage,
 	const unsigned historySamplerCount = shaderPackage.temporal.enabled ? mMaxTemporalHistoryFrames : 0;
 	wrapperSource = ReplaceAll(wrapperSource, "{{SOURCE_HISTORY_SAMPLERS}}", BuildHistorySamplerDeclarations("gSourceHistory", historySamplerCount));
 	wrapperSource = ReplaceAll(wrapperSource, "{{TEMPORAL_HISTORY_SAMPLERS}}", BuildHistorySamplerDeclarations("gTemporalHistory", historySamplerCount));
+	wrapperSource = ReplaceAll(wrapperSource, "{{FEEDBACK_SAMPLER}}", shaderPackage.feedback.enabled ? "Sampler2D<float4> gFeedbackState;\n" : "");
+	wrapperSource = ReplaceAll(wrapperSource, "{{FEEDBACK_HELPER}}",
+		shaderPackage.feedback.enabled
+			? "float4 sampleFeedback(float2 tc)\n{\n\tif (gFeedbackAvailable <= 0)\n\t\treturn float4(0.0, 0.0, 0.0, 0.0);\n\treturn gFeedbackState.Sample(tc);\n}\n"
+			: "float4 sampleFeedback(float2 tc)\n{\n\treturn float4(0.0, 0.0, 0.0, 0.0);\n}\n");
 	wrapperSource = ReplaceAll(wrapperSource, "{{TEXTURE_SAMPLERS}}", BuildTextureSamplerDeclarations(shaderPackage.textureAssets));
 	wrapperSource = ReplaceAll(wrapperSource, "{{TEXT_SAMPLERS}}", BuildTextSamplerDeclarations(shaderPackage.parameters));
 	wrapperSource = ReplaceAll(wrapperSource, "{{TEXT_HELPERS}}", BuildTextHelpers(shaderPackage.parameters));

apps/LoopThroughWithOpenGLCompositing/shader/ShaderPackageRegistry.cpp

@@ -473,6 +473,46 @@ bool ParseTemporalSettings(const JsonValue& manifestJson, ShaderPackage& shaderP
 	return true;
 }
 
+bool ParseFeedbackSettings(const JsonValue& manifestJson, ShaderPackage& shaderPackage, const std::filesystem::path& manifestPath, std::string& error)
+{
+	const JsonValue* feedbackValue = nullptr;
+	if (!OptionalObjectField(manifestJson, "feedback", feedbackValue, manifestPath, error))
+		return false;
+	if (!feedbackValue)
+		return true;
+
+	const JsonValue* enabledValue = feedbackValue->find("enabled");
+	if (!enabledValue || !enabledValue->asBoolean(false))
+		return true;
+
+	shaderPackage.feedback.enabled = true;
+	if (!OptionalStringField(*feedbackValue, "writePass", shaderPackage.feedback.writePassId, "", manifestPath, error))
+		return false;
+
+	if (shaderPackage.feedback.writePassId.empty())
+	{
+		if (shaderPackage.passes.empty())
+		{
+			error = "Feedback-enabled shader has no passes to target in: " + ManifestPathMessage(manifestPath);
+			return false;
+		}
+		shaderPackage.feedback.writePassId = shaderPackage.passes.back().id;
+	}
+
+	if (!ValidateShaderIdentifier(shaderPackage.feedback.writePassId, "feedback.writePass", manifestPath, error))
+		return false;
+
+	const auto passIt = std::find_if(shaderPackage.passes.begin(), shaderPackage.passes.end(),
+		[&shaderPackage](const ShaderPassDefinition& pass) { return pass.id == shaderPackage.feedback.writePassId; });
+	if (passIt == shaderPackage.passes.end())
+	{
+		error = "Feedback writePass '" + shaderPackage.feedback.writePassId + "' does not match any declared pass in: " + ManifestPathMessage(manifestPath);
+		return false;
+	}
+
+	return true;
+}
+
 bool ParseParameterNumberField(const JsonValue& parameterJson, const char* fieldName, std::vector<double>& values, const std::filesystem::path& manifestPath, std::string& error)
 {
 	if (const JsonValue* fieldValue = parameterJson.find(fieldName))
@@ -773,5 +813,6 @@ bool ShaderPackageRegistry::ParseManifest(const std::filesystem::path& manifestP
 	return ParseTextureAssets(manifestJson, shaderPackage, manifestPath, error) &&
 		ParseFontAssets(manifestJson, shaderPackage, manifestPath, error) &&
 		ParseTemporalSettings(manifestJson, shaderPackage, mMaxTemporalHistoryFrames, manifestPath, error) &&
+		ParseFeedbackSettings(manifestJson, shaderPackage, manifestPath, error) &&
 		ParseParameterDefinitions(manifestJson, shaderPackage, manifestPath, error);
 }

apps/LoopThroughWithOpenGLCompositing/shader/ShaderTypes.h

@@ -63,6 +63,12 @@ struct TemporalSettings
 	unsigned effectiveHistoryLength = 0;
 };
 
+struct FeedbackSettings
+{
+	bool enabled = false;
+	std::string writePassId;
+};
+
 struct ShaderTextureAsset
 {
 	std::string id;
@@ -110,6 +116,7 @@ struct ShaderPackage
 	std::vector<ShaderTextureAsset> textureAssets;
 	std::vector<ShaderFontAsset> fontAssets;
 	TemporalSettings temporal;
+	FeedbackSettings feedback;
 	std::filesystem::file_time_type shaderWriteTime;
 	std::filesystem::file_time_type manifestWriteTime;
 };
@@ -128,6 +135,7 @@ struct RuntimeRenderState
 {
 	std::string layerId;
 	std::string shaderId;
+	std::string shaderName;
 	std::vector<ShaderParameterDefinition> parameterDefinitions;
 	std::map<std::string, ShaderParameterValue> parameterValues;
 	std::vector<ShaderTextureAsset> textureAssets;
@@ -147,4 +155,5 @@ struct RuntimeRenderState
 	TemporalHistorySource temporalHistorySource = TemporalHistorySource::None;
 	unsigned requestedTemporalHistoryLength = 0;
 	unsigned effectiveTemporalHistoryLength = 0;
+	FeedbackSettings feedback;
 };

config/runtime-host.json

@@ -1,12 +1,15 @@
 {
   "shaderLibrary": "shaders",
   "serverPort": 8080,
+  "oscBindAddress": "0.0.0.0",
   "oscPort": 9000,
+  "oscSmoothing": 0.18,
   "inputVideoFormat": "1080p",
   "inputFrameRate": "59.94",
   "outputVideoFormat": "1080p",
   "outputFrameRate": "59.94",
   "autoReload": true,
   "maxTemporalHistoryFrames": 12,
+  "previewFps": 30,
   "enableExternalKeying": true
 }

docs/ARCHITECTURE_RESILIENCE_REVIEW.md

@@ -0,0 +1,638 @@
+# Architecture Resilience Review
+
+This note summarizes the main architectural improvements that would make the app more resilient during live use, especially around timing isolation, failure isolation, and recoverability.
+
+Phase checklist:
+
+- [ ] Define subsystem boundaries and target architecture
+- [ ] Introduce an internal event model
+- [ ] Split `RuntimeHost`
+- [ ] Make the render thread the sole GL owner
+- [ ] Refactor live state layering into an explicit composition model
+- [ ] Move persistence onto a background snapshot writer
+- [ ] Make DeckLink/backend lifecycle explicit with a state machine
+- [ ] Add structured health, telemetry, and operational reporting
+
+## Timing Review
+
+The recent OSC work removed several control-path stalls, but the app still has a few deeper timing characteristics that matter for live resilience:
+
+- output playout is still effectively render-on-demand from the DeckLink completion callback
+- output buffering and preroll are now larger, but the buffering model is still static and only loosely related to actual render cost
+- GPU readback is partly asynchronous, but the fallback path still returns to synchronous readback on any miss
+- preview presentation is still tied to the playout render path
+- background service timing still relies on coarse polling sleeps
+
+Those points are important because they affect not just average performance, but how the app behaves under brief spikes, device jitter, or load bursts.
+
+## Key Findings
+
+### 1. `RuntimeHost` is carrying too many responsibilities
+
+`RuntimeHost` currently acts as:
+
+- config store
+- persistent state store
+- live parameter/state authority
+- shader package registry owner
+- status/telemetry sink
+- control mutation entrypoint
+
+That makes it a single contention and failure domain. It is also why OSC and render timing issues repeatedly surfaced around shared state access.
+
+Relevant code:
+
+- [RuntimeHost.h](/c:/Users/Aiden/Documents/GitHub/video-shader-toys/apps/LoopThroughWithOpenGLCompositing/runtime/RuntimeHost.h:15)
+
+Recommended direction:
+
+- split persisted config/state from live render-facing state
+- separate status/telemetry updates from control mutation paths
+- make render consume snapshots rather than sharing a large mutable authority object
+
+### 2. OpenGL ownership is still centralized behind one shared lock
+
+Even after recent timing improvements, preview, input upload, and playout rendering still rely on one shared GL context protected by one `CRITICAL_SECTION`.
+
+Relevant code:
+
+- [OpenGLComposite.h](/c:/Users/Aiden/Documents/GitHub/video-shader-toys/apps/LoopThroughWithOpenGLCompositing/gl/OpenGLComposite.h:93)
+- [OpenGLComposite.cpp](/c:/Users/Aiden/Documents/GitHub/video-shader-toys/apps/LoopThroughWithOpenGLCompositing/gl/OpenGLComposite.cpp:253)
+- [OpenGLVideoIOBridge.cpp](/c:/Users/Aiden/Documents/GitHub/video-shader-toys/apps/LoopThroughWithOpenGLCompositing/gl/pipeline/OpenGLVideoIOBridge.cpp:70)
+
+This is still a central choke point and limits timing isolation.
+
+Recommended direction:
+
+- use one dedicated render thread as the sole GL owner
+- have input/output/control threads queue work instead of performing GL work directly
+- remove ad hoc GL use from callback threads
+
+### 3. Control flow is spread across polling and shared-memory patterns
+
+`RuntimeServices` currently mixes:
+
+- file polling
+- deferred OSC commit handling
+- control service orchestration
+
+OSC ingest, overlay application, and host sync are distributed across several components.
+
+Relevant code:
+
+- [RuntimeServices.h](/c:/Users/Aiden/Documents/GitHub/video-shader-toys/apps/LoopThroughWithOpenGLCompositing/control/RuntimeServices.h:26)
+- [RuntimeServices.cpp](/c:/Users/Aiden/Documents/GitHub/video-shader-toys/apps/LoopThroughWithOpenGLCompositing/control/RuntimeServices.cpp:178)
+
+Recommended direction:
+
+- introduce a small internal event pipeline or message bus
+- use typed events for OSC, reloads, persistence requests, and status changes
+- make timing ownership explicit per subsystem
+
+Example event types:
+
+- `OscParameterTargeted`
+- `RenderOverlaySettled`
+- `PersistStateRequested`
+- `ShaderReloadRequested`
+- `DeckLinkStatusChanged`
+
+### 4. Error handling is still heavily UI-coupled
+
+Failures are often surfaced via `MessageBoxA`, while background services mainly log with `OutputDebugStringA`.
+
+Relevant code:
+
+- [OpenGLComposite.cpp](/c:/Users/Aiden/Documents/GitHub/video-shader-toys/apps/LoopThroughWithOpenGLCompositing/gl/OpenGLComposite.cpp:314)
+- [DeckLinkSession.cpp](/c:/Users/Aiden/Documents/GitHub/video-shader-toys/apps/LoopThroughWithOpenGLCompositing/videoio/decklink/DeckLinkSession.cpp:478)
+- [RuntimeServices.cpp](/c:/Users/Aiden/Documents/GitHub/video-shader-toys/apps/LoopThroughWithOpenGLCompositing/control/RuntimeServices.cpp:205)
+
+This is not ideal for a live system where modal dialogs and silent debug logging are both poor operational behavior.
+
+Recommended direction:
+
+- introduce structured in-app error reporting
+- define severity levels and counters
+- prefer degraded runtime states over modal failure handling where possible
+- add a rolling log file for operational troubleshooting
+
+### 5. Live OSC overlay and persisted state are still separate concepts without a formal model
+
+The current design works better now, but it still relies on hand-managed reconciliation between:
+
+- persisted parameter state in `RuntimeHost`
+- transient OSC overlay state in `OpenGLComposite`
+
+Relevant code:
+
+- [OpenGLComposite.h](/c:/Users/Aiden/Documents/GitHub/video-shader-toys/apps/LoopThroughWithOpenGLCompositing/gl/OpenGLComposite.h:66)
+
+Recommended direction:
+
+Formalize three layers of state:
+
+- base persisted state
+- operator/UI committed state
+- transient live automation overlay
+
+Then render can always resolve:
+
+- `final = base + committed + transient`
+
+That avoids special-case sync behavior becoming scattered across the code.
+
+### 6. DeckLink lifecycle could be modeled more explicitly
+
+`DeckLinkSession` has a number of imperative calls, but startup, preroll, running, degraded, and stopped are not represented as an explicit state machine.
+
+Relevant code:
+
+- [DeckLinkSession.h](/c:/Users/Aiden/Documents/GitHub/video-shader-toys/apps/LoopThroughWithOpenGLCompositing/videoio/decklink/DeckLinkSession.h:17)
+
+Recommended direction:
+
+- introduce explicit session states
+- define allowed transitions
+- centralize recovery behavior
+- make shutdown ordering and degraded-mode behavior more predictable
+
+Timing-specific additions:
+
+- separate "device callback received" from "render the next output frame" so output cadence is not driven directly by the completion callback thread
+- make playout headroom configurable and adaptive instead of using a fixed compile-time preroll count
+- track an explicit backend health state such as `running-steady`, `catching-up`, `late`, and `dropping`
+
+Relevant timing code:
+
+- [OpenGLVideoIOBridge.cpp](/c:/Users/Aiden/Documents/GitHub/video-shader-toys/apps/LoopThroughWithOpenGLCompositing/gl/pipeline/OpenGLVideoIOBridge.cpp:86)
+- [DeckLinkSession.cpp](/c:/Users/Aiden/Documents/GitHub/video-shader-toys/apps/LoopThroughWithOpenGLCompositing/videoio/decklink/DeckLinkSession.cpp:420)
+- [DeckLinkSession.cpp](/c:/Users/Aiden/Documents/GitHub/video-shader-toys/apps/LoopThroughWithOpenGLCompositing/videoio/decklink/DeckLinkSession.cpp:487)
+- [VideoPlayoutScheduler.cpp](/c:/Users/Aiden/Documents/GitHub/video-shader-toys/apps/LoopThroughWithOpenGLCompositing/videoio/VideoPlayoutScheduler.cpp:26)
+
+Why this matters:
+
+- `PlayoutFrameCompleted()` currently begins an output frame, takes the shared GL path, renders, reads back, and schedules the next frame in one callback-driven flow.
+- `VideoPlayoutScheduler::AccountForCompletionResult()` currently reacts to both late and dropped frames by blindly advancing the schedule index by `2`, which is simple but not especially robust.
+- `kPrerollFrameCount` is now `12`, but `DeckLinkSession::ConfigureOutput()` still creates a fixed pool of `10` mutable output frames. That mismatch suggests the buffering model is not being sized from one coherent source of truth.
+
+Recommended direction:
+
+- move playout to a producer/consumer model where a render worker fills output buffers ahead of the DeckLink callback
+- define buffer-pool sizing from one policy object, for example: preroll depth, minimum spare buffers, and allowed catch-up depth
+- replace fixed "skip two frames" recovery with measured lag accounting based on actual scheduled-versus-completed position
+- expose playout latency as a runtime setting or policy, rather than burying it in a constant
+
+### 6a. The current playout timing model is still callback-coupled
+
+The app now has more headroom, but the next output frame is still produced directly in the scheduled-frame completion callback path.
+
+Relevant code:
+
+- [OpenGLVideoIOBridge.cpp](/c:/Users/Aiden/Documents/GitHub/video-shader-toys/apps/LoopThroughWithOpenGLCompositing/gl/pipeline/OpenGLVideoIOBridge.cpp:86)
+- [DeckLinkFrameTransfer.cpp](/c:/Users/Aiden/Documents/GitHub/video-shader-toys/apps/LoopThroughWithOpenGLCompositing/videoio/decklink/DeckLinkFrameTransfer.cpp:53)
+
+That means the completion callback is currently responsible for:
+
+- frame pacing accounting
+- acquiring the next output buffer
+- taking the GL critical section
+- rendering the composite
+- performing output readback
+- scheduling the next frame
+
+This works when the app is comfortably within budget, but it makes deadline misses much harder to absorb gracefully.
+
+Recommended direction:
+
+- make the DeckLink callback a lightweight notifier
+- have a dedicated playout worker or render worker keep an ahead-of-time queue of ready output frames
+- treat callback time as control-plane time, not render time
+
+### 6b. A producer/consumer playout model would be a better long-term fit
+
+The stronger architecture for this app is:
+
+- a render scheduler or dedicated render thread runs at the configured video cadence
+- rendering produces completed output frames ahead of need
+- those frames are placed into a bounded queue or ring buffer
+- the DeckLink side consumes already-prepared frames when callbacks indicate they are needed
+
+That is a better fit than callback-driven rendering because it separates:
+
+- render timing
+- GL ownership
+- output-device timing
+- latency policy
+
+In that model:
+
+- render is the producer
+- DeckLink is the timing consumer
+- the queue between them becomes the main place to manage latency versus resilience
+
+Why this is preferable:
+
+- brief callback jitter is less likely to become a visible dropped frame
+- render spikes can be absorbed by queue headroom instead of immediately missing output deadlines
+- latency becomes an explicit policy choice rather than an incidental side effect of callback timing
+- queue depth, underruns, stale-frame reuse, and catch-up behavior become measurable and tunable
+
+Recommended direction:
+
+- move toward a bounded producer/consumer playout queue
+- make queue depth and target headroom runtime policy, not compile-time constants
+- define explicit underrun behavior, for example:
+  - reuse newest completed frame
+  - reuse last scheduled frame
+  - output black or degraded frame
+- keep DeckLink callbacks limited to dequeue/schedule/accounting work wherever possible
+
+### 7. Persistence should be more asynchronous and debounced
+
+`SavePersistentState()` is still called directly from many update paths.
+
+Relevant code:
+
+- [RuntimeHost.cpp](/c:/Users/Aiden/Documents/GitHub/video-shader-toys/apps/LoopThroughWithOpenGLCompositing/runtime/RuntimeHost.cpp:1841)
+
+Recent OSC work already reduced this problem for live automation, but the broader architecture would still benefit from:
+
+- a debounced persistence queue
+- atomic write-behind snapshots
+- clear separation between state mutation and disk flush
+
+This improves both resilience and timing safety.
+
+### 8. Telemetry is useful, but still too coarse
+
+The app already records render timing and playout pacing, which is a good foundation.
+
+Relevant code:
+
+- [OpenGLRenderPipeline.cpp](/c:/Users/Aiden/Documents/GitHub/video-shader-toys/apps/LoopThroughWithOpenGLCompositing/gl/pipeline/OpenGLRenderPipeline.cpp:24)
+- [OpenGLVideoIOBridge.cpp](/c:/Users/Aiden/Documents/GitHub/video-shader-toys/apps/LoopThroughWithOpenGLCompositing/gl/pipeline/OpenGLVideoIOBridge.cpp:24)
+
+Recommended direction:
+
+Add lightweight tracing for:
+
+- input callback latency
+- input upload skip count
+- GL lock wait time
+- render queue depth
+- render time
+- pass build/compile latency
+- readback time
+- output scheduling lag
+- output queue depth
+- preroll depth versus spare-buffer depth
+- preview present cost and skipped-preview count
+- control queue depth
+- `RuntimeHost` lock contention
+
+That would make future tuning and failure diagnosis much easier.
+
+Timing-specific observations from the current code:
+
+- render time is captured as one total number in [OpenGLRenderPipeline.cpp](/c:/Users/Aiden/Documents/GitHub/video-shader-toys/apps/LoopThroughWithOpenGLCompositing/gl/pipeline/OpenGLRenderPipeline.cpp:24), but not split into draw, pack, readback wait, readback copy, or preview present
+- frame pacing stats are recorded in [OpenGLVideoIOBridge.cpp](/c:/Users/Aiden/Documents/GitHub/video-shader-toys/apps/LoopThroughWithOpenGLCompositing/gl/pipeline/OpenGLVideoIOBridge.cpp:17), but there is no explicit visibility into how much queued playout headroom remains
+- input uploads are intentionally skipped when the GL bridge is busy in [OpenGLVideoIOBridge.cpp](/c:/Users/Aiden/Documents/GitHub/video-shader-toys/apps/LoopThroughWithOpenGLCompositing/gl/pipeline/OpenGLVideoIOBridge.cpp:60), but the app does not currently surface how often that is happening
+
+### 8a. Preview and playout are still too close together
+
+The desktop preview is rate-limited, but still presented from inside the render pipeline path.
+
+Relevant code:
+
+- [OpenGLRenderPipeline.cpp](/c:/Users/Aiden/Documents/GitHub/video-shader-toys/apps/LoopThroughWithOpenGLCompositing/gl/pipeline/OpenGLRenderPipeline.cpp:54)
+- [OpenGLComposite.cpp](/c:/Users/Aiden/Documents/GitHub/video-shader-toys/apps/LoopThroughWithOpenGLCompositing/gl/OpenGLComposite.cpp:235)
+
+This means preview presentation can still consume time on the same path that is trying to meet output deadlines.
+
+Recommended direction:
+
+- treat preview as best-effort and entirely subordinate to playout
+- move preview present to a separate presentation schedule fed from the latest completed render
+- record preview skips and preview present cost independently from playout timing
+
+### 8b. Readback is improved, but still not fully deadline-safe
+
+The async readback path is a good step, but the miss path still falls back to synchronous `glReadPixels()` and then flushes the async pipeline.
+
+Relevant code:
+
+- [OpenGLRenderPipeline.cpp](/c:/Users/Aiden/Documents/GitHub/video-shader-toys/apps/LoopThroughWithOpenGLCompositing/gl/pipeline/OpenGLRenderPipeline.cpp:150)
+- [OpenGLRenderPipeline.cpp](/c:/Users/Aiden/Documents/GitHub/video-shader-toys/apps/LoopThroughWithOpenGLCompositing/gl/pipeline/OpenGLRenderPipeline.cpp:228)
+
+That means a single late GPU fence can push the app back onto the most timing-sensitive path exactly when it is already under pressure.
+
+Recommended direction:
+
+- increase readback instrumentation before changing policy again
+- consider deeper readback buffering or a true stale-frame reuse policy instead of immediate synchronous fallback
+- separate "freshest possible frame" policy from "never miss output deadline" policy and make that tradeoff explicit
+
+### 8c. Background control and file-watch timing are still coarse
+
+`RuntimeServices::PollLoop()` currently uses a `25 x Sleep(10)` loop, which gives it a coarse `~250 ms` cadence for file-watch polling and deferred OSC commit work.
+
+Relevant code:
+
+- [RuntimeServices.cpp](/c:/Users/Aiden/Documents/GitHub/video-shader-toys/apps/LoopThroughWithOpenGLCompositing/control/RuntimeServices.cpp:245)
+
+That is acceptable for non-critical background work, but it is still too blunt to be the long-term timing model for coordination-heavy runtime services.
+
+Recommended direction:
+
+- replace coarse sleep polling with waitable events or condition-variable driven wakeups where practical
+- isolate truly background work from latency-sensitive control reconciliation
+- add separate metrics for queue age, not just queue depth
+
+## Phased Roadmap
+
+This roadmap is ordered by architectural dependency rather than by “quick wins.” The goal is to move the app toward clearer ownership boundaries and safer live behavior without doing later work on top of foundations that are likely to change again.
+
+### Phase 1. Define subsystem boundaries and target architecture
+
+Before changing major internals, formalize the target responsibilities for each major part of the app.
+
+Target split:
+
+- `RuntimeStore`
+  - persisted config
+  - persisted layer stack
+  - preset persistence
+- `RuntimeSnapshot`
+  - render-facing immutable or near-immutable snapshots
+  - parameter values prepared for the render path
+- `ControlServices`
+  - OSC ingress
+  - web control ingress
+  - reload/file-watch requests
+  - commit/persist requests
+- `RenderEngine`
+  - sole owner of live GL rendering
+  - sole consumer of render snapshots plus transient overlays
+- `VideoBackend`
+  - DeckLink input/output lifecycle
+  - pacing and scheduling
+- `Health/Telemetry`
+  - logging
+  - counters
+  - timing traces
+  - degraded-state reporting
+
+Why this phase comes first:
+
+- it prevents later refactors from reintroducing responsibility overlap
+- it gives names to the seams the later phases will build around
+- it reduces the risk of replacing one monolith with several poorly-defined ones
+
+Suggested deliverables:
+
+- a short architecture diagram
+- a responsibility table for each subsystem
+- a list of allowed dependencies between subsystems
+
+### Phase 2. Introduce an internal event model
+
+Once subsystem boundaries are defined, introduce a typed event pipeline between them. This should happen before large state splits so the app has a stable coordination model.
+
+Example event families:
+
+- control events
+  - `OscParameterTargeted`
+  - `UiParameterCommitted`
+  - `TriggerFired`
+- runtime events
+  - `ShaderReloadRequested`
+  - `PackagesRescanned`
+  - `PersistStateRequested`
+- render events
+  - `OverlayApplied`
+  - `OverlaySettled`
+  - `SnapshotPublished`
+- backend events
+  - `InputSignalChanged`
+  - `OutputLateFrameDetected`
+  - `OutputDroppedFrameDetected`
+- health events
+  - `SubsystemWarningRaised`
+  - `SubsystemRecovered`
+
+Why this phase comes second:
+
+- it provides a migration path away from direct cross-calls
+- it makes ownership explicit before data structures are split apart
+- it lets you move one subsystem at a time without losing coordination
+
+Suggested outcome:
+
+- the app stops relying on “shared object plus mutex plus polling” as the default coordination pattern
+
+### Phase 3. Split `RuntimeHost` into persistent state, render snapshot state, and service-facing coordination
+
+After the event model exists, break apart `RuntimeHost`.
+
+Recommended split:
+
+- `RuntimeStore`
+  - owns config and saved layer data
+  - handles serialization/deserialization
+  - does not sit on the live render path
+- `RuntimeCoordinator`
+  - resolves control actions
+  - validates mutations
+  - publishes new snapshots
+  - bridges events between services and render
+- `RuntimeSnapshotProvider`
+  - publishes immutable render snapshots
+  - avoids large shared mutable structures on the render path
+
+Why this phase comes before render-thread isolation:
+
+- render isolation is easier when the render thread consumes clean snapshots instead of a large mutable host object
+- otherwise the GL refactor still drags along too much shared state complexity
+
+Primary design rule:
+
+- render should read snapshots
+- persistence should write stored state
+- services should request mutations through the coordinator
+
+### Phase 4. Make the render thread the sole GL owner
+
+With state and coordination cleaner, move to a dedicated render-thread model.
+
+Target behavior:
+
+- one thread owns the GL context
+- input callbacks never perform GL work directly
+- output callbacks never perform GL work directly
+- preview presentation, texture upload, render passes, readback, and output pack work are all issued by the render thread
+
+Other threads should only:
+
+- enqueue new video frames
+- enqueue control updates
+- enqueue backend events
+- consume produced output buffers
+
+Why this phase comes here:
+
+- it is much safer once state access and control coordination are no longer centered on `RuntimeHost`
+- it avoids coupling the render-thread refactor to storage and service refactors at the same time
+
+Expected benefits:
+
+- less cross-thread GL contention
+- easier timing reasoning
+- much lower risk of callback-driven stalls
+- a clearer foundation for future GPU pipeline work
+
+### Phase 5. Refactor live state layering into an explicit composition model
+
+Once rendering and snapshots are isolated, formalize how final parameter values are derived.
+
+Recommended layers:
+
+- base persisted state
+- operator-committed live state
+- transient automation overlay
+
+Render should derive final values from a clear composition rule such as:
+
+- `final = base + committed + transient`
+
+Why this phase follows render isolation:
+
+- once render owns snapshot consumption, it becomes much easier to cleanly evaluate layered state without touching persistence or control services
+- it turns the current OSC overlay behavior into a first-class model instead of an implementation detail
+
+Expected benefits:
+
+- fewer one-off sync rules
+- clearer behavior for OSC, UI changes, and automation
+- easier future expansion to presets, cues, or timed transitions
+
+### Phase 6. Move persistence onto a background snapshot writer
+
+After the state model is explicit, persistence should become a background concern rather than a synchronous side effect of mutations.
+
+Target behavior:
+
+- mutations update authoritative in-memory stored state
+- persistence requests are queued
+- disk writes are debounced and coalesced
+- writes are atomic and versioned where practical
+
+Why this phase comes after state splitting:
+
+- otherwise persistence logic will need to be rewritten twice
+- it should operate on the new `RuntimeStore` model, not on the current mixed-responsibility object
+
+Expected benefits:
+
+- less timing interference
+- better corruption resistance
+- cleaner restart/recovery semantics
+
+### Phase 7. Make DeckLink/backend lifecycle explicit with a state machine
+
+Once the render and state layers are cleaner, refactor the video backend into an explicit lifecycle model.
+
+Suggested states:
+
+- uninitialized
+- devices-discovered
+- configured
+- prerolling
+- running
+- degraded
+- stopping
+- stopped
+- failed
+
+Why this phase belongs here:
+
+- the backend should integrate with the new event model
+- degraded/recovery behavior will be easier once rendering and state coordination are already more deterministic
+
+Expected benefits:
+
+- safer startup/shutdown ordering
+- clearer recovery behavior
+- easier handling of missing input, dropped frames, or reconfiguration
+- a clearer place to own playout headroom policy, output queue sizing, and late-frame recovery behavior
+
+### Phase 8. Add structured health, telemetry, and operational reporting
+
+This phase should happen after the main ownership changes so the telemetry can reflect the final architecture instead of a transient one.
+
+Recommended coverage:
+
+- render queue depth
+- GL lock wait time, if any shared lock remains
+- input callback latency
+- input upload skip count
+- output scheduling lag
+- output queue depth and spare-buffer depth
+- readback timing
+- readback fence wait timing
+- synchronous readback fallback count
+- preview present timing and skipped-preview count
+- snapshot publish frequency
+- persistence queue depth
+- event queue depth
+- backend state transitions
+- warning/error counters per subsystem
+
+Also replace modal-only error handling with:
+
+- structured in-app health state
+- severity-based logging
+- rolling log files
+- operator-visible degraded-state messages
+
+Why this phase comes last:
+
+- it should instrument the architecture you intend to keep
+- otherwise instrumentation work gets invalidated by the refactor
+
+## Recommended Execution Order
+
+If this is approached as a serious architecture program rather than opportunistic cleanup, the recommended order is:
+
+1. Define subsystem boundaries and target architecture.
+2. Introduce the internal event model.
+3. Split `RuntimeHost`.
+4. Make the render thread the sole GL owner.
+5. Formalize live state layering and composition.
+6. Move persistence to a background snapshot writer.
+7. Refactor DeckLink/backend lifecycle into an explicit state machine.
+8. Add structured telemetry, health reporting, and operational diagnostics.
+
+## Why This Order Makes Sense
+
+This order tries to avoid doing foundational work twice.
+
+- The event model comes before major subsystem extraction so coordination patterns stabilize early.
+- `RuntimeHost` is split before render isolation so the render thread does not inherit the current monolithic state model.
+- Live state layering is formalized only after render ownership is clearer.
+- Persistence is moved later so it can target the final state model rather than the current one.
+- Telemetry is intentionally late so it instruments the architecture that survives the refactor.
+
+## Short Version
+
+The app is in a much better place than it was before the OSC timing work, but the main remaining architectural risk is still shared ownership. Too many responsibilities converge on `RuntimeHost` and the shared GL path. The most sensible path forward is:
+
+1. define boundaries
+2. establish an event model
+3. split state ownership
+4. isolate rendering
+5. formalize layered live state
+6. background persistence
+7. explicit backend lifecycle
+8. health and telemetry
+
+That sequence gives each later phase a cleaner foundation than the current app has today.

docs/OSC_CONTROL.md

@@ -8,11 +8,15 @@ Set the UDP port in `config/runtime-host.json`:
 
 ```json
 {
-  "oscPort": 9000
+  "oscBindAddress": "127.0.0.1",
+  "oscPort": 9000,
+  "oscSmoothing": 0.18
 }
 ```
 
 Set `oscPort` to `0` to disable the OSC listener.
+Set `oscBindAddress` to `127.0.0.1` to keep OSC local to the host, or `0.0.0.0` to listen on all IPv4 interfaces.
+Set `oscSmoothing` to a value from `0.0` to `1.0` to add a subtle per-frame easing amount for numeric OSC controls. `0.0` disables smoothing, and larger values respond more quickly.
 
 ## Address Pattern
 
@@ -61,6 +65,8 @@ The listener accepts these OSC argument types:
 
 Single-argument messages become scalar JSON values. Multi-argument messages become JSON arrays, which lets OSC drive `vec2` and `color` parameters.
 
+OSC updates are coalesced by target route and applied once per render tick, so rapid controller motion does not force one runtime mutation, disk write, and UI push per incoming UDP packet. Numeric OSC controls can also be slightly smoothed with `oscSmoothing`.
+
 Examples:
 
 ```text
@@ -72,6 +78,8 @@ Examples:
 
 Values are validated with the same shader parameter rules used by the REST API. Invalid values or unknown addresses are ignored and reported to the native debug output.
 
+OSC-driven parameter changes are not autosaved to `runtime/runtime_state.json`. Stack edits made through the UI and preset operations still persist as before. Smoothing only applies to numeric controls such as floats, `vec2`, and `color`; booleans, enums, text, and triggers stay immediate.
+
 For `trigger` parameters, the OSC value is treated as a pulse. A simple integer or boolean message is enough:
 
 ```text
@@ -114,10 +122,21 @@ send('127.0.0.1:9000', '/VideoShaderToys/fisheye-reproject/tiltDegrees', {type:
 
 ## Network
 
-The listener binds to localhost only:
+By default the listener binds to localhost only:
 
 ```text
 127.0.0.1:<oscPort>
 ```
 
 This keeps the control surface local to the machine running Video Shader Toys.
+
+To accept OSC from other machines on the network, set:
+
+```json
+{
+  "oscBindAddress": "0.0.0.0",
+  "oscPort": 9000
+}
+```
+
+That listens on all IPv4 interfaces, so make sure your firewall and network are configured appropriately.

runtime/templates/shader_wrapper.slang.in

@@ -19,6 +19,7 @@ struct ShaderContext
 	float bypass;
 	int sourceHistoryLength;
 	int temporalHistoryLength;
+	int feedbackAvailable;
 };
 
 cbuffer GlobalParams
@@ -34,16 +35,23 @@ cbuffer GlobalParams
 	float gBypass;
 	int gSourceHistoryLength;
 	int gTemporalHistoryLength;
+	int gFeedbackAvailable;
 {{PARAMETER_UNIFORMS}}};
 
 Sampler2D<float4> gVideoInput;
-{{SOURCE_HISTORY_SAMPLERS}}{{TEMPORAL_HISTORY_SAMPLERS}}{{TEXTURE_SAMPLERS}}
+Sampler2D<float4> gLayerInput;
+{{SOURCE_HISTORY_SAMPLERS}}{{TEMPORAL_HISTORY_SAMPLERS}}{{FEEDBACK_SAMPLER}}{{TEXTURE_SAMPLERS}}
 {{TEXT_SAMPLERS}}
 float4 sampleVideo(float2 tc)
 {
 	return gVideoInput.Sample(tc);
 }
 
+float4 sampleLayerInput(float2 tc)
+{
+	return gLayerInput.Sample(tc);
+}
+
 float4 sampleSourceHistory(int framesAgo, float2 tc)
 {
 	if (gSourceHistoryLength <= 0)
@@ -74,6 +82,8 @@ float4 sampleTemporalHistory(int framesAgo, float2 tc)
 	}
 }
 
+{{FEEDBACK_HELPER}}
+
 {{TEXT_HELPERS}}
 #include "{{USER_SHADER_INCLUDE}}"
 
@@ -94,6 +104,7 @@ float4 fragmentMain(FragmentInput input) : SV_Target
 	context.bypass = gBypass;
 	context.sourceHistoryLength = gSourceHistoryLength;
 	context.temporalHistoryLength = gTemporalHistoryLength;
+	context.feedbackAvailable = gFeedbackAvailable;
 	float4 effectedColor = {{ENTRY_POINT_CALL}};
 	float mixValue = clamp(gBypass > 0.5 ? 0.0 : gMixAmount, 0.0, 1.0);
 	return lerp(context.sourceColor, effectedColor, mixValue);

shaders/SHADER_CONTRACT.md

@@ -101,9 +101,17 @@ Optional fields:
 - `textures`: texture assets to load and expose as samplers.
 - `fonts`: packaged font assets for live text parameters.
 - `temporal`: history-buffer requirements.
+- `feedback`: optional previous-frame shader-local feedback surface.
 
 Parameter objects may also include an optional `description` string. The control UI displays it as one-line helper text with the full text available on hover, so use it for short operational guidance rather than long documentation.
 
+Metadata conventions:
+
+- Keep `name` short, human-facing, and in title case.
+- Keep `category` consistent with existing library groups such as `Color`, `Transform`, `Projection`, `Temporal`, `Scopes & Guides`, `Utility`, `Feedback`, and `Calibration`.
+- Keep `description` to one clear sentence in present tense that explains what the shader does for an operator.
+- Avoid placeholder, joke, or overly implementation-heavy descriptions unless the shader is intentionally a diagnostic or broken example.
+
 Shader-visible identifiers must be valid Slang-style identifiers:
 
 - `entryPoint`
@@ -194,6 +202,98 @@ Pass output names:
 
 If the final declared pass does not explicitly output `layerOutput`, the runtime still treats that final pass as the visible layer output. Existing single-pass shaders are unaffected.
 
+## Feedback Surface
+
+Shaders may opt in to a persistent previous-frame feedback surface:
+
+```json
+{
+  "feedback": {
+    "enabled": true,
+    "writePass": "final"
+  }
+}
+```
+
+Fields:
+
+- `enabled`: when `true`, the runtime allocates one persistent `RGBA16F` feedback surface for this shader at the current render resolution.
+- `writePass`: optional pass `id` whose output should become next frame's feedback surface. If omitted, the runtime uses the final declared pass, or the implicit `main` pass for single-pass shaders.
+
+Behavior:
+
+- all passes may sample the same previous-frame feedback surface
+- one designated pass writes the next feedback surface
+- feedback is previous-frame state, not same-frame pass chaining
+
+Guardrails:
+
+- Feedback is best suited to image-like state such as trails, masks, luminance fields, decay maps, and shader-local analysis buffers.
+- Feedback is not a precise long-term data store. The surface uses `RGBA16F`, so repeated accumulation, exact counters, and tightly packed metadata can drift or clamp over time.
+- The feedback surface is currently filtered like an image, not configured as strict texel-addressed storage. If you reserve texels as data slots, sample them carefully and do not assume exact CPU-style array semantics.
+- Each feedback-enabled layer allocates two full-resolution feedback textures for ping-pong state. This increases VRAM use and adds one extra full-frame feedback copy per rendered frame.
+- In multipass shaders, feedback remains previous-frame state even when a pass also consumes same-frame pass outputs. Do not treat feedback as another same-frame intermediate buffer.
+
+Single-pass example:
+
+```json
+{
+  "id": "feedback-glow",
+  "name": "Feedback Glow",
+  "feedback": {
+    "enabled": true
+  },
+  "parameters": []
+}
+```
+
+Multipass example:
+
+```json
+{
+  "passes": [
+    {
+      "id": "analysis",
+      "source": "shader.slang",
+      "entryPoint": "analyzeFrame",
+      "output": "analysisBuffer"
+    },
+    {
+      "id": "final",
+      "source": "shader.slang",
+      "entryPoint": "finishFrame",
+      "inputs": ["analysisBuffer"],
+      "output": "layerOutput"
+    }
+  ],
+  "feedback": {
+    "enabled": true,
+    "writePass": "final"
+  }
+}
+```
+
+The wrapper exposes:
+
+```slang
+float4 sampleFeedback(float2 uv);
+```
+
+On the first frame, or after a reset, `sampleFeedback` returns transparent black.
+
+Feedback resets when:
+
+- a layer bypass state changes
+- a layer changes shader
+- the layer itself is removed
+- a shader is reloaded or recompiled
+- render dimensions change
+- the app restarts
+
+Ordinary stack add/remove/reorder operations on other layers are intended to preserve feedback state for unchanged feedback-enabled layers.
+
+So feedback should be treated as live runtime state, not durable saved state.
+
 ## Slang Entry Point
 
 Your shader file must implement the manifest `entryPoint`.
@@ -239,6 +339,7 @@ struct ShaderContext
     float bypass;
     int sourceHistoryLength;
     int temporalHistoryLength;
+    int feedbackAvailable;
 };
 ```
 
@@ -257,6 +358,7 @@ Fields:
 - `bypass`: `1.0` when the layer is bypassed, otherwise `0.0`.
 - `sourceHistoryLength`: number of usable source-history frames currently available.
 - `temporalHistoryLength`: number of usable temporal frames currently available for this layer.
+- `feedbackAvailable`: `1` when previous-frame feedback exists for this layer, otherwise `0`.
 
 Color/precision notes:
 
@@ -270,17 +372,23 @@ Color/precision notes:
 The wrapper provides:
 
 ```slang
+float4 sampleLayerInput(float2 uv);
 float4 sampleVideo(float2 uv);
 float4 sampleSourceHistory(int framesAgo, float2 uv);
 float4 sampleTemporalHistory(int framesAgo, float2 uv);
+float4 sampleFeedback(float2 uv);
 ```
 
-`sampleVideo` samples the live decoded source video.
+`sampleLayerInput` samples the input arriving at this shader layer before any of the layer's own passes run. If this layer follows another shader, it sees that previous shader's output. If this is the first shader layer, it sees the decoded source image.
+
+`sampleVideo` samples the current pass input texture. In single-pass shaders this is usually the layer input. In multipass shaders it may instead be a named pass output or `previousPass`, depending on the manifest routing for that pass.
 
 `sampleSourceHistory` samples previous decoded source frames. `framesAgo` is clamped into the available range. If no history is available, it falls back to `sampleVideo`.
 
 `sampleTemporalHistory` samples previous pre-layer input frames for temporal shaders that request `preLayerInput` history. `framesAgo` is clamped into the available range. If no temporal history is available, it falls back to `sampleVideo`.
 
+`sampleFeedback` samples the shader-local previous-frame feedback surface. If feedback has not been written yet, it returns transparent black.
+
 Example:
 
 ```slang
@@ -291,6 +399,57 @@ float4 shadeVideo(ShaderContext context)
 }
 ```
 
+Layer-input example:
+
+```slang
+float4 finishPass(ShaderContext context)
+{
+    float3 baseColor = sampleLayerInput(context.uv).rgb;
+    float3 passResult = context.sourceColor.rgb;
+    return float4(baseColor + passResult * 0.25, 1.0);
+}
+```
+
+Feedback example:
+
+```slang
+float4 shadeVideo(ShaderContext context)
+{
+    float4 previous = sampleFeedback(context.uv);
+    float4 current = context.sourceColor;
+    return lerp(current, previous, 0.2);
+}
+```
+
+Multipass feedback example:
+
+```slang
+float4 analyzeFrame(ShaderContext context)
+{
+    float4 previous = sampleFeedback(context.uv);
+    float luma = dot(context.sourceColor.rgb, float3(0.2126, 0.7152, 0.0722));
+    return float4(lerp(previous.rgb, float3(luma), 0.1), 1.0);
+}
+
+float4 finishFrame(ShaderContext context)
+{
+    float4 analysis = context.sourceColor;
+    return float4(analysis.rgb, 1.0);
+}
+```
+
+In that multipass case:
+
+- `analyzeFrame` reads last frame's feedback
+- `finishFrame` receives the same-frame pass output through normal multipass routing
+- the `writePass` decides which pass output becomes next frame's feedback
+
+That means:
+
+- use `context.sourceColor` or `sampleVideo()` when you want this pass's routed input
+- use `sampleLayerInput()` when you want the pre-pass layer input
+- use `sampleFeedback()` when you want previous-frame persistent shader-local state
+
 ## Parameters
 
 Manifest parameters are exposed to Slang as global values with the same `id`.

shaders/balatro-swirl/shader.slang

@@ -6,6 +6,8 @@ float4 balatroSwirl(float2 screenSize, float2 screenCoords, float time, float se
 	float2 uv = (screenCoords - 0.5 * screenSize) / safeScreenLength - offset - seedOffset;
 	float uvLength = length(uv);
 
+	// First warp: convert to polar space and twist the angle more near the
+	// center, creating the large spiral motion.
 	float speed = spinRotation * spinEase * 0.2;
 	if (isRotate)
 		speed = time * speed;
@@ -19,6 +21,8 @@ float4 balatroSwirl(float2 screenSize, float2 screenCoords, float time, float se
 	speed = (time + seed * 17.0) * spinSpeed;
 	float2 uv2 = float2(uv.x + uv.y, uv.x + uv.y);
 
+	// Second warp: a short iterative feedback loop turns the spiral into
+	// painterly bands while preserving a fixed compile-time loop bound.
 	for (int i = 0; i < 5; ++i)
 	{
 		uv2 += float2(sin(max(uv.x, uv.y)), sin(max(uv.x, uv.y))) + uv;
@@ -32,6 +36,8 @@ float4 balatroSwirl(float2 screenSize, float2 screenCoords, float time, float se
 	float c1p = max(0.0, 1.0 - contrastMod * abs(1.0 - paintRes));
 	float c2p = max(0.0, 1.0 - contrastMod * abs(paintRes));
 	float c3p = 1.0 - min(1.0, c1p + c2p);
+	// Three soft band weights drive the palette; lighting rides on the brightest
+	// bands so the swirl keeps dimensional highlights.
 	float light = (lighting - 0.2) * max(c1p * 5.0 - 4.0, 0.0) + lighting * max(c2p * 5.0 - 4.0, 0.0);
 
 	float safeContrast = max(contrast, 0.001);

shaders/crt-bulge/shader.json

@@ -0,0 +1,102 @@
+{
+  "id": "crt-bulge",
+  "name": "CRT Bulge",
+  "description": "Warps the image like convex CRT glass, with optional rounded screen edges and vignette darkening.",
+  "category": "Distortion",
+  "entryPoint": "shadeVideo",
+  "parameters": [
+    {
+      "id": "bulgeAmount",
+      "label": "Bulge",
+      "type": "float",
+      "default": -0.04,
+      "min": -0.5,
+      "max": 0.8,
+      "step": 0.01,
+      "description": "Positive values swell the center outward; negative values pinch it inward."
+    },
+    {
+      "id": "zoom",
+      "label": "Zoom",
+      "type": "float",
+      "default": 1.04,
+      "min": 0.5,
+      "max": 2,
+      "step": 0.01,
+      "description": "Scales the source before distortion, useful for hiding warped edges."
+    },
+    {
+      "id": "edgeRoundness",
+      "label": "Edge Roundness",
+      "type": "float",
+      "default": 0.08,
+      "min": 0,
+      "max": 0.35,
+      "step": 0.01,
+      "description": "Rounds the visible screen corners like older CRT glass."
+    },
+    {
+      "id": "edgeFeather",
+      "label": "Edge Feather",
+      "type": "float",
+      "default": 2,
+      "min": 0,
+      "max": 24,
+      "step": 0.1,
+      "description": "Softens the rounded screen edge in pixels."
+    },
+    {
+      "id": "sourceEdgeFeather",
+      "label": "Source Edge Feather",
+      "type": "float",
+      "default": 1.5,
+      "min": 0,
+      "max": 16,
+      "step": 0.1,
+      "description": "Antialiases warped source edges when the distortion reveals outside-frame pixels."
+    },
+    {
+      "id": "vignetteAmount",
+      "label": "Vignette",
+      "type": "float",
+      "default": 0.18,
+      "min": 0,
+      "max": 1,
+      "step": 0.01,
+      "description": "Darkens the glass toward the screen edges."
+    },
+    {
+      "id": "edgeMode",
+      "label": "Edge Mode",
+      "type": "enum",
+      "default": "black",
+      "options": [
+        {
+          "value": "black",
+          "label": "Black"
+        },
+        {
+          "value": "clamp",
+          "label": "Clamp"
+        },
+        {
+          "value": "mirror",
+          "label": "Mirror"
+        }
+      ],
+      "description": "Chooses how warped samples outside the source frame are filled."
+    },
+    {
+      "id": "outsideColor",
+      "label": "Outside Color",
+      "type": "color",
+      "default": [
+        0,
+        0,
+        0,
+        1
+      ],
+      "description": "Color used outside the curved screen or source frame."
+    }
+  ]
+}

shaders/crt-bulge/shader.slang

@@ -0,0 +1,71 @@
+float mirroredCoordinate(float coordinate)
+{
+	float wrapped = frac(coordinate * 0.5) * 2.0;
+	return wrapped <= 1.0 ? wrapped : 2.0 - wrapped;
+}
+
+float roundedBoxMask(float2 point, float2 halfSize, float radius, float feather)
+{
+	float2 distanceToEdge = abs(point) - (halfSize - radius);
+	float outsideDistance = length(max(distanceToEdge, float2(0.0, 0.0))) - radius;
+	float insideDistance = min(max(distanceToEdge.x, distanceToEdge.y), 0.0);
+	float signedDistance = outsideDistance + insideDistance;
+	return 1.0 - smoothstep(0.0, max(feather, 0.00001), signedDistance);
+}
+
+float sourceBoundsMask(float2 uv, float2 resolution)
+{
+	float2 pixel = 1.0 / max(resolution, float2(1.0, 1.0));
+	float2 feather = pixel * max(sourceEdgeFeather, 0.0);
+	float left = smoothstep(0.0, max(feather.x, 0.00001), uv.x);
+	float right = 1.0 - smoothstep(1.0 - max(feather.x, 0.00001), 1.0, uv.x);
+	float top = smoothstep(0.0, max(feather.y, 0.00001), uv.y);
+	float bottom = 1.0 - smoothstep(1.0 - max(feather.y, 0.00001), 1.0, uv.y);
+	return saturate(left * right * top * bottom);
+}
+
+float2 applyBulge(float2 uv, float2 resolution)
+{
+	float2 centered = uv * 2.0 - 1.0;
+	float aspect = resolution.x / max(resolution.y, 1.0);
+	float2 aspectCentered = float2(centered.x * aspect, centered.y);
+	float radiusSq = dot(aspectCentered, aspectCentered);
+	float amount = clamp(bulgeAmount, -0.95, 0.95);
+	float scale = 1.0 / max(1.0 + amount * radiusSq, 0.05);
+	return centered * scale / max(zoom, 0.001) * 0.5 + 0.5;
+}
+
+float4 sampleWarped(float2 uv, float2 resolution, out bool insideSource)
+{
+	insideSource = uv.x >= 0.0 && uv.x <= 1.0 && uv.y >= 0.0 && uv.y <= 1.0;
+
+	if (edgeMode == 1)
+		return sampleVideo(clamp(uv, 0.0, 1.0));
+	if (edgeMode == 2)
+		return sampleVideo(float2(mirroredCoordinate(uv.x), mirroredCoordinate(uv.y)));
+
+	float edgeMask = sourceBoundsMask(uv, resolution);
+	float4 color = sampleVideo(clamp(uv, 0.0, 1.0));
+	return lerp(outsideColor, color, edgeMask);
+}
+
+float4 shadeVideo(ShaderContext context)
+{
+	float2 resolution = max(context.outputResolution, float2(1.0, 1.0));
+	float2 sourceUv = applyBulge(context.uv, resolution);
+
+	bool insideSource = false;
+	float4 color = sampleWarped(sourceUv, resolution, insideSource);
+
+	float2 centered = context.uv * 2.0 - 1.0;
+	float feather = max(edgeFeather, 0.0) / min(resolution.x, resolution.y);
+	float screenMask = roundedBoxMask(centered, float2(1.0, 1.0), saturate(edgeRoundness), feather);
+	color = lerp(outsideColor, color, screenMask);
+
+	float2 aspectCentered = float2(centered.x * resolution.x / max(resolution.y, 1.0), centered.y);
+	float edgeDistance = saturate(length(aspectCentered) * 0.72);
+	float vignette = lerp(1.0, 1.0 - saturate(vignetteAmount), smoothstep(0.35, 1.05, edgeDistance));
+	color.rgb *= vignette;
+
+	return saturate(color);
+}

shaders/feedback-data-blocks/shader.json

@@ -0,0 +1,66 @@
+{
+  "id": "feedback-data-blocks",
+  "name": "Feedback Data Blocks",
+  "description": "Demonstrates coarse shader-local data storage by reserving eight 3x3 feedback cells for sampled colors and one hidden metadata cell for refresh state.",
+  "category": "Feedback",
+  "entryPoint": "storeProbeData",
+  "passes": [
+    {
+      "id": "store",
+      "source": "shader.slang",
+      "entryPoint": "storeProbeData",
+      "output": "dataBuffer"
+    },
+    {
+      "id": "display",
+      "source": "shader.slang",
+      "entryPoint": "displayProbeData",
+      "inputs": [
+        "dataBuffer"
+      ],
+      "output": "layerOutput"
+    }
+  ],
+  "feedback": {
+    "enabled": true,
+    "writePass": "store"
+  },
+  "parameters": [
+    {
+      "id": "refresh",
+      "label": "Refresh",
+      "type": "trigger",
+      "description": "Forces the stored probe colors to resample immediately."
+    },
+    {
+      "id": "refreshSeconds",
+      "label": "Refresh Seconds",
+      "type": "float",
+      "default": 15.0,
+      "min": 1.0,
+      "max": 60.0,
+      "step": 0.1,
+      "description": "Automatic interval for resampling all stored probe colors."
+    },
+    {
+      "id": "overlayOpacity",
+      "label": "Overlay Opacity",
+      "type": "float",
+      "default": 1.0,
+      "min": 0.0,
+      "max": 1.0,
+      "step": 0.01,
+      "description": "Strength of the swatch overlay drawn from the stored data cells."
+    },
+    {
+      "id": "swatchSize",
+      "label": "Swatch Size",
+      "type": "vec2",
+      "default": [0.045, 0.055],
+      "min": [0.02, 0.02],
+      "max": [0.12, 0.12],
+      "step": [0.001, 0.001],
+      "description": "Size of the top-left preview swatches that show the stored cell values."
+    }
+  ]
+}

shaders/feedback-data-blocks/shader.slang

@@ -0,0 +1,152 @@
+static const int kProbeCount = 8;
+static const int kMetadataIndex = 8;
+
+float2 probeUvForIndex(int index)
+{
+    if (index == 0)
+        return float2(0.18, 0.28);
+    if (index == 1)
+        return float2(0.39, 0.28);
+    if (index == 2)
+        return float2(0.61, 0.28);
+    if (index == 3)
+        return float2(0.82, 0.28);
+    if (index == 4)
+        return float2(0.18, 0.72);
+    if (index == 5)
+        return float2(0.39, 0.72);
+    if (index == 6)
+        return float2(0.61, 0.72);
+    return float2(0.82, 0.72);
+}
+
+float2 cellCenterPixelForIndex(int index)
+{
+    return float2(1.0 + float(index) * 3.0, 1.0);
+}
+
+float2 cellCenterUvForIndex(ShaderContext context, int index)
+{
+    return (cellCenterPixelForIndex(index) + 0.5) / context.outputResolution;
+}
+
+bool pixelIsInsideCell(float2 pixelCoord, int index)
+{
+    float minX = float(index) * 3.0;
+    float maxX = minX + 3.0;
+    return pixelCoord.x >= minX && pixelCoord.x < maxX && pixelCoord.y >= 0.0 && pixelCoord.y < 3.0;
+}
+
+float4 readStoredCell(ShaderContext context, int index)
+{
+    if (context.feedbackAvailable <= 0)
+        return float4(0.0, 0.0, 0.0, 0.0);
+    return sampleFeedback(cellCenterUvForIndex(context, index));
+}
+
+bool shouldRefreshStoredData(ShaderContext context)
+{
+    if (context.feedbackAvailable <= 0)
+        return true;
+
+    float4 metadata = readStoredCell(context, kMetadataIndex);
+    float previousRefreshBucket = metadata.r;
+    float previousTriggerCount = metadata.g;
+    float refreshInterval = max(refreshSeconds, 0.001);
+    float currentRefreshBucket = floor(context.time / refreshInterval);
+    float currentTriggerCount = float(refresh);
+
+    return currentRefreshBucket > previousRefreshBucket + 0.5 || currentTriggerCount > previousTriggerCount + 0.5;
+}
+
+float4 metadataValueForFrame(ShaderContext context, bool refreshNow)
+{
+    float refreshInterval = max(refreshSeconds, 0.001);
+    float currentRefreshBucket = floor(context.time / refreshInterval);
+    float currentTriggerCount = float(refresh);
+
+    if (!refreshNow && context.feedbackAvailable > 0)
+        return readStoredCell(context, kMetadataIndex);
+
+    return float4(currentRefreshBucket, currentTriggerCount, refreshTime, 1.0);
+}
+
+float4 storedProbeValueForFrame(ShaderContext context, int index, bool refreshNow)
+{
+    float3 liveColor = sampleLayerInput(probeUvForIndex(index)).rgb;
+    if (refreshNow || context.feedbackAvailable <= 0)
+        return float4(liveColor, 1.0);
+    return readStoredCell(context, index);
+}
+
+float4 storeProbeData(ShaderContext context)
+{
+    // Reserve nine 3x3 texel cells along the top edge of the feedback surface:
+    // eight cells for visible probe colors and one hidden metadata cell that
+    // tracks the timed refresh bucket and last trigger count.
+    float2 pixelCoord = floor(context.uv * context.outputResolution);
+    bool refreshNow = shouldRefreshStoredData(context);
+
+    for (int index = 0; index < kProbeCount; ++index)
+    {
+        if (pixelIsInsideCell(pixelCoord, index))
+            return storedProbeValueForFrame(context, index, refreshNow);
+    }
+
+    if (pixelIsInsideCell(pixelCoord, kMetadataIndex))
+        return metadataValueForFrame(context, refreshNow);
+
+    return float4(0.0, 0.0, 0.0, 1.0);
+}
+
+float rectMask(float2 uv, float2 minUv, float2 maxUv)
+{
+    if (uv.x < minUv.x || uv.x > maxUv.x)
+        return 0.0;
+    if (uv.y < minUv.y || uv.y > maxUv.y)
+        return 0.0;
+    return 1.0;
+}
+
+float borderMask(float2 uv, float2 minUv, float2 maxUv, float thickness)
+{
+    float outer = rectMask(uv, minUv, maxUv);
+    float inner = rectMask(uv, minUv + thickness, maxUv - thickness);
+    return saturate(outer - inner);
+}
+
+float4 displayProbeData(ShaderContext context)
+{
+    float3 baseColor = sampleLayerInput(context.uv).rgb;
+    float3 swatchColor = baseColor;
+    float swatchMask = 0.0;
+
+    float2 panelOrigin = float2(0.03, 0.04);
+    float2 gap = float2(swatchSize.x + 0.012, swatchSize.y + 0.012);
+    float borderThickness = min(swatchSize.x, swatchSize.y) * 0.08;
+
+    for (int index = 0; index < kProbeCount; ++index)
+    {
+        int column = index % 4;
+        int row = index / 4;
+        float2 swatchMin = panelOrigin + float2(float(column) * gap.x, float(row) * gap.y);
+        float2 swatchMax = swatchMin + swatchSize;
+        float3 storedColor = sampleVideo(cellCenterUvForIndex(context, index)).rgb;
+        float fill = rectMask(context.uv, swatchMin, swatchMax);
+        float outline = borderMask(context.uv, swatchMin, swatchMax, borderThickness);
+        if (fill > 0.5)
+        {
+            swatchColor = storedColor;
+            swatchMask = 1.0;
+        }
+        if (outline > 0.5)
+        {
+            swatchColor = float3(0.0, 0.0, 0.0);
+            swatchMask = 1.0;
+        }
+    }
+
+    float opacity = saturate(overlayOpacity) * swatchMask;
+    float3 displayColor = lerp(baseColor, swatchColor, opacity);
+    return float4(saturate(displayColor), 1.0);
+}

shaders/feedback-highlight-accumulator/shader.json

@@ -0,0 +1,110 @@
+{
+  "id": "feedback-highlight-accumulator",
+  "name": "Feedback Background Memory",
+  "description": "Learns a persistent per-pixel background plate in shader-local feedback and compares the live frame against that evolving full-frame state.",
+  "category": "Feedback",
+  "entryPoint": "updateBackgroundModel",
+  "passes": [
+    {
+      "id": "background",
+      "source": "shader.slang",
+      "entryPoint": "updateBackgroundModel",
+      "output": "backgroundModel"
+    },
+    {
+      "id": "display",
+      "source": "shader.slang",
+      "entryPoint": "displayBackgroundDifference",
+      "inputs": [
+        "backgroundModel"
+      ],
+      "output": "layerOutput"
+    }
+  ],
+  "feedback": {
+    "enabled": true,
+    "writePass": "background"
+  },
+  "parameters": [
+    {
+      "id": "learnRate",
+      "label": "Learn Rate",
+      "type": "float",
+      "default": 0.03,
+      "min": 0.001,
+      "max": 0.5,
+      "step": 0.001,
+      "description": "How quickly the stored background model adapts toward the current frame."
+    },
+    {
+      "id": "differenceThreshold",
+      "label": "Difference Threshold",
+      "type": "float",
+      "default": 0.12,
+      "min": 0.001,
+      "max": 1.0,
+      "step": 0.001,
+      "description": "Minimum difference between the live frame and stored background before the overlay becomes visible."
+    },
+    {
+      "id": "softness",
+      "label": "Threshold Softness",
+      "type": "float",
+      "default": 0.08,
+      "min": 0.001,
+      "max": 0.5,
+      "step": 0.001,
+      "description": "Softens the transition around the difference threshold."
+    },
+    {
+      "id": "overlayOpacity",
+      "label": "Overlay Opacity",
+      "type": "float",
+      "default": 0.85,
+      "min": 0.0,
+      "max": 1.0,
+      "step": 0.01,
+      "description": "Strength of the motion/difference overlay on top of the live image."
+    },
+    {
+      "id": "backgroundMix",
+      "label": "Background Mix",
+      "type": "float",
+      "default": 0.15,
+      "min": 0.0,
+      "max": 1.0,
+      "step": 0.01,
+      "description": "Amount of the learned background model shown underneath the live source."
+    },
+    {
+      "id": "overlayTint",
+      "label": "Overlay Tint",
+      "type": "color",
+      "default": [
+        1.0,
+        0.45,
+        0.08,
+        1.0
+      ],
+      "min": [
+        0.0,
+        0.0,
+        0.0,
+        0.0
+      ],
+      "max": [
+        1.0,
+        1.0,
+        1.0,
+        1.0
+      ],
+      "step": [
+        0.01,
+        0.01,
+        0.01,
+        0.01
+      ],
+      "description": "Tint used for areas that differ from the learned background."
+    }
+  ]
+}

shaders/feedback-highlight-accumulator/shader.slang

@@ -0,0 +1,39 @@
+float luminance(float3 color)
+{
+    return dot(color, float3(0.2126, 0.7152, 0.0722));
+}
+
+float4 updateBackgroundModel(ShaderContext context)
+{
+    float3 liveColor = context.sourceColor.rgb;
+    if (context.feedbackAvailable <= 0)
+        return float4(liveColor, 1.0);
+
+    float3 previousBackground = sampleFeedback(context.uv).rgb;
+    float rate = saturate(learnRate);
+    float3 nextBackground = lerp(previousBackground, liveColor, rate);
+    return float4(saturate(nextBackground), 1.0);
+}
+
+float4 displayBackgroundDifference(ShaderContext context)
+{
+    // In the display pass, context.sourceColor is the same-frame background
+    // model produced by updateBackgroundModel().
+    float3 backgroundModel = context.sourceColor.rgb;
+    float3 liveColor = sampleLayerInput(context.uv).rgb;
+
+    float3 delta = abs(liveColor - backgroundModel);
+    float difference = max(delta.r, max(delta.g, delta.b));
+    float thresholdWidth = max(softness, 0.0001);
+    float motionMask = smoothstep(
+        differenceThreshold - thresholdWidth,
+        differenceThreshold + thresholdWidth,
+        difference);
+
+    float3 baseColor = lerp(liveColor, backgroundModel, saturate(backgroundMix));
+    float3 overlayColor = overlayTint.rgb * max(luminance(liveColor), 0.15);
+    float overlayAmount = motionMask * saturate(overlayOpacity) * overlayTint.a;
+    float3 displayColor = lerp(baseColor, baseColor + overlayColor, overlayAmount);
+
+    return float4(saturate(displayColor), 1.0);
+}

shaders/fisheye-equirectangular-mirror/shader.slang

@@ -31,6 +31,8 @@ float normalizedFisheyeRadius(float theta, float halfFov)
 {
 	float safeHalfFov = max(halfFov, 0.0001);
 
+	// Match common fisheye projection families while keeping the selected FOV
+	// normalized to the same source-image radius.
 	if (fisheyeModel == 1)
 	{
 		return sin(theta * 0.5) / max(sin(safeHalfFov * 0.5), 0.0001);
@@ -49,6 +51,7 @@ float normalizedFisheyeRadius(float theta, float halfFov)
 
 float3 equirectangularRay(float2 uv)
 {
+	// Convert equirectangular UVs into longitude/latitude on the unit sphere.
 	float longitude = (uv.x - 0.5) * TWO_PI;
 	float latitude = (0.5 - uv.y) * PI;
 	float latitudeCos = cos(latitude);
@@ -82,6 +85,8 @@ float4 sampleEdgeFilledVideo(float2 sourceUv, ShaderContext context)
 	float inwardLength = max(length(inward), 0.000001);
 	inward /= inwardLength;
 
+	// Outside the fisheye image, sample back inward from the nearest edge so the
+	// fill looks like stretched lens content instead of a hard color plate.
 	float blurDistance = max(edgeBlur, 0.0);
 	float4 color = sampleVideo(clampedUv) * 0.32;
 	color += sampleVideo(saturate(clampedUv + inward * blurDistance * 0.35)) * 0.26;
@@ -114,6 +119,7 @@ float4 shadeVideo(ShaderContext context)
 	float phi = atan2(ray.y, ray.x);
 	float fisheyeRadius = normalizedFisheyeRadius(theta, halfFov);
 
+	// Project the mirrored sphere ray back into the circular fisheye source.
 	float2 sourceUv = float2(
 		center.x + cos(phi) * fisheyeRadius * radius.x,
 		center.y - sin(phi) * fisheyeRadius * radius.y

shaders/fisheye-reproject/shader.json

@@ -59,6 +59,26 @@
       ],
       "description": "Normalized fisheye radius; adjust X/Y when the image is cropped or squeezed."
     },
+    {
+      "id": "sourceEdgeCut",
+      "label": "Source Edge Cut",
+      "type": "float",
+      "default": 0.01,
+      "min": 0,
+      "max": 0.2,
+      "step": 0.001,
+      "description": "Cuts slightly inward from all four source-frame edges before sampling to hide empty border regions."
+    },
+    {
+      "id": "sourceEdgeFeather",
+      "label": "Source Edge Feather",
+      "type": "float",
+      "default": 0.02,
+      "min": 0,
+      "max": 0.2,
+      "step": 0.001,
+      "description": "Softens the trimmed source edges into the outside color for easier background blending."
+    },
     {
       "id": "virtualFovDegrees",
       "label": "Virtual FOV",

shaders/fisheye-reproject/shader.slang

@@ -43,6 +43,8 @@ float normalizedFisheyeRadius(float theta, float halfFov)
 {
 	float safeHalfFov = max(halfFov, 0.0001);
 
+	// Different fisheye lenses map angle to image radius differently. Normalize
+	// each model by the selected half-FOV so the outer lens edge stays at 1.0.
 	if (fisheyeModel == 1)
 	{
 		return sin(theta * 0.5) / max(sin(safeHalfFov * 0.5), 0.0001);
@@ -59,6 +61,20 @@ float normalizedFisheyeRadius(float theta, float halfFov)
 	return theta / safeHalfFov;
 }
 
+float sourceUvRectMask(float2 uv, float2 inputResolution)
+{
+	float2 pixel = 1.0 / max(inputResolution, float2(1.0, 1.0));
+	float cut = max(sourceEdgeCut, 0.0);
+	float feather = max(sourceEdgeFeather, 0.0);
+	float2 featherSize = max(float2(feather, feather), pixel * 0.5);
+
+	float left = smoothstep(cut, cut + featherSize.x, uv.x);
+	float right = 1.0 - smoothstep(1.0 - cut - featherSize.x, 1.0 - cut, uv.x);
+	float top = smoothstep(cut, cut + featherSize.y, uv.y);
+	float bottom = 1.0 - smoothstep(1.0 - cut - featherSize.y, 1.0 - cut, uv.y);
+	return saturate(left * right * top * bottom);
+}
+
 float4 shadeVideo(ShaderContext context)
 {
 	float2 screen = float2(context.uv.x * 2.0 - 1.0, 1.0 - context.uv.y * 2.0);
@@ -67,6 +83,8 @@ float4 shadeVideo(ShaderContext context)
 	float virtualFov = radiansFromDegrees(clamp(virtualFovDegrees, 1.0, 175.0));
 	float tanHalfFov = tan(virtualFov * 0.5);
 
+	// Build a virtual output-camera ray, then rotate it into the fisheye lens
+	// coordinate system before asking where that ray lands on the source image.
 	float3 ray = outputProjection == 1
 		? buildCylindricalRay(screen, outputAspect, tanHalfFov)
 		: buildRectilinearRay(screen, outputAspect, tanHalfFov);
@@ -86,6 +104,7 @@ float4 shadeVideo(ShaderContext context)
 	float phi = atan2(ray.y, ray.x);
 	float fisheyeRadius = normalizedFisheyeRadius(theta, halfFov);
 
+	// Polar lens coordinates become UVs inside the circular fisheye image.
 	float2 sourceUv = float2(
 		center.x + cos(phi) * fisheyeRadius * radius.x,
 		center.y - sin(phi) * fisheyeRadius * radius.y
@@ -94,5 +113,7 @@ float4 shadeVideo(ShaderContext context)
 	if (sourceUv.x < 0.0 || sourceUv.x > 1.0 || sourceUv.y < 0.0 || sourceUv.y > 1.0)
 		return outsideColor;
 
-	return sampleVideo(sourceUv);
+	float sourceMask = sourceUvRectMask(sourceUv, context.inputResolution);
+	float4 sourceColor = sampleVideo(sourceUv);
+	return saturate(lerp(outsideColor, sourceColor, sourceMask));
 }

shaders/greenscreen-key/shader.slang

@@ -23,6 +23,8 @@ float3 matteSampleColor(float2 uv, ShaderContext context)
 	if (blur <= 0.0001)
 		return center;
 
+	// Pre-blur only the color used for screen comparison; the final image keeps
+	// its original detail and alpha is refined in a later pass.
 	float2 radius = pixel * blur;
 	float3 color = center * 0.36;
 	color += saturate(sampleVideo(saturate(uv + float2(radius.x, 0.0))).rgb) * 0.16;
@@ -37,6 +39,8 @@ float keyDistanceAt(float2 uv, ShaderContext context)
 	float3 color = matteSampleColor(uv, context);
 	float3 keyColor = saturate(screenColor.rgb);
 	float chromaDistance = distance(chroma709(color), chroma709(keyColor)) * 2.65;
+	// Direction distance is less sensitive to brightness, while chroma distance
+	// follows broadcast-style color difference; screenBalance blends the two.
 	float directionDistance = length(safeNormalize(max(color, float3(0.0001, 0.0001, 0.0001))) - safeNormalize(max(keyColor, float3(0.0001, 0.0001, 0.0001)))) * 0.55;
 	return lerp(directionDistance, chromaDistance, saturate(screenBalance));
 }
@@ -65,6 +69,8 @@ float refinedAlphaFromMatte(float2 uv, ShaderContext context)
 
 	if (aaRadius > 0.0001)
 	{
+		// A small fixed kernel smooths edges and collects min/max alpha for
+		// black/white cleanup without needing dynamic loops or arrays.
 		float2 radius = pixel * aaRadius;
 		float2 halfRadius = radius * 0.5;
 		float alphaMin = centerAlpha;
@@ -126,6 +132,8 @@ float refinedAlphaFromMatte(float2 uv, ShaderContext context)
 		alpha = centerAlpha;
 	}
 
+	// Final matte shaping happens after blur/cleanup so clip and contrast affect
+	// the refined edge rather than the raw screen-distance estimate.
 	alpha = saturate((alpha - clipBlack) / max(clipWhite - clipBlack, 0.0001));
 	alpha = saturate((alpha - 0.5) * max(matteContrast, 0.0001) + 0.5);
 	alpha = pow(max(alpha, 0.0), max(matteGamma, 0.0001));
@@ -135,6 +143,8 @@ float refinedAlphaFromMatte(float2 uv, ShaderContext context)
 float spillAmountForColor(float3 color)
 {
 	float3 keyColor = saturate(screenColor.rgb);
+	// Measure spill as color energy aligned with the screen color minus the
+	// strongest opposing channel, leaving neutral highlights mostly intact.
 	float keyComponent = dot(color, safeNormalize(max(keyColor, float3(0.0001, 0.0001, 0.0001))));
 	float opposingComponent = max(max(color.r * (1.0 - keyColor.r), color.g * (1.0 - keyColor.g)), color.b * (1.0 - keyColor.b));
 	return saturate(keyComponent - opposingComponent + despillBias);
@@ -187,6 +197,8 @@ float4 applyKey(ShaderContext context)
 	float cropMask = cropMaskAt(context.uv, context);
 	alpha *= cropMask;
 
+	// Edge recovery is strongest around 50% alpha, where fringing usually lives,
+	// and fades away for solid foreground/background pixels.
 	float edgeAmount = saturate(1.0 - abs(alpha * 2.0 - 1.0));
 	despilled = lerp(despilled, despilled * saturate(edgeColor.rgb), edgeAmount * saturate(edgeRecover));
 

shaders/happy-accident/shader.slang

@@ -36,6 +36,8 @@ float4 shadeVideo(ShaderContext context)
 	float4 accumulated = float4(0.0, 0.0, 0.0, 0.0);
 	float clampedSteps = clamp(raySteps, 1.0, 77.0);
 
+	// Ray-march a folded procedural field. distanceToSurface advances the ray,
+	// while inverse-distance accumulation creates the glowing filaments.
 	for (int i = 0; i < 77; ++i)
 	{
 		if (float(i) >= clampedSteps)
@@ -49,11 +51,14 @@ float4 shadeVideo(ShaderContext context)
 		position.xy = mul(rotateAroundZ(2.0 + originalPosition.z), position.xy);
 		position.xy = mul(happyAccidentMatrix(originalPosition, timeCos), position.xy);
 
+		// Color comes from pre-fold space so the palette varies smoothly even as
+		// the geometry folds into repeated cells.
 		float colorSeed = 0.5 * originalPosition.z + length(position - originalPosition);
 		float4 palette = 1.0 + sin(colorSeed + float4(0.0, 4.0, 3.0, 6.0));
 		palette /= 0.55 + 1.55 * dot(originalPosition.xy, originalPosition.xy);
 
 		position = abs(frac(position) - 0.5);
+		// Distance to a tiny box/cross primitive inside each repeated cell.
 		distanceToSurface = abs(min(length(position.xy) - 0.125, min(position.x, position.y) + 0.001)) + 0.001;
 		accumulated += palette.w * palette / distanceToSurface;
 	}

shaders/lut-apply/shader.slang

@@ -7,6 +7,8 @@ float3 sampleLutCell(float3 index)
     float g = floor(index.g + 0.5);
     float b = floor(index.b + 0.5);
 
+    // The 33^3 cube is packed as blue slices laid horizontally, with red across
+    // each slice and green down the atlas.
     float atlasWidth = LUT_SIZE * LUT_SIZE;
     float2 lutUv;
     lutUv.x = (r + b * LUT_SIZE + 0.5) / atlasWidth;
@@ -30,6 +32,9 @@ float3 applyLut33(float3 color)
     float3 c011 = sampleLutCell(float3(baseIndex.r, nextIndex.g, nextIndex.b));
     float3 c111 = sampleLutCell(float3(nextIndex.r, nextIndex.g, nextIndex.b));
 
+    // Tetrahedral interpolation chooses one of six paths through the cube.
+    // This avoids the muddy diagonals that simple trilinear LUT sampling can
+    // introduce for strong grades.
     if (blend.r > blend.g)
     {
         if (blend.g > blend.b)
@@ -55,6 +60,8 @@ float hash12(float2 value)
 
 float3 outputDither(float2 pixel)
 {
+    // Subtract paired hashes to center the dither around zero, then scale to
+    // roughly one 8-bit code value.
     float r = hash12(pixel + float2(17.0, 31.0)) - hash12(pixel + float2(83.0, 47.0));
     float g = hash12(pixel + float2(29.0, 71.0)) - hash12(pixel + float2(53.0, 19.0));
     float b = hash12(pixel + float2(61.0, 11.0)) - hash12(pixel + float2(7.0, 97.0));

shaders/singularity/shader.slang

@@ -20,6 +20,8 @@ float4 shadeVideo(ShaderContext context)
 	float2 p = (fragCoord + fragCoord - resolution) / resolution.y / safeScale;
 	p -= center + float2(sin(seed * 6.2831853), cos(seed * 6.2831853)) * 0.035;
 
+	// Build a skewed coordinate system around an offset "black hole" so the
+	// waves pinch and stretch instead of staying radially symmetric.
 	float iterator = 0.2;
 	float2 diagonal = normalize(float2(-1.0 + seed * 0.5, 1.0 - seed * 0.35));
 	float2 blackholeCenter = p - iterator * diagonal;
@@ -30,6 +32,8 @@ float4 shadeVideo(ShaderContext context)
 	float2 v = singularitySpiral(c, time, iterator);
 	float2 waves = float2(0.0001, 0.0001);
 
+	// Iterative sine feedback creates the accretion texture; the iterator value
+	// also damps later steps to keep the pattern stable.
 	for (; iterator < 9.0; iterator += 1.0)
 	{
 		waves += 1.0 + sin(v);
@@ -40,6 +44,8 @@ float4 shadeVideo(ShaderContext context)
 	float disk = 2.0 + diskRadius * diskRadius * (0.25 * safeTightness) - diskRadius;
 	float centerDarkness = 0.5 + 1.0 / max(dot(c, c), 0.0001);
 	float rim = 0.025 + abs(length(p) - safeRingRadius) * safeTightness;
+	// Exponential falloff turns the accumulated wave field into bright rims and
+	// a darker center without hard thresholds.
 	float4 redBlueGradient = exp(c.x * float4(0.6, -0.4, -1.0, 0.0) * colorShift);
 	float4 waveColor = waves.xyyx;
 

shaders/vhs/shader.json

@@ -69,7 +69,7 @@
       "id": "vignetteAmount",
       "label": "Vignette",
       "type": "float",
-      "default": 0.18,
+      "default": 0.3,
       "min": 0,
       "max": 0.6,
       "step": 0.01,
@@ -154,6 +154,46 @@
       "max": 6,
       "step": 0.05,
       "description": "Scale of the generated noise pattern."
+    },
+    {
+      "id": "scanlineAmount",
+      "label": "Scanlines",
+      "type": "float",
+      "default": 0.08,
+      "min": 0,
+      "max": 0.35,
+      "step": 0.005,
+      "description": "Subtle alternating-field luma modulation."
+    },
+    {
+      "id": "chromaCrawlAmount",
+      "label": "Chroma Crawl",
+      "type": "float",
+      "default": 0.035,
+      "min": 0,
+      "max": 0.2,
+      "step": 0.005,
+      "description": "Moving color shimmer around high-contrast edges."
+    },
+    {
+      "id": "generationLoss",
+      "label": "Generation Loss",
+      "type": "float",
+      "default": 0.18,
+      "min": 0,
+      "max": 1,
+      "step": 0.01,
+      "description": "Raises blacks, softens detail, lowers contrast, and desaturates chroma like copied tape."
+    },
+    {
+      "id": "sharpnessDrift",
+      "label": "Sharpness Drift",
+      "type": "float",
+      "default": 0.12,
+      "min": 0,
+      "max": 0.6,
+      "step": 0.01,
+      "description": "Slowly varies picture softness to mimic unstable tape focus."
     }
   ]
 }

shaders/vhs/shader.slang

@@ -8,6 +8,8 @@ float2 jumpy(float2 uv, float framecount)
 	float2 look = uv;
 	float m = frac(framecount / 4.0);
 	float dy = look.y - m;
+	// Localize the horizontal tear to a moving scanline window instead of
+	// bending the whole frame equally.
 	float window = 1.0 / (1.0 + 80.0 * dy * dy);
 	look.x += 0.05 * sin(look.y * 10.0 + framecount) / 20.0 * onOff(4.0, 4.0, 0.3, framecount) * (0.5 + cos(framecount * 20.0)) * window;
 	float vShift = (0.1 * wiggle) * 0.4 * onOff(2.0, 3.0, 0.9, framecount) * (sin(framecount) * sin(framecount * 20.0) + (0.5 + 0.1 * sin(framecount * 200.0) * cos(framecount)));
@@ -44,11 +46,16 @@ float noiseHash(float2 p)
 	return frac(sin(dot(p, float2(127.1, 311.7))) * 43758.5453123);
 }
 
-// Gold Noise (c)2015 dcerisano@standard3d.com, adapted for Slang.
-float goldNoise(float2 xy, float seed)
+float staticHash(float2 p)
 {
-	const float phi = 1.61803398874989484820459;
-	return frac(tan(distance(xy * phi, xy) * seed) * xy.x);
+	float3 p3 = frac(float3(p.x, p.y, p.x) * 0.1031);
+	p3 += dot(p3, p3.yzx + 33.33);
+	return frac((p3.x + p3.y) * p3.z);
+}
+
+float seededStaticHash(float2 p, float seed)
+{
+	return staticHash(p + float2(seed * 37.13, seed * 17.71));
 }
 
 float grainScalar(float2 uv)
@@ -59,13 +66,17 @@ float grainScalar(float2 uv)
 float3 animatedChromaGrain(float2 uv, float time, float2 outputResolution, float grainSize)
 {
 	float safeGrainSize = max(grainSize, 0.001);
+	// Quantize the coordinates first so larger grain sizes become visible
+	// chroma blocks rather than simply lower-frequency smooth noise.
 	float2 baseUv = uv * outputResolution * float2(0.85, 0.95) / safeGrainSize;
 	float2 grainUv = floor(baseUv) + 0.5;
-	float2 drift = float2(time * 19.7, time * 23.3);
+	float frame = floor(time * 59.94);
 
-	float r = grainScalar(grainUv + drift + float2(13.1, 71.7));
-	float g = grainScalar(grainUv * float2(1.03, 0.97) + drift * 1.11 + float2(47.2, 19.4));
-	float b = grainScalar(grainUv * float2(0.96, 1.05) + drift * 0.91 + float2(83.6, 53.8));
+	// Change the grain field per frame instead of drifting it through UV space;
+	// continuous drift can alias into horizontal bands that march down-frame.
+	float r = staticHash(grainUv + float2(frame * 17.0 + 13.1, frame * 3.0 + 71.7));
+	float g = staticHash(grainUv * float2(1.03, 0.97) + float2(frame * 11.0 + 47.2, frame * 5.0 + 19.4));
+	float b = staticHash(grainUv * float2(0.96, 1.05) + float2(frame * 7.0 + 83.6, frame * 13.0 + 53.8));
 
 	return float3(r, g, b) * 2.0 - 1.0;
 }
@@ -87,6 +98,8 @@ float valueNoise2(float2 p)
 float tapeLineNoise(float2 uv, float time, float2 outputResolution)
 {
 	float y = floor(uv.y * outputResolution.y);
+	// Combine stable per-line noise with frame-rate noise so bands have both
+	// slow tape wander and fast electronic shimmer.
 	float slowLine = valueNoise2(float2(y * 0.021, floor(time * 10.0)));
 	float fastLine = noiseHash(float2(y * 1.73, floor(time * 59.94)));
 	float line = (slowLine * 0.7 + fastLine * 0.3) * 2.0 - 1.0;
@@ -102,16 +115,19 @@ float3 analogStatic(float2 uv, float time, float2 outputResolution)
 	float frame = floor(time * 59.94);
 	float seed = frac(time);
 
+	// Several differently skewed hashes keep the snow from forming obvious
+	// diagonal or grid patterns at broadcast frame cadence.
 	float2 goldPixel = pixel + float2(0.37, 0.61) + frame;
-	float snowA = goldNoise(goldPixel, seed + 0.1);
-	float snowB = goldNoise(goldPixel * float2(0.37, 2.11) + float2(19.0, 41.0), seed + 0.2);
-	float snowC = goldNoise(goldPixel * float2(1.73, 0.81) + float2(53.0, 7.0), seed + 0.3);
+	float snowA = seededStaticHash(goldPixel, seed + 0.1);
+	float snowB = seededStaticHash(goldPixel * float2(0.37, 2.11) + float2(19.0, 41.0), seed + 0.2);
+	float snowC = seededStaticHash(goldPixel * float2(1.73, 0.81) + float2(53.0, 7.0), seed + 0.3);
 	float snow = (snowA * 0.72 + snowB * 0.28) * 2.0 - 1.0;
 
 	float lineNoise = tapeLineNoise(uv, time, safeResolution);
-	float dropoutSeed = goldNoise(float2(floor(uv.y * safeResolution.y * 0.25) + 1.0, frame + 2.0), seed + 0.4);
+	float dropoutSeed = seededStaticHash(float2(floor(uv.y * safeResolution.y * 0.25) + 1.0, frame + 2.0), seed + 0.4);
 	float dropout = smoothstep(0.965, 1.0, dropoutSeed);
-	float fleck = smoothstep(0.988, 1.0, snowA) - smoothstep(0.0, 0.012, snowC);
+	float fleckSeed = seededStaticHash(pixel + float2(frame * 13.0, -frame * 7.0), seed + 0.5);
+	float fleck = smoothstep(0.992, 1.0, fleckSeed) - smoothstep(0.0, 0.008, snowC);
 
 	float scan = sin(uv.y * safeResolution.y * 3.14159265);
 	float scanMask = 0.55 + 0.45 * scan * scan;
@@ -138,6 +154,85 @@ float3 softBloom(float2 uv, float2 outputResolution, float radius)
 	return sum;
 }
 
+float3 softCrossBlur(float2 uv, float2 outputResolution, float radius)
+{
+	float2 pixel = 1.0 / max(outputResolution, float2(1.0, 1.0));
+	float2 offset = pixel * radius;
+	float3 sum = sampleVideo(frac(uv)).rgb * 0.40;
+	sum += sampleVideo(frac(uv + float2(offset.x, 0.0))).rgb * 0.15;
+	sum += sampleVideo(frac(uv - float2(offset.x, 0.0))).rgb * 0.15;
+	sum += sampleVideo(frac(uv + float2(0.0, offset.y))).rgb * 0.15;
+	sum += sampleVideo(frac(uv - float2(0.0, offset.y))).rgb * 0.15;
+	return sum;
+}
+
+float3 applyChromaCrawl(float3 color, float2 uv, float time, float2 outputResolution)
+{
+	float amount = saturate(chromaCrawlAmount);
+	if (amount <= 0.0001)
+		return color;
+
+	float2 pixel = 1.0 / max(outputResolution, float2(1.0, 1.0));
+	float lumaCenter = dot(color, float3(0.299, 0.587, 0.114));
+	float lumaX = dot(sampleVideo(frac(uv + float2(pixel.x, 0.0))).rgb, float3(0.299, 0.587, 0.114));
+	float lumaY = dot(sampleVideo(frac(uv + float2(0.0, pixel.y))).rgb, float3(0.299, 0.587, 0.114));
+	float edge = saturate((abs(lumaX - lumaCenter) + abs(lumaY - lumaCenter)) * 6.0);
+	float phase = sin(uv.y * outputResolution.y * 1.35 + time * 36.0) * cos(uv.x * outputResolution.x * 0.55 - time * 21.0);
+	float2 crawlOffset = float2(phase, -phase * 0.35) * pixel * (1.0 + amount * 8.0);
+
+	float3 shiftedA = sampleVideo(frac(uv + crawlOffset)).rgb;
+	float3 shiftedB = sampleVideo(frac(uv - crawlOffset * 0.75)).rgb;
+	float3 crawled = color;
+	crawled.r = lerp(color.r, shiftedA.r, edge * amount);
+	crawled.b = lerp(color.b, shiftedB.b, edge * amount);
+	return crawled;
+}
+
+float3 applyGenerationLoss(float3 color, float2 uv, float2 outputResolution)
+{
+	float loss = saturate(generationLoss);
+	if (loss <= 0.0001)
+		return color;
+
+	float3 softened = softCrossBlur(uv, outputResolution, 0.85 + loss * 2.2);
+	color = lerp(color, softened, loss * 0.42);
+
+	float luma = dot(color, float3(0.299, 0.587, 0.114));
+	float3 gray = float3(luma, luma, luma);
+	color = lerp(color, gray, loss * 0.32);
+	color = (color - 0.5) * (1.0 - loss * 0.18) + 0.5;
+	color = color * (1.0 - loss * 0.08) + float3(0.035, 0.035, 0.04) * loss;
+	return color;
+}
+
+float3 applySharpnessDrift(float3 color, float2 uv, float time, float2 outputResolution)
+{
+	float drift = saturate(sharpnessDrift);
+	if (drift <= 0.0001)
+		return color;
+
+	float wobble = 0.5 + 0.5 * sin(time * 1.7 + sin(time * 0.37) * 2.0);
+	float radius = 0.35 + wobble * 2.25;
+	float3 softened = softCrossBlur(uv, outputResolution, radius);
+	return lerp(color, softened, drift * (0.35 + 0.65 * wobble));
+}
+
+float3 applySubtleScanlines(float3 color, float2 uv, float time, float2 outputResolution)
+{
+	float amount = saturate(scanlineAmount);
+	if (amount <= 0.0001)
+		return color;
+
+	float scan = sin((uv.y * outputResolution.y + floor(time * 59.94) * 0.5) * 3.14159265);
+	float field = 0.5 + 0.5 * scan;
+	float luma = dot(color, float3(0.299, 0.587, 0.114));
+	float visibility = lerp(1.0, 0.45, saturate(luma));
+	float modulation = 1.0 - amount * visibility * (0.35 + 0.65 * field);
+	color.rgb *= modulation;
+	color.rgb += amount * 0.015 * (1.0 - field);
+	return color;
+}
+
 float3 blurVhs(float2 uv, float d, int sampleCount)
 {
 	float3 sum = float3(0.0, 0.0, 0.0);
@@ -146,6 +241,8 @@ float3 blurVhs(float2 uv, float d, int sampleCount)
 	float2 pixelOffset = float2(d, 0.0);
 	float2 scale = 0.66 * 8.0 * pixelOffset;
 
+	// The circular tap pattern approximates soft tape smear while keeping the
+	// maximum loop bound fixed for shader compilation.
 	for (int i = 0; i < 15; ++i)
 	{
 		if (i >= sampleCount)
@@ -170,6 +267,8 @@ float4 buildTapeSmear(ShaderContext context)
 	float framecount = frac(time * wiggleSpeed / 7.0) * 7.0;
 	int sampleCount = int(clamp(blurSamples, 3.0, 15.0) + 0.5);
 
+	// Split the source into YIQ, smear each component by a different amount,
+	// then recombine to mimic luma/chroma bandwidth mismatch on tape.
 	float d = 0.1 - round(frac(time / 3.0)) * 0.1;
 	uv = jumpy(uv, framecount);
 	float s = 0.0001 * -d + 0.0001 * wiggle * sin(time * wiggleSpeed);
@@ -202,6 +301,8 @@ float4 finishVhs(ShaderContext context)
 	float time = distortedTapeTime(context);
 	float3 color = sampleVideo(context.uv).rgb;
 
+	// Radial red/blue offsets create lens and deck misregistration before the
+	// wider tape effects are layered in.
 	float2 centered = context.uv * 2.0 - 1.0;
 	centered.x *= context.outputResolution.x / max(context.outputResolution.y, 1.0);
 	float2 aberrationOffset = centered * (aberrationAmount * 0.0015);
@@ -219,16 +320,24 @@ float4 finishVhs(ShaderContext context)
 	float halationMask = smoothstep(0.45, 1.0, halationLuma) * halationAmount;
 	color += halationSource * float3(1.0, 0.38, 0.24) * halationMask * 0.35;
 
+	// Bloom and fade are applied as separate layers so highlights glow without
+	// flattening the full picture into the faded black level.
 	float3 bloomSource = softBloom(context.uv, context.outputResolution, 2.0 + smear * 2.5);
 	float bloomLuma = dot(bloomSource, float3(0.299, 0.587, 0.114));
 	float bloomMask = smoothstep(0.32, 1.0, bloomLuma) * bloomAmount;
 	color = lerp(color, bloomSource, bloomAmount * 0.18);
 	color += bloomSource * float3(1.0, 0.96, 0.92) * bloomMask * 0.24;
 
+	color = applySharpnessDrift(color, context.uv, time, context.outputResolution);
+	color = applyGenerationLoss(color, context.uv, context.outputResolution);
+	color = applyChromaCrawl(color, context.uv, time, context.outputResolution);
+
 	float3 speckle = animatedChromaGrain(context.uv, time, context.outputResolution, noiseSize);
 	float luma = dot(color, float3(0.299, 0.587, 0.114));
 	float noiseMask = lerp(0.65, 1.0, 1.0 - saturate(luma));
 	float chunkiness = lerp(1.0, 2.4, saturate((noiseSize - 1.0) / 5.0));
+	// Push darker regions harder: analog noise reads most naturally in shadows
+	// and avoids washing out bright highlights.
 	float3 chromaNoise = float3(speckle.x * 1.2, speckle.y * 0.28, speckle.z * 1.35);
 	color += chromaNoise * noiseAmount * noiseMask * chunkiness;
 	color.rg = lerp(color.rg, float2(color.r, color.g) + speckle.xy * noiseAmount * 0.2 * chunkiness, 0.35);
@@ -244,6 +353,8 @@ float4 finishVhs(ShaderContext context)
 	color = color * (1.0 - fadeAmount * 0.08) + float3(0.055, 0.055, 0.065) * fadeAmount;
 	color = lerp(color, softBloom(context.uv, context.outputResolution, 1.0 + smear), fadeAmount * 0.12);
 
+	color = applySubtleScanlines(color, context.uv, time, context.outputResolution);
+
 	float vignetteBase = context.uv.x * (1.0 - context.uv.x) * context.uv.y * (1.0 - context.uv.y);
 	float vignette = saturate(pow(vignetteBase * 16.0, 0.22));
 	color *= lerp(1.0 - vignetteAmount, 1.0, vignette);

shaders/video-cube/shader.slang

@@ -17,6 +17,8 @@ bool intersectCube(float3 rayOrigin, float3 rayDirection, float halfExtent, out
 	float3 boxMin = float3(-halfExtent, -halfExtent, -halfExtent);
 	float3 boxMax = float3(halfExtent, halfExtent, halfExtent);
 
+	// Slab intersection: find the ray interval that overlaps all three box
+	// axes, then keep the nearest positive hit.
 	float3 invDir = 1.0 / rayDirection;
 	float3 t0 = (boxMin - rayOrigin) * invDir;
 	float3 t1 = (boxMax - rayOrigin) * invDir;
@@ -43,6 +45,8 @@ float2 cubeFaceUv(float3 hitPoint, float halfExtent, float zoom)
 	float2 uv = float2(0.5, 0.5);
 	float safeZoom = max(zoom, 0.001);
 
+	// The dominant coordinate tells which face was hit; the other two axes
+	// become that face's local UVs.
 	if (face.x >= face.y && face.x >= face.z)
 	{
 		uv = hitPoint.x > 0.0
@@ -79,6 +83,8 @@ float4 shadeVideo(ShaderContext context)
 	float yaw = spin;
 	float pitch = spin * 0.61 + 0.35;
 
+	// Rotate the camera ray into cube-local space instead of rotating the cube
+	// geometry, which keeps the intersection math axis-aligned.
 	float3 localOrigin = rotateY(rotateX(rayOrigin, -pitch), -yaw);
 	float3 localDirection = rotateY(rotateX(rayDirection, -pitch), -yaw);
 
@@ -96,6 +102,8 @@ float4 shadeVideo(ShaderContext context)
 
 	float3 normal;
 	float3 face = abs(localHit);
+	// Reconstruct the face normal from the hit point so lighting follows the
+	// same face choice used for UV lookup.
 	if (face.x >= face.y && face.x >= face.z)
 		normal = float3(sign(localHit.x), 0.0, 0.0);
 	else if (face.y >= face.x && face.y >= face.z)

shaders/video-plane-3d/shader.json

@@ -0,0 +1,121 @@
+{
+  "id": "video-plane-3d",
+  "name": "Video Plane 3D",
+  "description": "Places the video on a perspective 2D plane in 3D space with camera FOV, XYZ position, and pan/tilt/roll controls.",
+  "category": "Projection",
+  "entryPoint": "shadeVideo",
+  "parameters": [
+    {
+      "id": "fovDegrees",
+      "label": "FOV",
+      "type": "float",
+      "default": 45,
+      "min": 5,
+      "max": 150,
+      "step": 0.1,
+      "description": "Virtual camera vertical field of view in degrees."
+    },
+    {
+      "id": "positionX",
+      "label": "X",
+      "type": "float",
+      "default": 0,
+      "min": -4,
+      "max": 4,
+      "step": 0.01,
+      "description": "Horizontal plane position in world units."
+    },
+    {
+      "id": "positionY",
+      "label": "Y",
+      "type": "float",
+      "default": 0,
+      "min": -4,
+      "max": 4,
+      "step": 0.01,
+      "description": "Vertical plane position in world units."
+    },
+    {
+      "id": "positionZ",
+      "label": "Z",
+      "type": "float",
+      "default": 2.2,
+      "min": 0.1,
+      "max": 10,
+      "step": 0.01,
+      "description": "Depth of the plane in front of the virtual camera."
+    },
+    {
+      "id": "panDegrees",
+      "label": "Pan",
+      "type": "float",
+      "default": 0,
+      "min": -180,
+      "max": 180,
+      "step": 0.1,
+      "description": "Rotates the plane left/right around its vertical axis."
+    },
+    {
+      "id": "tiltDegrees",
+      "label": "Tilt",
+      "type": "float",
+      "default": 0,
+      "min": -120,
+      "max": 120,
+      "step": 0.1,
+      "description": "Rotates the plane up/down around its horizontal axis."
+    },
+    {
+      "id": "rollDegrees",
+      "label": "Roll",
+      "type": "float",
+      "default": 0,
+      "min": -180,
+      "max": 180,
+      "step": 0.1,
+      "description": "Rotates the plane around its face normal."
+    },
+    {
+      "id": "planeScale",
+      "label": "Plane Scale",
+      "type": "float",
+      "default": 1.4,
+      "min": 0.05,
+      "max": 6,
+      "step": 0.01,
+      "description": "Height of the video plane in world units; width follows the source aspect ratio."
+    },
+    {
+      "id": "edgeFeather",
+      "label": "Edge Feather",
+      "type": "float",
+      "default": 1.5,
+      "min": 0,
+      "max": 24,
+      "step": 0.1,
+      "description": "Softens the plane edge in source pixels."
+    },
+    {
+      "id": "backgroundMix",
+      "label": "Background Mix",
+      "type": "float",
+      "default": 0,
+      "min": 0,
+      "max": 1,
+      "step": 0.01,
+      "description": "Mixes the original video behind the projected plane."
+    },
+    {
+      "id": "outsideColor",
+      "label": "Outside Color",
+      "type": "color",
+      "default": [
+        0,
+        0,
+        0,
+        1
+      ],
+      "description": "Color used where the camera ray misses the plane."
+    }
+  ]
+}

shaders/video-plane-3d/shader.slang

@@ -0,0 +1,84 @@
+static const float PI = 3.14159265358979323846;
+
+float radiansFromDegrees(float degrees)
+{
+	return degrees * (PI / 180.0);
+}
+
+float3 rotateX(float3 p, float angle)
+{
+	float s = sin(angle);
+	float c = cos(angle);
+	return float3(p.x, c * p.y - s * p.z, s * p.y + c * p.z);
+}
+
+float3 rotateY(float3 p, float angle)
+{
+	float s = sin(angle);
+	float c = cos(angle);
+	return float3(c * p.x + s * p.z, p.y, -s * p.x + c * p.z);
+}
+
+float3 rotateZ(float3 p, float angle)
+{
+	float s = sin(angle);
+	float c = cos(angle);
+	return float3(c * p.x - s * p.y, s * p.x + c * p.y, p.z);
+}
+
+float3 rotateWorldToPlane(float3 value)
+{
+	float pan = radiansFromDegrees(panDegrees);
+	float tilt = radiansFromDegrees(tiltDegrees);
+	float roll = radiansFromDegrees(rollDegrees);
+	return rotateZ(rotateX(rotateY(value, -pan), -tilt), -roll);
+}
+
+float planeEdgeMask(float2 uv, float2 inputResolution)
+{
+	float2 feather = max(edgeFeather, 0.0) / max(inputResolution, float2(1.0, 1.0));
+	feather = max(feather, float2(0.00001, 0.00001));
+
+	float left = smoothstep(0.0, feather.x, uv.x);
+	float right = 1.0 - smoothstep(1.0 - feather.x, 1.0, uv.x);
+	float top = smoothstep(0.0, feather.y, uv.y);
+	float bottom = 1.0 - smoothstep(1.0 - feather.y, 1.0, uv.y);
+	return saturate(left * right * top * bottom);
+}
+
+float4 shadeVideo(ShaderContext context)
+{
+	float2 outputResolution = max(context.outputResolution, float2(1.0, 1.0));
+	float outputAspect = outputResolution.x / outputResolution.y;
+	float sourceAspect = context.inputResolution.x / max(context.inputResolution.y, 1.0);
+	float tanHalfFov = tan(radiansFromDegrees(clamp(fovDegrees, 5.0, 150.0)) * 0.5);
+
+	float2 screen = float2(context.uv.x * 2.0 - 1.0, 1.0 - context.uv.y * 2.0);
+	float3 rayOrigin = float3(0.0, 0.0, 0.0);
+	float3 rayDirection = normalize(float3(screen.x * outputAspect * tanHalfFov, screen.y * tanHalfFov, 1.0));
+
+	float3 planePosition = float3(positionX, positionY, max(positionZ, 0.001));
+	float3 localOrigin = rotateWorldToPlane(rayOrigin - planePosition);
+	float3 localDirection = rotateWorldToPlane(rayDirection);
+
+	float backgroundAmount = saturate(backgroundMix);
+	float4 background = float4(lerp(outsideColor.rgb, context.sourceColor.rgb, backgroundAmount), 1.0);
+	if (abs(localDirection.z) < 0.00001)
+		return background;
+
+	float hitDistance = -localOrigin.z / localDirection.z;
+	if (hitDistance <= 0.0)
+		return background;
+
+	float3 localHit = localOrigin + localDirection * hitDistance;
+	float halfHeight = max(planeScale, 0.001) * 0.5;
+	float halfWidth = halfHeight * sourceAspect;
+	float2 planeUv = float2(
+		localHit.x / max(halfWidth * 2.0, 0.0001) + 0.5,
+		0.5 - localHit.y / max(halfHeight * 2.0, 0.0001)
+	);
+
+	float mask = planeEdgeMask(planeUv, max(context.inputResolution, float2(1.0, 1.0)));
+	float4 planeColor = sampleVideo(clamp(planeUv, 0.0, 1.0));
+	return saturate(lerp(background, planeColor, mask));
+}

shaders/video-transform/shader.json

@@ -47,6 +47,35 @@
       "step": 0.1,
       "description": "Rotates the source image around the frame center."
     },
+    {
+      "id": "cropAspect",
+      "label": "Crop Aspect",
+      "type": "enum",
+      "default": "none",
+      "options": [
+        {
+          "value": "none",
+          "label": "None"
+        },
+        {
+          "value": "4x3",
+          "label": "4:3"
+        },
+        {
+          "value": "3x2",
+          "label": "3:2"
+        },
+        {
+          "value": "1x1",
+          "label": "1:1"
+        },
+        {
+          "value": "9x16",
+          "label": "9:16"
+        }
+      ],
+      "description": "Crops the visible image to a centered preset aspect ratio without squeezing the source."
+    },
     {
       "id": "edgeMode",
       "label": "Edge Mode",

shaders/video-transform/shader.slang

@@ -28,8 +28,42 @@ float2 applyEdgeMode(float2 uv, out bool inside)
 	return uv;
 }
 
+float selectedCropAspect()
+{
+	if (cropAspect == 1)
+		return 4.0 / 3.0;
+	if (cropAspect == 2)
+		return 3.0 / 2.0;
+	if (cropAspect == 3)
+		return 1.0;
+	if (cropAspect == 4)
+		return 9.0 / 16.0;
+	return 0.0;
+}
+
+bool insideCropWindow(float2 uv, float2 resolution)
+{
+	float targetAspect = selectedCropAspect();
+	if (targetAspect <= 0.0)
+		return true;
+
+	float outputAspect = resolution.x / max(resolution.y, 1.0);
+	float2 cropSize = float2(1.0, 1.0);
+	if (outputAspect > targetAspect)
+		cropSize.x = targetAspect / outputAspect;
+	else
+		cropSize.y = outputAspect / targetAspect;
+
+	float2 cropMin = (1.0 - cropSize) * 0.5;
+	float2 cropMax = cropMin + cropSize;
+	return uv.x >= cropMin.x && uv.x <= cropMax.x && uv.y >= cropMin.y && uv.y <= cropMax.y;
+}
+
 float4 shadeVideo(ShaderContext context)
 {
+	if (!insideCropWindow(context.uv, max(context.outputResolution, float2(1.0, 1.0))))
+		return outsideColor;
+
 	float safeZoom = max(zoom, 0.001);
 	float2 sourceUv = (context.uv - 0.5) / safeZoom + 0.5;
 	sourceUv -= pan;

shaders/waveform-overlay/shader.slang

@@ -18,6 +18,8 @@ float4 shadeVideo(ShaderContext context)
 	float resolutionAspect = max(context.outputResolution.x, 1.0) / max(context.outputResolution.y, 1.0);
 	float width = saturate(overlayScale);
 	float height = width * resolutionAspect / targetAspect;
+	// Keep the scope in a 16:9 frame, then shrink it if the requested scale
+	// would push the overlay beyond the screen bounds.
 	float fitScale = min(1.0 / max(width, 0.001), 1.0 / max(height, 0.001));
 	width *= min(fitScale, 1.0);
 	height *= min(fitScale, 1.0);
@@ -36,6 +38,8 @@ float4 shadeVideo(ShaderContext context)
 
 	float3 bg = lerp(color.rgb, float3(0.0, 0.0, 0.0), saturate(backgroundOpacity));
 	float labelHeight = min(max(pad.x * 0.95, 0.048), 0.12);
+	// Label textures are authored in UV space, so compensate for the overlay
+	// and output aspect ratios to keep the glyphs from stretching.
 	float labelWidth = labelHeight * height * max(context.outputResolution.y, 1.0) / max(width * max(context.outputResolution.x, 1.0), 0.001);
 	float labelX = max(pad.x * 0.5, labelWidth * 0.55);
 	float y0 = pad.y;
@@ -63,6 +67,8 @@ float4 shadeVideo(ShaderContext context)
 	float requestedSamples = clamp(waveformSamples, 1.0, 96.0);
 	float density = 0.0;
 
+	// For each output pixel, march through source rows at the same X coordinate
+	// and accumulate hits where sampled luma lands near this pixel's Y level.
 	for (int sampleIndex = 0; sampleIndex < 96; sampleIndex++)
 	{
 		float samplePosition = float(sampleIndex);

shaders/white-balance-correction/shader.json

@@ -0,0 +1,49 @@
+{
+  "id": "white-balance-correction",
+  "name": "White Balance Correction",
+  "description": "Provides operator-friendly warm/cool, green/magenta, and exposure correction intended to pair with the White Match Probe.",
+  "category": "Color",
+  "entryPoint": "shadeVideo",
+  "parameters": [
+    {
+      "id": "warmCool",
+      "label": "Warm / Cool",
+      "type": "float",
+      "default": 0.0,
+      "min": -1.0,
+      "max": 1.0,
+      "step": 0.001,
+      "description": "Moves the image cooler at negative values and warmer at positive values."
+    },
+    {
+      "id": "greenMagenta",
+      "label": "Green / Magenta",
+      "type": "float",
+      "default": 0.0,
+      "min": -1.0,
+      "max": 1.0,
+      "step": 0.001,
+      "description": "Moves the image toward magenta at negative values and toward green at positive values."
+    },
+    {
+      "id": "exposure",
+      "label": "Exposure",
+      "type": "float",
+      "default": 0.0,
+      "min": -4.0,
+      "max": 4.0,
+      "step": 0.01,
+      "description": "Exposure offset in stop units, using a Blender-style 2^exposure brightness scale."
+    },
+    {
+      "id": "strength",
+      "label": "Strength",
+      "type": "float",
+      "default": 1.0,
+      "min": 0.0,
+      "max": 1.0,
+      "step": 0.01,
+      "description": "Blends the correction with the original image."
+    }
+  ]
+}

shaders/white-balance-correction/shader.slang

@@ -0,0 +1,35 @@
+float3 applyWhiteBalanceOnly(float3 color)
+{
+    float warmAmount = clamp(warmCool, -1.0, 1.0);
+    float tintAmount = clamp(greenMagenta, -1.0, 1.0);
+
+    // Warm/cool pivots red against blue while keeping green more stable.
+    float3 warmCoolGain = float3(
+        exp2(warmAmount * 0.35),
+        exp2(-abs(warmAmount) * 0.08),
+        exp2(-warmAmount * 0.35));
+
+    // Green/magenta pivots green against the average of red and blue.
+    float3 tintGain = float3(
+        exp2(-tintAmount * 0.22),
+        exp2(tintAmount * 0.35),
+        exp2(-tintAmount * 0.22));
+
+    return color * warmCoolGain * tintGain;
+}
+
+float3 applyExposureLikeBlender(float3 color)
+{
+    // Match the compositor-style exposure model: every +1.0 stop doubles the
+    // image and every -1.0 stop halves it.
+    return color * exp2(exposure);
+}
+
+float4 shadeVideo(ShaderContext context)
+{
+    float4 source = context.sourceColor;
+    float3 balanced = applyWhiteBalanceOnly(source.rgb);
+    float3 corrected = applyExposureLikeBlender(balanced);
+    source.rgb = lerp(source.rgb, corrected, saturate(strength));
+    return source;
+}

shaders/white-match-probe/shader.json

@@ -0,0 +1,147 @@
+{
+  "id": "white-match-probe",
+  "name": "White Match Probe",
+  "description": "Samples a movable box, stores a reference color on trigger using shader-local feedback, and compares the current sample against a captured or manual reference for camera matching.",
+  "category": "Scopes & Guides",
+  "entryPoint": "storeReferenceState",
+  "passes": [
+    {
+      "id": "store",
+      "source": "shader.slang",
+      "entryPoint": "storeReferenceState",
+      "output": "referenceState"
+    },
+    {
+      "id": "display",
+      "source": "shader.slang",
+      "entryPoint": "displayReferenceCompare",
+      "inputs": [
+        "referenceState"
+      ],
+      "output": "layerOutput"
+    }
+  ],
+  "feedback": {
+    "enabled": true,
+    "writePass": "store"
+  },
+  "parameters": [
+    {
+      "id": "referenceSource",
+      "label": "Reference Source",
+      "type": "enum",
+      "default": "captured",
+      "options": [
+        {
+          "value": "captured",
+          "label": "Captured Sample"
+        },
+        {
+          "value": "manual",
+          "label": "Manual Color"
+        }
+      ],
+      "description": "Choose whether the probe compares against a captured screen sample or a manually selected reference color."
+    },
+    {
+      "id": "captureReference",
+      "label": "Capture Reference",
+      "type": "trigger",
+      "description": "Stores the current sample box average as the held reference."
+    },
+    {
+      "id": "sampleCenter",
+      "label": "Sample Center",
+      "type": "vec2",
+      "default": [
+        0.5,
+        0.5
+      ],
+      "min": [
+        0.0,
+        0.0
+      ],
+      "max": [
+        1.0,
+        1.0
+      ],
+      "step": [
+        0.001,
+        0.001
+      ],
+      "description": "Center of the sample box in normalized coordinates."
+    },
+    {
+      "id": "sampleSize",
+      "label": "Sample Size",
+      "type": "vec2",
+      "default": [
+        0.14,
+        0.14
+      ],
+      "min": [
+        0.02,
+        0.02
+      ],
+      "max": [
+        0.5,
+        0.5
+      ],
+      "step": [
+        0.001,
+        0.001
+      ],
+      "description": "Width and height of the sample box."
+    },
+    {
+      "id": "manualReference",
+      "label": "Manual Reference",
+      "type": "color",
+      "default": [
+        1.0,
+        1.0,
+        1.0,
+        1.0
+      ],
+      "min": [
+        0.0,
+        0.0,
+        0.0,
+        0.0
+      ],
+      "max": [
+        1.0,
+        1.0,
+        1.0,
+        1.0
+      ],
+      "step": [
+        0.01,
+        0.01,
+        0.01,
+        0.01
+      ],
+      "description": "Manual reference color used when Reference Source is set to Manual Color."
+    },
+    {
+      "id": "overlayOpacity",
+      "label": "Overlay Opacity",
+      "type": "float",
+      "default": 0.9,
+      "min": 0.0,
+      "max": 1.0,
+      "step": 0.01,
+      "description": "Strength of the swatch and box overlay."
+    },
+    {
+      "id": "differenceGain",
+      "label": "Difference Gain",
+      "type": "float",
+      "default": 2.0,
+      "min": 0.0,
+      "max": 8.0,
+      "step": 0.01,
+      "description": "Scales the displayed reference-vs-current difference."
+    }
+  ]
+}

shaders/white-match-probe/shader.slang

@@ -0,0 +1,235 @@
+static const int kReferenceCellIndex = 0;
+static const int kMetadataCellIndex = 1;
+
+float2 cellCenterPixelForIndex(int index)
+{
+    return float2(1.0 + float(index) * 3.0, 1.0);
+}
+
+float2 cellCenterUvForIndex(ShaderContext context, int index)
+{
+    return (cellCenterPixelForIndex(index) + 0.5) / context.outputResolution;
+}
+
+bool pixelIsInsideCell(float2 pixelCoord, int index)
+{
+    float minX = float(index) * 3.0;
+    float maxX = minX + 3.0;
+    return pixelCoord.x >= minX && pixelCoord.x < maxX && pixelCoord.y >= 0.0 && pixelCoord.y < 3.0;
+}
+
+float4 readStoredCell(ShaderContext context, int index)
+{
+    if (context.feedbackAvailable <= 0)
+        return float4(0.0, 0.0, 0.0, 0.0);
+    return sampleFeedback(cellCenterUvForIndex(context, index));
+}
+
+float3 sampleProbeAverage(ShaderContext context)
+{
+    float2 clampedSize = clamp(sampleSize, float2(0.001, 0.001), float2(1.0, 1.0));
+    float2 halfSize = clampedSize * 0.5;
+    float2 minUv = clamp(sampleCenter - halfSize, float2(0.0, 0.0), float2(1.0, 1.0));
+    float2 maxUv = clamp(sampleCenter + halfSize, float2(0.0, 0.0), float2(1.0, 1.0));
+
+    float3 total = float3(0.0, 0.0, 0.0);
+    float weight = 0.0;
+    for (int y = 0; y < 3; ++y)
+    {
+        for (int x = 0; x < 3; ++x)
+        {
+            float2 t = float2((float(x) + 0.5) / 3.0, (float(y) + 0.5) / 3.0);
+            float2 uv = lerp(minUv, maxUv, t);
+            total += sampleLayerInput(uv).rgb;
+            weight += 1.0;
+        }
+    }
+
+    return total / max(weight, 0.0001);
+}
+
+float4 storeReferenceState(ShaderContext context)
+{
+    float2 pixelCoord = floor(context.uv * context.outputResolution);
+    float3 currentSample = sampleProbeAverage(context);
+
+    float previousTriggerCount = context.feedbackAvailable > 0
+        ? readStoredCell(context, kMetadataCellIndex).r
+        : -1.0;
+    float currentTriggerCount = float(captureReference);
+    bool captureNow = context.feedbackAvailable <= 0 || currentTriggerCount > previousTriggerCount + 0.5;
+
+    float3 storedReference = context.feedbackAvailable > 0
+        ? readStoredCell(context, kReferenceCellIndex).rgb
+        : currentSample;
+    if (captureNow)
+        storedReference = currentSample;
+
+    float4 metadata = float4(currentTriggerCount, captureReferenceTime, 0.0, 1.0);
+    if (!captureNow && context.feedbackAvailable > 0)
+        metadata = readStoredCell(context, kMetadataCellIndex);
+
+    if (pixelIsInsideCell(pixelCoord, kReferenceCellIndex))
+        return float4(storedReference, 1.0);
+    if (pixelIsInsideCell(pixelCoord, kMetadataCellIndex))
+        return metadata;
+
+    return float4(0.0, 0.0, 0.0, 1.0);
+}
+
+float rectMask(float2 uv, float2 minUv, float2 maxUv)
+{
+    if (uv.x < minUv.x || uv.x > maxUv.x)
+        return 0.0;
+    if (uv.y < minUv.y || uv.y > maxUv.y)
+        return 0.0;
+    return 1.0;
+}
+
+float borderMask(float2 uv, float2 minUv, float2 maxUv, float thickness)
+{
+    float outer = rectMask(uv, minUv, maxUv);
+    float inner = rectMask(uv, minUv + thickness, maxUv - thickness);
+    return saturate(outer - inner);
+}
+
+float luminance(float3 color)
+{
+    return dot(color, float3(0.2126, 0.7152, 0.0722));
+}
+
+float3 activeReferenceColor(float3 capturedReference)
+{
+    // Enum parameters are exposed as their zero-based option index.
+    // 0 = captured sample, 1 = manual color.
+    return referenceSource == 1 ? manualReference.rgb : capturedReference;
+}
+
+float4 displayReferenceCompare(ShaderContext context)
+{
+    float3 liveColor = sampleLayerInput(context.uv).rgb;
+    float3 currentSample = sampleProbeAverage(context);
+    float3 capturedReference = sampleVideo(cellCenterUvForIndex(context, kReferenceCellIndex)).rgb;
+    float3 storedReference = activeReferenceColor(capturedReference);
+    float3 delta = currentSample - storedReference;
+    float3 absoluteDelta = abs(delta);
+    float differenceMagnitude = max(absoluteDelta.r, max(absoluteDelta.g, absoluteDelta.b));
+
+    float3 displayColor = liveColor;
+    float opacity = saturate(overlayOpacity);
+
+    float2 halfSize = clamp(sampleSize, float2(0.001, 0.001), float2(1.0, 1.0)) * 0.5;
+    float2 boxMin = clamp(sampleCenter - halfSize, float2(0.0, 0.0), float2(1.0, 1.0));
+    float2 boxMax = clamp(sampleCenter + halfSize, float2(0.0, 0.0), float2(1.0, 1.0));
+    float pixelThickness = 2.0 / max(min(context.outputResolution.x, context.outputResolution.y), 1.0);
+    float outerOutline = borderMask(context.uv, boxMin - pixelThickness, boxMax + pixelThickness, pixelThickness);
+    float innerOutline = borderMask(context.uv, boxMin, boxMax, pixelThickness);
+    if (outerOutline > 0.5)
+        displayColor = float3(0.0, 0.0, 0.0);
+    if (innerOutline > 0.5)
+        displayColor = lerp(displayColor, float3(1.0, 0.0, 0.0), opacity);
+
+    float2 swatchSize = float2(0.06, 0.07);
+    float2 panelOrigin = float2(0.03, 0.04);
+    float2 gap = float2(0.075, 0.0);
+    float2 refMin = panelOrigin;
+    float2 curMin = panelOrigin + gap;
+    float2 diffMin = panelOrigin + gap * 2.0;
+    float2 refMax = refMin + swatchSize;
+    float2 curMax = curMin + swatchSize;
+    float2 diffMax = diffMin + swatchSize;
+    float swatchBorder = min(swatchSize.x, swatchSize.y) * 0.08;
+
+    float refFill = rectMask(context.uv, refMin, refMax);
+    float curFill = rectMask(context.uv, curMin, curMax);
+    float diffFill = rectMask(context.uv, diffMin, diffMax);
+    float refOutline = borderMask(context.uv, refMin, refMax, swatchBorder);
+    float curOutline = borderMask(context.uv, curMin, curMax, swatchBorder);
+    float diffOutline = borderMask(context.uv, diffMin, diffMax, swatchBorder);
+
+    if (refFill > 0.5)
+        displayColor = storedReference;
+    if (curFill > 0.5)
+        displayColor = currentSample;
+    if (diffFill > 0.5)
+    {
+        float3 neutralBase = float3(0.5, 0.5, 0.5);
+        float3 signedDeltaDisplay = saturate(neutralBase + delta * max(differenceGain, 0.0) * 0.5);
+        displayColor = signedDeltaDisplay;
+    }
+    if (refOutline > 0.5 || curOutline > 0.5 || diffOutline > 0.5)
+        displayColor = float3(0.0, 0.0, 0.0);
+
+    // Approximate the difference in two operator-friendly axes:
+    // warm/cool leans red versus blue, and green/magenta leans green versus
+    // the average of red and blue. Centered bars make "match" obvious.
+    float warmCool = clamp((delta.r - delta.b) * max(differenceGain, 0.0), -1.0, 1.0);
+    float greenMagenta = clamp((delta.g - (delta.r + delta.b) * 0.5) * max(differenceGain, 0.0), -1.0, 1.0);
+    float brightnessDelta = clamp((luminance(currentSample) - luminance(storedReference)) * max(differenceGain, 0.0) * 1.5, -1.0, 1.0);
+
+    float barWidth = 0.18;
+    float barHeight = 0.018;
+    float halfBarWidth = barWidth * 0.5;
+    float2 warmCoolMin = float2(0.03, 0.13);
+    float2 warmCoolMax = warmCoolMin + float2(barWidth, barHeight);
+    float2 tintMin = float2(0.03, 0.157);
+    float2 tintMax = tintMin + float2(barWidth, barHeight);
+    float2 brightnessMin = float2(0.03, 0.184);
+    float2 brightnessMax = brightnessMin + float2(barWidth, barHeight);
+    float centerX = warmCoolMin.x + halfBarWidth;
+
+    float warmCoolFill = rectMask(context.uv, warmCoolMin, warmCoolMax);
+    float tintFill = rectMask(context.uv, tintMin, tintMax);
+    float brightnessFill = rectMask(context.uv, brightnessMin, brightnessMax);
+    float warmCoolOutline = borderMask(context.uv, warmCoolMin, warmCoolMax, barHeight * 0.12);
+    float tintOutline = borderMask(context.uv, tintMin, tintMax, barHeight * 0.12);
+    float brightnessOutline = borderMask(context.uv, brightnessMin, brightnessMax, barHeight * 0.12);
+    float targetHalfWidth = 0.0015;
+    float warmCoolCenter = rectMask(context.uv, float2(centerX - targetHalfWidth, warmCoolMin.y), float2(centerX + targetHalfWidth, warmCoolMax.y));
+    float tintCenter = rectMask(context.uv, float2(centerX - targetHalfWidth, tintMin.y), float2(centerX + targetHalfWidth, tintMax.y));
+    float brightnessCenter = rectMask(context.uv, float2(centerX - targetHalfWidth, brightnessMin.y), float2(centerX + targetHalfWidth, brightnessMax.y));
+
+    float warmCoolPosition = centerX + warmCool * halfBarWidth;
+    float tintPosition = centerX + greenMagenta * halfBarWidth;
+    float brightnessPosition = centerX + brightnessDelta * halfBarWidth;
+    float indicatorHalfWidth = 0.0018;
+    float warmCoolIndicator = rectMask(context.uv, float2(warmCoolPosition - indicatorHalfWidth, warmCoolMin.y), float2(warmCoolPosition + indicatorHalfWidth, warmCoolMax.y));
+    float tintIndicator = rectMask(context.uv, float2(tintPosition - indicatorHalfWidth, tintMin.y), float2(tintPosition + indicatorHalfWidth, tintMax.y));
+    float brightnessIndicator = rectMask(context.uv, float2(brightnessPosition - indicatorHalfWidth, brightnessMin.y), float2(brightnessPosition + indicatorHalfWidth, brightnessMax.y));
+
+    if (warmCoolFill > 0.5)
+    {
+        float gradientT = saturate((context.uv.x - warmCoolMin.x) / max(barWidth, 0.0001));
+        float3 coolColor = float3(0.18, 0.52, 1.0);
+        float3 warmColor = float3(1.0, 0.48, 0.10);
+        float3 gradientColor = gradientT <= 0.5
+            ? lerp(coolColor, float3(1.0, 1.0, 1.0), gradientT * 2.0)
+            : lerp(float3(1.0, 1.0, 1.0), warmColor, (gradientT - 0.5) * 2.0);
+        displayColor = gradientColor;
+    }
+    if (tintFill > 0.5)
+    {
+        float gradientT = saturate((context.uv.x - tintMin.x) / max(barWidth, 0.0001));
+        float3 magentaColor = float3(1.0, 0.25, 0.75);
+        float3 greenColor = float3(0.18, 0.92, 0.32);
+        float3 gradientColor = gradientT <= 0.5
+            ? lerp(magentaColor, float3(1.0, 1.0, 1.0), gradientT * 2.0)
+            : lerp(float3(1.0, 1.0, 1.0), greenColor, (gradientT - 0.5) * 2.0);
+        displayColor = gradientColor;
+    }
+    if (brightnessFill > 0.5)
+    {
+        float gradientT = saturate((context.uv.x - brightnessMin.x) / max(barWidth, 0.0001));
+        float3 darkColor = float3(0.18, 0.18, 0.18);
+        float3 gradientColor = lerp(darkColor, float3(1.0, 1.0, 1.0), gradientT);
+        displayColor = gradientColor;
+    }
+    if (warmCoolCenter > 0.5 || tintCenter > 0.5 || brightnessCenter > 0.5)
+        displayColor = float3(0.12, 0.45, 1.0);
+    if (warmCoolIndicator > 0.5 || tintIndicator > 0.5 || brightnessIndicator > 0.5)
+        displayColor = float3(1.0, 0.0, 0.0);
+    if (warmCoolOutline > 0.5 || tintOutline > 0.5 || brightnessOutline > 0.5)
+        displayColor = float3(0.0, 0.0, 0.0);
+
+    return float4(saturate(displayColor), 1.0);
+}

shaders/xyla-exposure-chart/shader.slang

@@ -1,5 +1,7 @@
 float boxMask(float2 point, float2 halfSize, float feather)
 {
+	// Signed-distance box mask gives the chart and border pixel-sized feathered
+	// edges without branching per side.
 	float2 distanceToEdge = abs(point) - halfSize;
 	float outsideDistance = length(max(distanceToEdge, float2(0.0, 0.0)));
 	float insideDistance = min(max(distanceToEdge.x, distanceToEdge.y), 0.0);
@@ -31,6 +33,8 @@ float applyToneCurve(float linearLevel)
 float patchBrightness(int patchIndex, int count)
 {
 	int clampedIndex = clamp(patchIndex, 0, max(count - 1, 0));
+	// Each patch is one stop brighter than the previous patch until it clips at
+	// the requested peak level, matching the Xyla-style exposure ramp.
 	float linearLevel = baseLevel * exp2(float(clampedIndex));
 	linearLevel = min(linearLevel, peakLevel);
 	return applyToneCurve(linearLevel);
@@ -60,6 +64,8 @@ float4 shadeVideo(ShaderContext context)
 	if (reverseOrder)
 		patchIndex = count - 1 - patchIndex;
 
+	// Build each patch as a slot along the main axis, then mask the cross-axis
+	// extents so vertical and horizontal charts share the same logic.
 	float patchSlotCenter = (floor(patchPosition) + 0.5) / float(count);
 	float localAxis = abs(normalizedAxis - patchSlotCenter) * float(count) * 2.0;
 	float safeGapSize = saturate(gapSize);

tests/OscServerTests.cpp

@@ -74,6 +74,11 @@ struct OscServerTestAccess
 		return server.DispatchMessage(message, error);
 	}
 
+	static bool TryParseBindAddress(const std::string& bindAddress, in_addr& address, std::string& error)
+	{
+		return OscServer::TryParseBindAddress(bindAddress, address, error);
+	}
+
 	static void SetUpdateParameterCallback(
 		OscServer& server,
 		const std::function<bool(const std::string&, const std::string&, const std::string&, std::string&)>& callback)
@@ -191,6 +196,23 @@ void TestRejectsUnsupportedAddress()
 	Expect(!called, "unsupported OSC namespace does not invoke callback");
 	Expect(!error.empty(), "unsupported OSC address reports an error");
 }
+
+void TestParsesOscBindAddress()
+{
+	in_addr loopback = {};
+	std::string error;
+	Expect(OscServerTestAccess::TryParseBindAddress("127.0.0.1", loopback, error), "loopback OSC bind address parses");
+	Expect(loopback.S_un.S_addr != 0, "loopback OSC bind address produces a socket address");
+
+	in_addr wildcard = {};
+	error.clear();
+	Expect(OscServerTestAccess::TryParseBindAddress("0.0.0.0", wildcard, error), "wildcard OSC bind address parses");
+
+	in_addr invalid = {};
+	error.clear();
+	Expect(!OscServerTestAccess::TryParseBindAddress("localhost", invalid, error), "hostname OSC bind address is rejected");
+	Expect(!error.empty(), "invalid OSC bind address reports an error");
+}
 }
 
 int main()
@@ -201,6 +223,7 @@ int main()
 	TestDecodeIntStringAndBoolMessages();
 	TestDispatchValidAddress();
 	TestRejectsUnsupportedAddress();
+	TestParsesOscBindAddress();
 
 	if (gFailures != 0)
 	{

tests/ShaderPackageRegistryTests.cpp

@@ -58,6 +58,7 @@ void TestValidManifest()
 		"textures": [{ "id": "maskTex", "path": "mask.png" }],
 		"fonts": [{ "id": "inter", "path": "Inter.ttf" }],
 		"temporal": { "enabled": true, "historySource": "source", "historyLength": 8 },
+		"feedback": { "enabled": true },
 		"parameters": [
 			{ "id": "gain", "label": "Gain", "description": "Scales the output intensity.", "type": "float", "default": 0.5, "min": 0, "max": 1 },
 			{ "id": "titleText", "label": "Title", "type": "text", "default": "LIVE", "font": "inter", "maxLength": 32 },
@@ -77,6 +78,7 @@ void TestValidManifest()
 	Expect(package.textureAssets.size() == 1 && package.textureAssets[0].id == "maskTex", "texture assets parse");
 	Expect(package.fontAssets.size() == 1 && package.fontAssets[0].id == "inter", "font assets parse");
 	Expect(package.temporal.enabled && package.temporal.effectiveHistoryLength == 4, "temporal history is capped");
+	Expect(package.feedback.enabled && package.feedback.writePassId == "main", "feedback defaults to the implicit main pass");
 	Expect(package.parameters.size() == 4, "parameters parse");
 	Expect(package.parameters[0].description == "Scales the output intensity.", "parameter descriptions parse");
 	Expect(package.parameters[1].type == ShaderParameterType::Text && package.parameters[1].defaultTextValue == "LIVE", "text parameter parses");
@@ -96,6 +98,7 @@ void TestExplicitPassManifest()
 			{ "id": "blurX", "source": "blur-x.slang", "entryPoint": "blurHorizontal", "inputs": ["layerInput"], "output": "blurredX" },
 			{ "id": "final", "source": "final.slang", "entryPoint": "finish", "inputs": ["blurredX"], "output": "layerOutput" }
 		],
+		"feedback": { "enabled": true, "writePass": "blurX" },
 		"parameters": []
 	})");
 	WriteFile(root / "multi" / "blur-x.slang", "float4 blurHorizontal(float2 uv) { return float4(uv, 0.0, 1.0); }\n");
@@ -109,6 +112,7 @@ void TestExplicitPassManifest()
 	Expect(package.passes[0].id == "blurX" && package.passes[0].entryPoint == "blurHorizontal", "first pass metadata parses");
 	Expect(package.passes[0].inputNames.size() == 1 && package.passes[0].inputNames[0] == "layerInput", "pass inputs parse");
 	Expect(package.passes[1].outputName == "layerOutput", "pass output parses");
+	Expect(package.feedback.enabled && package.feedback.writePassId == "blurX", "explicit feedback write pass parses");
 
 	std::filesystem::remove_all(root);
 }
@@ -190,6 +194,25 @@ void TestInvalidTemporalSettings()
 	std::filesystem::remove_all(root);
 }
 
+void TestInvalidFeedbackSettings()
+{
+	const std::filesystem::path root = MakeTestRoot();
+	WriteShaderPackage(root, "bad-feedback", R"({
+		"id": "bad-feedback",
+		"name": "Bad Feedback",
+		"feedback": { "enabled": true, "writePass": "missingPass" },
+		"parameters": []
+	})");
+
+	ShaderPackageRegistry registry(4);
+	ShaderPackage package;
+	std::string error;
+	Expect(!registry.ParseManifest(root / "bad-feedback" / "shader.json", package, error), "invalid feedback manifest is rejected");
+	Expect(error.find("writePass") != std::string::npos, "invalid feedback error names writePass");
+
+	std::filesystem::remove_all(root);
+}
+
 void TestDisabledTemporalSettingsAreIgnored()
 {
 	const std::filesystem::path root = MakeTestRoot();
@@ -264,6 +287,7 @@ int main()
 	TestMissingFontAsset();
 	TestInvalidManifest();
 	TestInvalidTemporalSettings();
+	TestInvalidFeedbackSettings();
 	TestDisabledTemporalSettingsAreIgnored();
 	TestDuplicateScan();
 	TestInvalidPackageDoesNotFailScan();

ui/src/components/StackPresetToolbar.jsx

@@ -11,6 +11,12 @@ export function StackPresetToolbar({
   onSelectedPresetNameChange,
 }) {
   const [screenshotQueued, setScreenshotQueued] = useState(false);
+  const trimmedPresetName = presetName.trim();
+  const normalizedPresetName = trimmedPresetName
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "");
+  const willOverwrite = normalizedPresetName ? stackPresets.includes(normalizedPresetName) : false;
 
   async function requestScreenshot() {
     setScreenshotQueued(true);
@@ -61,23 +67,34 @@ export function StackPresetToolbar({
             />
             <button
               type="button"
-              className="button-with-icon"
-              disabled={!presetName.trim()}
-              onClick={() => {
-                const trimmedName = presetName.trim();
-                if (!trimmedName) {
+              className={`button-with-icon${willOverwrite ? " stack-panel__save--overwrite" : ""}`}
+              disabled={!trimmedPresetName}
+              onClick={async () => {
+                if (!trimmedPresetName) {
                   return;
                 }
-                postJson("/api/stack-presets/save", { presetName: trimmedName });
-                onSelectedPresetNameChange(
-                  trimmedName.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, ""),
-                );
+                const response = await postJson("/api/stack-presets/save", { presetName: trimmedPresetName });
+                if (response?.ok) {
+                  onSelectedPresetNameChange(normalizedPresetName);
+                  onPresetNameChange("");
+                }
               }}
             >
               <Save size={16} strokeWidth={1.9} aria-hidden="true" />
-              <span>Save</span>
+              <span>{willOverwrite ? "Overwrite" : "Save"}</span>
             </button>
           </div>
+          {trimmedPresetName ? (
+            <p className="muted toolbar__status" role="status">
+              {willOverwrite
+                ? `This will overwrite the existing preset "${normalizedPresetName}".`
+                : `This will save as "${normalizedPresetName}".`}
+            </p>
+          ) : (
+            <p className="muted toolbar__status toolbar__status--placeholder" aria-hidden="true">
+              Preset status
+            </p>
+          )}
         </div>
 
         <div className="toolbar__group">
@@ -109,6 +126,9 @@ export function StackPresetToolbar({
               <span>Recall</span>
             </button>
           </div>
+          <p className="muted toolbar__status toolbar__status--placeholder" aria-hidden="true">
+            Preset status
+          </p>
         </div>
       </div>
     </div>

ui/src/hooks/useThrottledParameterValue.js

@@ -34,6 +34,27 @@ export function useThrottledParameterValue(parameter, onParameterChange) {
     }
   }, [draftValue, currentValue]);
 
+  useEffect(() => {
+    if (isInteractingRef.current) {
+      return;
+    }
+
+    if (valuesMatch(currentValue, latestDraftRef.current)) {
+      return;
+    }
+
+    if (pendingTimeoutRef.current) {
+      clearTimeout(pendingTimeoutRef.current);
+      pendingTimeoutRef.current = null;
+    }
+
+    setDraftValue(currentValue);
+    setAppliedValue(currentValue);
+    latestDraftRef.current = currentValue;
+    isDirtyRef.current = false;
+    lastSentAtRef.current = 0;
+  }, [currentValue]);
+
   useEffect(() => {
     return () => {
       if (pendingTimeoutRef.current) {

ui/src/styles.css

@@ -515,19 +515,46 @@ pre {
 
 .toolbar__group {
   display: grid;
+  grid-template-rows: auto auto auto;
+  align-content: start;
   gap: 0.5rem;
   min-width: 0;
 }
 
 .toolbar__inline {
-  grid-template-columns: minmax(0, 1fr) auto;
+  grid-template-columns: minmax(0, 1fr) 9.5rem;
   align-items: stretch;
   gap: 0.5rem;
 }
 
+.toolbar__inline input,
+.toolbar__inline select,
 .toolbar__inline button {
-  width: auto;
-  min-width: var(--button-min-width);
+  min-height: 3rem;
+}
+
+.toolbar__inline button {
+  width: 100%;
+  min-width: 9.5rem;
+}
+
+.stack-panel__save--overwrite {
+  background: #b42318;
+  border-color: #8f1d13;
+  color: #fff7f5;
+}
+
+.stack-panel__save--overwrite:hover:not(:disabled) {
+  background: #912018;
+}
+
+.toolbar__status {
+  min-height: 1.6rem;
+  margin: 0;
+}
+
+.toolbar__status--placeholder {
+  visibility: hidden;
 }
 
 .layer-stack {