Refactor

apps/LoopThroughWithOpenGLCompositing/control/ControlServer.cpp

@@ -0,0 +1,627 @@
+#include "stdafx.h"
+#include "ControlServer.h"
+
+#include "RuntimeJson.h"
+
+#include <Wincrypt.h>
+#include <ws2tcpip.h>
+
+#include <algorithm>
+#include <fstream>
+#include <sstream>
+
+#pragma comment(lib, "Ws2_32.lib")
+#pragma comment(lib, "Crypt32.lib")
+#pragma comment(lib, "Advapi32.lib")
+
+namespace
+{
+constexpr DWORD kStateBroadcastIntervalMs = 250;
+
+bool InitializeWinsock(std::string& error)
+{
+	WSADATA wsaData = {};
+	int result = WSAStartup(MAKEWORD(2, 2), &wsaData);
+	if (result != 0)
+	{
+		error = "WSAStartup failed.";
+		return false;
+	}
+	return true;
+}
+
+std::string ToLower(std::string text)
+{
+	std::transform(text.begin(), text.end(), text.begin(),
+		[](unsigned char ch) { return static_cast<char>(std::tolower(ch)); });
+	return text;
+}
+
+bool IsSafeUiPath(const std::filesystem::path& relativePath)
+{
+	for (const std::filesystem::path& part : relativePath)
+	{
+		if (part == "..")
+			return false;
+	}
+	return !relativePath.empty();
+}
+
+std::string GuessContentType(const std::filesystem::path& assetPath)
+{
+	const std::string extension = ToLower(assetPath.extension().string());
+	if (extension == ".js" || extension == ".mjs")
+		return "text/javascript";
+	if (extension == ".css")
+		return "text/css";
+	if (extension == ".json")
+		return "application/json";
+	if (extension == ".yaml" || extension == ".yml")
+		return "application/yaml";
+	if (extension == ".svg")
+		return "image/svg+xml";
+	if (extension == ".png")
+		return "image/png";
+	if (extension == ".jpg" || extension == ".jpeg")
+		return "image/jpeg";
+	if (extension == ".ico")
+		return "image/x-icon";
+	if (extension == ".map")
+		return "application/json";
+	if (extension == ".md")
+		return "text/markdown";
+	return "text/html";
+}
+}
+
+ControlServer::ControlServer()
+	: mPort(0), mRunning(false)
+{
+}
+
+ControlServer::~ControlServer()
+{
+	Stop();
+}
+
+bool ControlServer::Start(const std::filesystem::path& uiRoot, const std::filesystem::path& docsRoot, unsigned short preferredPort, const Callbacks& callbacks, std::string& error)
+{
+	mUiRoot = uiRoot;
+	mDocsRoot = docsRoot;
+	mCallbacks = callbacks;
+
+	if (!InitializeWinsock(error))
+		return false;
+
+	mListenSocket.reset(socket(AF_INET, SOCK_STREAM, IPPROTO_TCP));
+	if (!mListenSocket.valid())
+	{
+		error = "Could not create listening socket.";
+		return false;
+	}
+
+	u_long nonBlocking = 1;
+	ioctlsocket(mListenSocket.get(), FIONBIO, &nonBlocking);
+
+	sockaddr_in address = {};
+	address.sin_family = AF_INET;
+	address.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
+
+	bool bound = false;
+	for (unsigned short offset = 0; offset < 20; ++offset)
+	{
+		address.sin_port = htons(static_cast<u_short>(preferredPort + offset));
+		if (bind(mListenSocket.get(), reinterpret_cast<sockaddr*>(&address), sizeof(address)) == 0)
+		{
+			mPort = preferredPort + offset;
+			bound = true;
+			break;
+		}
+	}
+
+	if (!bound)
+	{
+		error = "Could not bind the local control server to any port in the preferred range.";
+		mListenSocket.reset();
+		return false;
+	}
+
+	if (listen(mListenSocket.get(), SOMAXCONN) != 0)
+	{
+		error = "Could not start listening on the local control server socket.";
+		mListenSocket.reset();
+		return false;
+	}
+
+	mRunning = true;
+	mThread = std::thread(&ControlServer::ServerLoop, this);
+	return true;
+}
+
+void ControlServer::Stop()
+{
+	const bool wasActive = mRunning || mListenSocket.valid() || mThread.joinable();
+	mRunning = false;
+
+	{
+		std::lock_guard<std::mutex> lock(mMutex);
+		for (ClientConnection& client : mClients)
+			client.socket.reset();
+		mClients.clear();
+	}
+
+	mListenSocket.reset();
+
+	if (mThread.joinable())
+		mThread.join();
+
+	if (wasActive)
+		WSACleanup();
+}
+
+void ControlServer::BroadcastState()
+{
+	std::lock_guard<std::mutex> lock(mMutex);
+	BroadcastStateLocked();
+}
+
+void ControlServer::ServerLoop()
+{
+	DWORD lastStateBroadcastMs = GetTickCount();
+	while (mRunning)
+	{
+		TryAcceptClient();
+
+		const DWORD nowMs = GetTickCount();
+		if (nowMs - lastStateBroadcastMs >= kStateBroadcastIntervalMs)
+		{
+			BroadcastState();
+			lastStateBroadcastMs = nowMs;
+		}
+
+		Sleep(25);
+	}
+}
+
+bool ControlServer::HandleHttpClient(UniqueSocket clientSocket)
+{
+	std::string request;
+	char buffer[8192];
+	int received = recv(clientSocket.get(), buffer, sizeof(buffer), 0);
+	if (received <= 0)
+		return false;
+
+	request.assign(buffer, buffer + received);
+	return HandleHttpRequest(std::move(clientSocket), request);
+}
+
+bool ControlServer::TryAcceptClient()
+{
+	sockaddr_in clientAddress = {};
+	int addressSize = sizeof(clientAddress);
+	UniqueSocket clientSocket(accept(mListenSocket.get(), reinterpret_cast<sockaddr*>(&clientAddress), &addressSize));
+	if (!clientSocket.valid())
+		return false;
+
+	return HandleHttpClient(std::move(clientSocket));
+}
+
+bool ControlServer::SendHttpResponse(SOCKET clientSocket, const std::string& status, const std::string& contentType, const std::string& body)
+{
+	std::ostringstream response;
+	response << "HTTP/1.1 " << status << "\r\n";
+	response << "Content-Type: " << contentType << "\r\n";
+	response << "Content-Length: " << body.size() << "\r\n";
+	response << "Connection: close\r\n\r\n";
+	response << body;
+
+	const std::string payload = response.str();
+	return send(clientSocket, payload.c_str(), static_cast<int>(payload.size()), 0) == static_cast<int>(payload.size());
+}
+
+bool ControlServer::SendHttpResponse(SOCKET clientSocket, const HttpResponse& response)
+{
+	return SendHttpResponse(clientSocket, response.status, response.contentType, response.body);
+}
+
+bool ControlServer::HandleHttpRequest(UniqueSocket clientSocket, const std::string& request)
+{
+	HttpRequest httpRequest;
+	if (!ParseHttpRequest(request, httpRequest))
+	{
+		SendHttpResponse(clientSocket.get(), "400 Bad Request", "text/plain", "Bad Request");
+		return true;
+	}
+
+	if (ToLower(GetHeaderValue(httpRequest, "Upgrade")) == "websocket")
+		return HandleWebSocketUpgrade(std::move(clientSocket), httpRequest);
+
+	const HttpResponse response = RouteHttpRequest(httpRequest);
+	SendHttpResponse(clientSocket.get(), response);
+	if (response.broadcastState)
+		BroadcastState();
+	return true;
+}
+
+ControlServer::HttpResponse ControlServer::RouteHttpRequest(const HttpRequest& request)
+{
+	if (request.method == "GET")
+		return ServeGetRequest(request);
+
+	if (request.method == "POST")
+		return HandleApiPost(request);
+
+	return { "404 Not Found", "text/plain", "Not Found" };
+}
+
+ControlServer::HttpResponse ControlServer::ServeGetRequest(const HttpRequest& request) const
+{
+	if (request.path == "/" || request.path == "/index.html")
+		return ServeUiAsset("index.html");
+
+	if (request.path == "/api/state")
+		return { "200 OK", "application/json", mCallbacks.getStateJson ? mCallbacks.getStateJson() : "{}" };
+
+	if (request.path == "/openapi.yaml" || request.path == "/docs/openapi.yaml")
+		return ServeOpenApiSpec();
+
+	if (request.path == "/docs" || request.path == "/docs/")
+		return ServeSwaggerDocs();
+
+	const std::string docsPrefix = "/docs/";
+	if (request.path.rfind(docsPrefix, 0) == 0)
+		return ServeDocsAsset(request.path.substr(docsPrefix.size()));
+
+	if (request.path.size() > 1)
+	{
+		const HttpResponse assetResponse = ServeUiAsset(request.path.substr(1));
+		if (!assetResponse.body.empty())
+			return assetResponse;
+	}
+
+	return { "404 Not Found", "text/plain", "Not Found" };
+}
+
+ControlServer::HttpResponse ControlServer::ServeUiAsset(const std::string& relativePath) const
+{
+	std::string contentType;
+	const std::string body = LoadUiAsset(relativePath, contentType);
+	return body.empty()
+		? HttpResponse{ "404 Not Found", "text/plain", "Not Found" }
+		: HttpResponse{ "200 OK", contentType, body };
+}
+
+ControlServer::HttpResponse ControlServer::ServeDocsAsset(const std::string& relativePath) const
+{
+	const std::filesystem::path sanitizedPath = std::filesystem::path(relativePath).lexically_normal();
+	if (!IsSafeUiPath(sanitizedPath))
+		return { "404 Not Found", "text/plain", "Not Found" };
+
+	const std::filesystem::path docsPath = mDocsRoot / sanitizedPath;
+	const std::string body = LoadTextFile(docsPath);
+	return body.empty()
+		? HttpResponse{ "404 Not Found", "text/plain", "Not Found" }
+		: HttpResponse{ "200 OK", GuessContentType(docsPath), body };
+}
+
+ControlServer::HttpResponse ControlServer::ServeOpenApiSpec() const
+{
+	const std::filesystem::path specPath = mDocsRoot / "openapi.yaml";
+	const std::string body = LoadTextFile(specPath);
+	return body.empty()
+		? HttpResponse{ "404 Not Found", "text/plain", "OpenAPI spec not found" }
+		: HttpResponse{ "200 OK", GuessContentType(specPath), body };
+}
+
+ControlServer::HttpResponse ControlServer::ServeSwaggerDocs() const
+{
+	std::ostringstream html;
+	html << "<!doctype html>\n"
+		<< "<html lang=\"en\">\n"
+		<< "<head>\n"
+		<< "  <meta charset=\"utf-8\">\n"
+		<< "  <meta name=\"viewport\" content=\"width=device-width, initial-scale=1\">\n"
+		<< "  <title>Video Shader Toys API Docs</title>\n"
+		<< "  <link rel=\"stylesheet\" href=\"https://unpkg.com/swagger-ui-dist@5/swagger-ui.css\">\n"
+		<< "</head>\n"
+		<< "<body>\n"
+		<< "  <div id=\"swagger-ui\"></div>\n"
+		<< "  <script src=\"https://unpkg.com/swagger-ui-dist@5/swagger-ui-bundle.js\"></script>\n"
+		<< "  <script>SwaggerUIBundle({url:'/docs/openapi.yaml',dom_id:'#swagger-ui'});</script>\n"
+		<< "</body>\n"
+		<< "</html>\n";
+	return { "200 OK", "text/html", html.str() };
+}
+
+ControlServer::HttpResponse ControlServer::HandleApiPost(const HttpRequest& request)
+{
+	JsonValue root;
+	std::string parseError;
+	if (!ParseJson(request.body, root, parseError))
+		return { "400 Bad Request", "application/json", BuildJsonResponse(false, parseError) };
+
+	std::string actionError;
+	const bool success = InvokePostRoute(request.path, root, actionError);
+	return {
+		success ? "200 OK" : "400 Bad Request",
+		"application/json",
+		BuildJsonResponse(success, actionError),
+		success
+	};
+}
+
+bool ControlServer::InvokePostRoute(const std::string& path, const JsonValue& root, std::string& actionError)
+{
+	using PostHandler = std::function<bool(const JsonValue&, std::string&)>;
+	const std::map<std::string, PostHandler> postRoutes =
+	{
+		{ "/api/layers/add", [this](const JsonValue& json, std::string& error)
+			{
+				const JsonValue* shaderId = json.find("shaderId");
+				return shaderId && mCallbacks.addLayer && mCallbacks.addLayer(shaderId->asString(), error);
+			}
+		},
+		{ "/api/layers/remove", [this](const JsonValue& json, std::string& error)
+			{
+				const JsonValue* layerId = json.find("layerId");
+				return layerId && mCallbacks.removeLayer && mCallbacks.removeLayer(layerId->asString(), error);
+			}
+		},
+		{ "/api/layers/move", [this](const JsonValue& json, std::string& error)
+			{
+				const JsonValue* layerId = json.find("layerId");
+				const JsonValue* direction = json.find("direction");
+				return layerId && direction && mCallbacks.moveLayer &&
+					mCallbacks.moveLayer(layerId->asString(), static_cast<int>(direction->asNumber()), error);
+			}
+		},
+		{ "/api/layers/reorder", [this](const JsonValue& json, std::string& error)
+			{
+				const JsonValue* layerId = json.find("layerId");
+				const JsonValue* targetIndex = json.find("targetIndex");
+				return layerId && targetIndex && mCallbacks.moveLayerToIndex &&
+					mCallbacks.moveLayerToIndex(layerId->asString(), static_cast<std::size_t>(targetIndex->asNumber()), error);
+			}
+		},
+		{ "/api/layers/set-bypass", [this](const JsonValue& json, std::string& error)
+			{
+				const JsonValue* layerId = json.find("layerId");
+				const JsonValue* bypass = json.find("bypass");
+				return layerId && bypass && mCallbacks.setLayerBypass &&
+					mCallbacks.setLayerBypass(layerId->asString(), bypass->asBoolean(), error);
+			}
+		},
+		{ "/api/layers/set-shader", [this](const JsonValue& json, std::string& error)
+			{
+				const JsonValue* layerId = json.find("layerId");
+				const JsonValue* shaderId = json.find("shaderId");
+				return layerId && shaderId && mCallbacks.setLayerShader &&
+					mCallbacks.setLayerShader(layerId->asString(), shaderId->asString(), error);
+			}
+		},
+		{ "/api/layers/update-parameter", [this](const JsonValue& json, std::string& error)
+			{
+				const JsonValue* layerId = json.find("layerId");
+				const JsonValue* parameterId = json.find("parameterId");
+				const JsonValue* value = json.find("value");
+				return layerId && parameterId && value && mCallbacks.updateLayerParameter &&
+					mCallbacks.updateLayerParameter(layerId->asString(), parameterId->asString(), SerializeJson(*value, false), error);
+			}
+		},
+		{ "/api/layers/reset-parameters", [this](const JsonValue& json, std::string& error)
+			{
+				const JsonValue* layerId = json.find("layerId");
+				return layerId && mCallbacks.resetLayerParameters &&
+					mCallbacks.resetLayerParameters(layerId->asString(), error);
+			}
+		},
+		{ "/api/stack-presets/save", [this](const JsonValue& json, std::string& error)
+			{
+				const JsonValue* presetName = json.find("presetName");
+				return presetName && mCallbacks.saveStackPreset &&
+					mCallbacks.saveStackPreset(presetName->asString(), error);
+			}
+		},
+		{ "/api/stack-presets/load", [this](const JsonValue& json, std::string& error)
+			{
+				const JsonValue* presetName = json.find("presetName");
+				return presetName && mCallbacks.loadStackPreset &&
+					mCallbacks.loadStackPreset(presetName->asString(), error);
+			}
+		},
+		{ "/api/reload", [this](const JsonValue&, std::string& error)
+			{
+				return mCallbacks.reloadShader && mCallbacks.reloadShader(error);
+			}
+		}
+	};
+
+	const auto route = postRoutes.find(path);
+	return route != postRoutes.end() && route->second(root, actionError);
+}
+
+bool ControlServer::HandleWebSocketUpgrade(UniqueSocket clientSocket, const HttpRequest& request)
+{
+	const std::string clientKey = GetHeaderValue(request, "Sec-WebSocket-Key");
+	if (clientKey.empty())
+	{
+		SendHttpResponse(clientSocket.get(), "400 Bad Request", "text/plain", "Missing Sec-WebSocket-Key");
+		return true;
+	}
+
+	std::ostringstream response;
+	response << "HTTP/1.1 101 Switching Protocols\r\n";
+	response << "Upgrade: websocket\r\n";
+	response << "Connection: Upgrade\r\n";
+	response << "Sec-WebSocket-Accept: " << ComputeWebSocketAcceptKey(clientKey) << "\r\n\r\n";
+
+	const std::string payload = response.str();
+	send(clientSocket.get(), payload.c_str(), static_cast<int>(payload.size()), 0);
+
+	{
+		std::lock_guard<std::mutex> lock(mMutex);
+		ClientConnection client;
+		client.socket.reset(clientSocket.release());
+		client.websocket = true;
+		mClients.push_back(std::move(client));
+		BroadcastStateLocked();
+	}
+	return true;
+}
+
+bool ControlServer::SendWebSocketText(SOCKET clientSocket, const std::string& payload)
+{
+	std::string frame;
+	frame.push_back(static_cast<char>(0x81));
+	if (payload.size() <= 125)
+	{
+		frame.push_back(static_cast<char>(payload.size()));
+	}
+	else if (payload.size() <= 65535)
+	{
+		frame.push_back(126);
+		frame.push_back(static_cast<char>((payload.size() >> 8) & 0xFF));
+		frame.push_back(static_cast<char>(payload.size() & 0xFF));
+	}
+	else
+	{
+		frame.push_back(127);
+		for (int shift = 56; shift >= 0; shift -= 8)
+			frame.push_back(static_cast<char>((payload.size() >> shift) & 0xFF));
+	}
+	frame.append(payload);
+
+	return send(clientSocket, frame.data(), static_cast<int>(frame.size()), 0) == static_cast<int>(frame.size());
+}
+
+void ControlServer::BroadcastStateLocked()
+{
+	const std::string stateMessage = mCallbacks.getStateJson ? mCallbacks.getStateJson() : "{}";
+	for (auto it = mClients.begin(); it != mClients.end();)
+	{
+		if (!SendWebSocketText(it->socket.get(), stateMessage))
+		{
+			it = mClients.erase(it);
+		}
+		else
+		{
+			++it;
+		}
+	}
+}
+
+std::string ControlServer::LoadUiAsset(const std::string& relativePath, std::string& contentType) const
+{
+	const std::filesystem::path sanitizedPath = std::filesystem::path(relativePath).lexically_normal();
+	if (!IsSafeUiPath(sanitizedPath))
+		return std::string();
+
+	const std::filesystem::path assetPath = mUiRoot / sanitizedPath;
+	contentType = GuessContentType(assetPath);
+	return LoadTextFile(assetPath);
+}
+
+std::string ControlServer::LoadTextFile(const std::filesystem::path& path) const
+{
+	std::ifstream input(path, std::ios::binary);
+	if (!input)
+		return std::string();
+
+	std::ostringstream buffer;
+	buffer << input.rdbuf();
+	return buffer.str();
+}
+
+std::string ControlServer::BuildJsonResponse(bool success, const std::string& error) const
+{
+	JsonValue response = JsonValue::MakeObject();
+	response.set("ok", JsonValue(success));
+	if (!error.empty())
+		response.set("error", JsonValue(error));
+	return SerializeJson(response, false);
+}
+
+std::string ControlServer::Base64Encode(const unsigned char* data, DWORD dataLength)
+{
+	DWORD outputLength = 0;
+	CryptBinaryToStringA(data, dataLength, CRYPT_STRING_BASE64 | CRYPT_STRING_NOCRLF, NULL, &outputLength);
+	std::string encoded(outputLength, '\0');
+	CryptBinaryToStringA(data, dataLength, CRYPT_STRING_BASE64 | CRYPT_STRING_NOCRLF, &encoded[0], &outputLength);
+	if (!encoded.empty() && encoded.back() == '\0')
+		encoded.pop_back();
+	return encoded;
+}
+
+std::string ControlServer::ComputeWebSocketAcceptKey(const std::string& clientKey)
+{
+	const std::string combined = clientKey + "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
+	HCRYPTPROV provider = 0;
+	HCRYPTHASH hash = 0;
+	BYTE digest[20] = {};
+	DWORD digestLength = sizeof(digest);
+
+	CryptAcquireContext(&provider, NULL, NULL, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT);
+	CryptCreateHash(provider, CALG_SHA1, 0, 0, &hash);
+	CryptHashData(hash, reinterpret_cast<const BYTE*>(combined.data()), static_cast<DWORD>(combined.size()), 0);
+	CryptGetHashParam(hash, HP_HASHVAL, digest, &digestLength, 0);
+
+	if (hash)
+		CryptDestroyHash(hash);
+	if (provider)
+		CryptReleaseContext(provider, 0);
+
+	return Base64Encode(digest, digestLength);
+}
+
+std::string ControlServer::GetHeaderValue(const HttpRequest& request, const std::string& headerName)
+{
+	const auto header = request.headers.find(ToLower(headerName));
+	return header == request.headers.end() ? std::string() : header->second;
+}
+
+bool ControlServer::ParseHttpRequest(const std::string& rawRequest, HttpRequest& request)
+{
+	const std::size_t requestLineEnd = rawRequest.find("\r\n");
+	if (requestLineEnd == std::string::npos)
+		return false;
+
+	const std::string requestLine = rawRequest.substr(0, requestLineEnd);
+	const std::size_t methodEnd = requestLine.find(' ');
+	if (methodEnd == std::string::npos)
+		return false;
+
+	const std::size_t pathEnd = requestLine.find(' ', methodEnd + 1);
+	if (pathEnd == std::string::npos)
+		return false;
+
+	request.method = requestLine.substr(0, methodEnd);
+	request.path = requestLine.substr(methodEnd + 1, pathEnd - methodEnd - 1);
+	request.headers.clear();
+
+	const std::size_t headersStart = requestLineEnd + 2;
+	const std::size_t bodySeparator = rawRequest.find("\r\n\r\n", headersStart);
+	const std::size_t headersEnd = bodySeparator == std::string::npos ? rawRequest.size() : bodySeparator;
+
+	for (std::size_t lineStart = headersStart; lineStart < headersEnd;)
+	{
+		const std::size_t lineEnd = rawRequest.find("\r\n", lineStart);
+		const std::size_t currentLineEnd = lineEnd == std::string::npos ? headersEnd : std::min(lineEnd, headersEnd);
+		const std::string line = rawRequest.substr(lineStart, currentLineEnd - lineStart);
+		const std::size_t separator = line.find(':');
+		if (separator != std::string::npos)
+		{
+			const std::string key = ToLower(line.substr(0, separator));
+			std::string value = line.substr(separator + 1);
+			const std::size_t first = value.find_first_not_of(" \t");
+			const std::size_t last = value.find_last_not_of(" \t");
+			request.headers[key] = first == std::string::npos ? std::string() : value.substr(first, last - first + 1);
+		}
+
+		if (lineEnd == std::string::npos || lineEnd >= headersEnd)
+			break;
+		lineStart = lineEnd + 2;
+	}
+
+	request.body = bodySeparator == std::string::npos ? std::string() : rawRequest.substr(bodySeparator + 4);
+	return !request.method.empty() && !request.path.empty();
+}

apps/LoopThroughWithOpenGLCompositing/control/ControlServer.h

@@ -0,0 +1,104 @@
+#pragma once
+
+#include "NativeSockets.h"
+
+#include <winsock2.h>
+
+#include <atomic>
+#include <filesystem>
+#include <functional>
+#include <map>
+#include <mutex>
+#include <string>
+#include <thread>
+#include <vector>
+
+class JsonValue;
+
+class ControlServer
+{
+public:
+	struct Callbacks
+	{
+		std::function<std::string()> getStateJson;
+		std::function<bool(const std::string&, std::string&)> addLayer;
+		std::function<bool(const std::string&, std::string&)> removeLayer;
+		std::function<bool(const std::string&, int, std::string&)> moveLayer;
+		std::function<bool(const std::string&, std::size_t, std::string&)> moveLayerToIndex;
+		std::function<bool(const std::string&, bool, std::string&)> setLayerBypass;
+		std::function<bool(const std::string&, const std::string&, std::string&)> setLayerShader;
+		std::function<bool(const std::string&, const std::string&, const std::string&, std::string&)> updateLayerParameter;
+		std::function<bool(const std::string&, std::string&)> resetLayerParameters;
+		std::function<bool(const std::string&, std::string&)> saveStackPreset;
+		std::function<bool(const std::string&, std::string&)> loadStackPreset;
+		std::function<bool(std::string&)> reloadShader;
+	};
+
+	ControlServer();
+	~ControlServer();
+
+	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();
+
+	unsigned short GetPort() const { return mPort; }
+
+private:
+	struct ClientConnection
+	{
+		UniqueSocket socket;
+		bool websocket = false;
+	};
+
+	struct HttpRequest
+	{
+		std::string method;
+		std::string path;
+		std::map<std::string, std::string> headers;
+		std::string body;
+	};
+
+	struct HttpResponse
+	{
+		std::string status;
+		std::string contentType;
+		std::string body;
+		bool broadcastState = false;
+	};
+
+	void ServerLoop();
+	bool HandleHttpClient(UniqueSocket clientSocket);
+	bool TryAcceptClient();
+	bool SendHttpResponse(SOCKET clientSocket, const HttpResponse& response);
+	bool SendHttpResponse(SOCKET clientSocket, const std::string& status, const std::string& contentType, const std::string& body);
+	bool HandleHttpRequest(UniqueSocket clientSocket, const std::string& request);
+	bool HandleWebSocketUpgrade(UniqueSocket clientSocket, const HttpRequest& request);
+	HttpResponse RouteHttpRequest(const HttpRequest& request);
+	HttpResponse ServeGetRequest(const HttpRequest& request) const;
+	HttpResponse ServeUiAsset(const std::string& relativePath) const;
+	HttpResponse ServeDocsAsset(const std::string& relativePath) const;
+	HttpResponse ServeOpenApiSpec() const;
+	HttpResponse ServeSwaggerDocs() const;
+	HttpResponse HandleApiPost(const HttpRequest& request);
+	bool InvokePostRoute(const std::string& path, const JsonValue& root, std::string& actionError);
+	bool SendWebSocketText(SOCKET clientSocket, const std::string& payload);
+	void BroadcastStateLocked();
+	std::string LoadUiAsset(const std::string& relativePath, std::string& contentType) const;
+	std::string LoadTextFile(const std::filesystem::path& path) const;
+	std::string BuildJsonResponse(bool success, const std::string& error = std::string()) const;
+	static std::string Base64Encode(const unsigned char* data, DWORD dataLength);
+	static std::string ComputeWebSocketAcceptKey(const std::string& clientKey);
+	static std::string GetHeaderValue(const HttpRequest& request, const std::string& headerName);
+	static bool ParseHttpRequest(const std::string& rawRequest, HttpRequest& request);
+
+private:
+	std::filesystem::path mUiRoot;
+	std::filesystem::path mDocsRoot;
+	Callbacks mCallbacks;
+	UniqueSocket mListenSocket;
+	unsigned short mPort;
+	std::thread mThread;
+	std::atomic<bool> mRunning;
+	mutable std::mutex mMutex;
+	std::vector<ClientConnection> mClients;
+};

apps/LoopThroughWithOpenGLCompositing/control/OscServer.cpp

@@ -0,0 +1,314 @@
+#include "stdafx.h"
+#include "OscServer.h"
+
+#include <ws2tcpip.h>
+
+#include <array>
+#include <cstring>
+#include <iomanip>
+#include <sstream>
+#include <vector>
+
+#pragma comment(lib, "Ws2_32.lib")
+
+namespace
+{
+bool InitializeWinsock(std::string& error)
+{
+	WSADATA wsaData = {};
+	const int result = WSAStartup(MAKEWORD(2, 2), &wsaData);
+	if (result != 0)
+	{
+		error = "WSAStartup failed.";
+		return false;
+	}
+	return true;
+}
+
+std::vector<std::string> SplitAddress(const std::string& address)
+{
+	std::vector<std::string> parts;
+	std::size_t start = !address.empty() && address[0] == '/' ? 1 : 0;
+
+	while (start <= address.size())
+	{
+		const std::size_t slash = address.find('/', start);
+		const std::size_t end = slash == std::string::npos ? address.size() : slash;
+		if (end > start)
+			parts.push_back(address.substr(start, end - start));
+		if (slash == std::string::npos)
+			break;
+		start = slash + 1;
+	}
+	return parts;
+}
+
+}
+
+OscServer::OscServer()
+	: mPort(0), mRunning(false)
+{
+}
+
+OscServer::~OscServer()
+{
+	Stop();
+}
+
+bool OscServer::Start(unsigned short port, const Callbacks& callbacks, std::string& error)
+{
+	if (port == 0)
+		return true;
+
+	mCallbacks = callbacks;
+	mPort = port;
+
+	if (!InitializeWinsock(error))
+		return false;
+
+	mSocket.reset(socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP));
+	if (!mSocket.valid())
+	{
+		error = "Could not create OSC UDP socket.";
+		return false;
+	}
+
+	DWORD timeoutMilliseconds = 100;
+	setsockopt(mSocket.get(), SOL_SOCKET, SO_RCVTIMEO, reinterpret_cast<const char*>(&timeoutMilliseconds), sizeof(timeoutMilliseconds));
+
+	sockaddr_in address = {};
+	address.sin_family = AF_INET;
+	address.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
+	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) + ".";
+		mSocket.reset();
+		return false;
+	}
+
+	mRunning = true;
+	mThread = std::thread(&OscServer::ServerLoop, this);
+	return true;
+}
+
+void OscServer::Stop()
+{
+	mRunning = false;
+	mSocket.reset();
+	if (mThread.joinable())
+		mThread.join();
+}
+
+void OscServer::ServerLoop()
+{
+	std::array<char, 4096> buffer = {};
+	while (mRunning)
+	{
+		sockaddr_in sender = {};
+		int senderLength = sizeof(sender);
+		const int byteCount = recvfrom(mSocket.get(), buffer.data(), static_cast<int>(buffer.size()), 0,
+			reinterpret_cast<sockaddr*>(&sender), &senderLength);
+		if (byteCount <= 0)
+			continue;
+
+		OscMessage message;
+		std::string error;
+		if (DecodeMessage(buffer.data(), byteCount, message, error))
+		{
+			if (!DispatchMessage(message, error) && !error.empty())
+				OutputDebugStringA(("OSC dispatch failed: " + error + "\n").c_str());
+		}
+		else if (!error.empty())
+		{
+			OutputDebugStringA(("OSC decode failed: " + error + "\n").c_str());
+		}
+	}
+}
+
+bool OscServer::DecodeMessage(const char* data, int byteCount, OscMessage& message, std::string& error) const
+{
+	int offset = 0;
+	if (!ReadPaddedString(data, byteCount, offset, message.address) || message.address.empty() || message.address[0] != '/')
+	{
+		error = "Invalid OSC address.";
+		return false;
+	}
+
+	std::string typeTags;
+	if (!ReadPaddedString(data, byteCount, offset, typeTags) || typeTags.empty() || typeTags[0] != ',')
+	{
+		error = "Invalid OSC type tag string.";
+		return false;
+	}
+
+	if (typeTags.size() < 2)
+	{
+		error = "OSC message has no parameter value.";
+		return false;
+	}
+
+	std::vector<std::string> values;
+	for (std::size_t index = 1; index < typeTags.size(); ++index)
+	{
+		std::string valueJson;
+		if (!DecodeArgument(data, byteCount, offset, typeTags[index], valueJson))
+		{
+			error = "Unsupported or malformed OSC value type.";
+			return false;
+		}
+		values.push_back(valueJson);
+	}
+
+	if (values.size() == 1)
+	{
+		message.valueJson = values.front();
+		return true;
+	}
+
+	std::ostringstream arrayJson;
+	arrayJson << "[";
+	for (std::size_t index = 0; index < values.size(); ++index)
+	{
+		if (index > 0)
+			arrayJson << ",";
+		arrayJson << values[index];
+	}
+	arrayJson << "]";
+	message.valueJson = arrayJson.str();
+	return true;
+}
+
+bool OscServer::DispatchMessage(const OscMessage& message, std::string& error) const
+{
+	const std::vector<std::string> parts = SplitAddress(message.address);
+	if (parts.size() != 3 || parts[0] != "VideoShaderToys")
+	{
+		error = "Unsupported OSC address: " + message.address;
+		return false;
+	}
+
+	return mCallbacks.updateParameter &&
+		mCallbacks.updateParameter(parts[1], parts[2], message.valueJson, error);
+}
+
+bool OscServer::DecodeArgument(const char* data, int byteCount, int& offset, char valueType, std::string& valueJson)
+{
+	if (valueType == 'f')
+	{
+		double value = 0.0;
+		if (!ReadFloat32(data, byteCount, offset, value))
+			return false;
+		std::ostringstream stream;
+		stream << std::setprecision(9) << value;
+		valueJson = stream.str();
+		return true;
+	}
+
+	if (valueType == 'd')
+	{
+		double value = 0.0;
+		if (!ReadFloat64(data, byteCount, offset, value))
+			return false;
+		std::ostringstream stream;
+		stream << std::setprecision(17) << value;
+		valueJson = stream.str();
+		return true;
+	}
+
+	if (valueType == 'i')
+	{
+		int value = 0;
+		if (!ReadInt32(data, byteCount, offset, value))
+			return false;
+		valueJson = std::to_string(value);
+		return true;
+	}
+
+	if (valueType == 's')
+	{
+		std::string value;
+		if (!ReadPaddedString(data, byteCount, offset, value))
+			return false;
+		valueJson = BuildJsonString(value);
+		return true;
+	}
+
+	if (valueType == 'T' || valueType == 'F')
+	{
+		valueJson = valueType == 'T' ? "true" : "false";
+		return true;
+	}
+
+	return false;
+}
+
+bool OscServer::ReadPaddedString(const char* data, int byteCount, int& offset, std::string& value)
+{
+	if (offset < 0 || offset >= byteCount)
+		return false;
+
+	const int start = offset;
+	while (offset < byteCount && data[offset] != '\0')
+		++offset;
+	if (offset >= byteCount)
+		return false;
+
+	value.assign(data + start, data + offset);
+	++offset;
+	while (offset % 4 != 0)
+		++offset;
+	return offset <= byteCount;
+}
+
+bool OscServer::ReadInt32(const char* data, int byteCount, int& offset, int& value)
+{
+	if (offset + 4 > byteCount)
+		return false;
+	const unsigned char* bytes = reinterpret_cast<const unsigned char*>(data + offset);
+	value = static_cast<int>((bytes[0] << 24) | (bytes[1] << 16) | (bytes[2] << 8) | bytes[3]);
+	offset += 4;
+	return true;
+}
+
+bool OscServer::ReadFloat32(const char* data, int byteCount, int& offset, double& value)
+{
+	int bits = 0;
+	if (!ReadInt32(data, byteCount, offset, bits))
+		return false;
+
+	float floatValue = 0.0f;
+	const unsigned int unsignedBits = static_cast<unsigned int>(bits);
+	std::memcpy(&floatValue, &unsignedBits, sizeof(floatValue));
+	value = static_cast<double>(floatValue);
+	return true;
+}
+
+bool OscServer::ReadFloat64(const char* data, int byteCount, int& offset, double& value)
+{
+	if (offset + 8 > byteCount)
+		return false;
+
+	const unsigned char* bytes = reinterpret_cast<const unsigned char*>(data + offset);
+	uint64_t bits = 0;
+	for (int index = 0; index < 8; ++index)
+		bits = (bits << 8) | static_cast<uint64_t>(bytes[index]);
+
+	std::memcpy(&value, &bits, sizeof(value));
+	offset += 8;
+	return true;
+}
+
+std::string OscServer::BuildJsonString(const std::string& value)
+{
+	std::ostringstream stream;
+	stream << '"';
+	for (char ch : value)
+	{
+		if (ch == '"' || ch == '\\')
+			stream << '\\';
+		stream << ch;
+	}
+	stream << '"';
+	return stream.str();
+}

apps/LoopThroughWithOpenGLCompositing/control/OscServer.h

@@ -0,0 +1,52 @@
+#pragma once
+
+#include "NativeSockets.h"
+
+#include <winsock2.h>
+
+#include <atomic>
+#include <functional>
+#include <string>
+#include <thread>
+
+class OscServer
+{
+public:
+	struct Callbacks
+	{
+		std::function<bool(const std::string&, const std::string&, const std::string&, std::string&)> updateParameter;
+	};
+
+	OscServer();
+	~OscServer();
+
+	bool Start(unsigned short port, const Callbacks& callbacks, std::string& error);
+	void Stop();
+
+	unsigned short GetPort() const { return mPort; }
+
+private:
+	friend struct OscServerTestAccess;
+
+	struct OscMessage
+	{
+		std::string address;
+		std::string valueJson;
+	};
+
+	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 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);
+	static bool ReadFloat32(const char* data, int byteCount, int& offset, double& value);
+	static bool ReadFloat64(const char* data, int byteCount, int& offset, double& value);
+	static std::string BuildJsonString(const std::string& value);
+
+	Callbacks mCallbacks;
+	UniqueSocket mSocket;
+	unsigned short mPort;
+	std::thread mThread;
+	std::atomic<bool> mRunning;
+};

apps/LoopThroughWithOpenGLCompositing/control/RuntimeControlBridge.cpp

@@ -0,0 +1,50 @@
+#include "RuntimeControlBridge.h"
+
+#include "ControlServer.h"
+#include "OpenGLComposite.h"
+#include "OscServer.h"
+#include "RuntimeHost.h"
+
+bool StartRuntimeControlServices(
+	OpenGLComposite& composite,
+	RuntimeHost& runtimeHost,
+	ControlServer& controlServer,
+	OscServer& oscServer,
+	std::string& error)
+{
+	ControlServer::Callbacks callbacks;
+	callbacks.getStateJson = [&composite]() { return composite.GetRuntimeStateJson(); };
+	callbacks.addLayer = [&composite](const std::string& shaderId, std::string& actionError) { return composite.AddLayer(shaderId, actionError); };
+	callbacks.removeLayer = [&composite](const std::string& layerId, std::string& actionError) { return composite.RemoveLayer(layerId, actionError); };
+	callbacks.moveLayer = [&composite](const std::string& layerId, int direction, std::string& actionError) { return composite.MoveLayer(layerId, direction, actionError); };
+	callbacks.moveLayerToIndex = [&composite](const std::string& layerId, std::size_t targetIndex, std::string& actionError) { return composite.MoveLayerToIndex(layerId, targetIndex, actionError); };
+	callbacks.setLayerBypass = [&composite](const std::string& layerId, bool bypassed, std::string& actionError) { return composite.SetLayerBypass(layerId, bypassed, actionError); };
+	callbacks.setLayerShader = [&composite](const std::string& layerId, const std::string& shaderId, std::string& actionError) { return composite.SetLayerShader(layerId, shaderId, actionError); };
+	callbacks.updateLayerParameter = [&composite](const std::string& layerId, const std::string& parameterId, const std::string& valueJson, std::string& actionError) {
+		return composite.UpdateLayerParameterJson(layerId, parameterId, valueJson, actionError);
+	};
+	callbacks.resetLayerParameters = [&composite](const std::string& layerId, std::string& actionError) { return composite.ResetLayerParameters(layerId, actionError); };
+	callbacks.saveStackPreset = [&composite](const std::string& presetName, std::string& actionError) { return composite.SaveStackPreset(presetName, actionError); };
+	callbacks.loadStackPreset = [&composite](const std::string& presetName, std::string& actionError) { return composite.LoadStackPreset(presetName, actionError); };
+	callbacks.reloadShader = [&composite](std::string& actionError) {
+		if (!composite.ReloadShader())
+		{
+			actionError = "Shader reload failed. See native app status for details.";
+			return false;
+		}
+		return true;
+	};
+
+	if (!controlServer.Start(runtimeHost.GetUiRoot(), runtimeHost.GetDocsRoot(), runtimeHost.GetServerPort(), callbacks, error))
+		return false;
+	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);
+	};
+	if (runtimeHost.GetOscPort() > 0 && !oscServer.Start(runtimeHost.GetOscPort(), oscCallbacks, error))
+		return false;
+
+	return true;
+}

apps/LoopThroughWithOpenGLCompositing/control/RuntimeControlBridge.h

@@ -0,0 +1,15 @@
+#pragma once
+
+#include <string>
+
+class ControlServer;
+class OpenGLComposite;
+class OscServer;
+class RuntimeHost;
+
+bool StartRuntimeControlServices(
+	OpenGLComposite& composite,
+	RuntimeHost& runtimeHost,
+	ControlServer& controlServer,
+	OscServer& oscServer,
+	std::string& error);