end point adjsutments

apps/RenderCadenceCompositor/README.md

@@ -44,6 +44,7 @@ Included now:
 - app-owned submission of a completed shader artifact
 - render-thread-only GL commit once the artifact is ready
 - manifest-driven stateless single-pass shader packages
+- HTTP shader list populated from supported stateless single-pass shader packages
 - default float, vec2, color, boolean, enum, and trigger parameters
 - small JSON writer for future HTTP/WebSocket payloads
 - JSON serialization for cadence telemetry snapshots
@@ -145,7 +146,7 @@ The app starts a local HTTP control server on `http://127.0.0.1:8080` by default
 Current endpoints:
 
 - `GET /` and UI asset paths: serve the bundled control UI from `ui/dist`
-- `GET /api/state`: returns an OpenAPI-shaped state scaffold with cadence telemetry under `performance.cadence`
+- `GET /api/state`: returns OpenAPI-shaped display data with cadence telemetry, supported shaders, output status, and a read-only current runtime layer
 - `GET /docs/openapi.yaml` and `GET /openapi.yaml`: serves the OpenAPI document
 - `GET /docs`: serves Swagger UI
 - OpenAPI POST routes are present but return `{ "ok": false, "error": "Endpoint is not implemented in RenderCadenceCompositor yet." }`
@@ -205,6 +206,10 @@ Current runtime shader support is deliberately limited to stateless single-pass
 - manifest defaults are used for parameters
 - `gVideoInput` and `gLayerInput` are bound to a small fallback source texture until DeckLink input is added
 
+The `/api/state` shader list uses the same support rules as runtime shader compilation and reports only packages this app can run today. Unsupported manifest feature sets such as multipass, temporal, feedback, texture-backed, font-backed, or text-parameter shaders are hidden from the control UI for now.
+
+The current runtime shader is also exposed as a read-only display layer with manifest parameter defaults. POST control endpoints still intentionally return "not implemented" responses until the control/state ownership model is ported.
+
 Successful handoff signs:
 
 - telemetry shows `shaderCommitted=1`

apps/RenderCadenceCompositor/app/RenderCadenceApp.h

@@ -4,6 +4,7 @@
 #include "AppConfigProvider.h"
 #include "../logging/Logger.h"
 #include "../runtime/RuntimeShaderBridge.h"
+#include "../runtime/SupportedShaderCatalog.h"
 #include "../control/RuntimeStateJson.h"
 #include "../telemetry/TelemetryHealthMonitor.h"
 #include "../video/DeckLinkOutput.h"
@@ -11,6 +12,7 @@
 
 #include <chrono>
 #include <filesystem>
+#include <mutex>
 #include <string>
 #include <thread>
 #include <type_traits>
@@ -68,6 +70,8 @@ public:
 
 	bool Start(std::string& error)
 	{
+		LoadSupportedShaderCatalog();
+
 		Log("app", "Starting render thread.");
 		if (!detail::StartRenderThread(mRenderThread, error, 0))
 		{
@@ -187,12 +191,17 @@ private:
 	std::string BuildStateJson()
 	{
 		CadenceTelemetrySnapshot telemetry = mHttpTelemetry.Sample(mFrameExchange, mOutput, mOutputThread, mRenderThread);
+		RuntimeDisplayState runtimeState = CopyRuntimeDisplayState(telemetry);
 		return RuntimeStateToJson(RuntimeStateJsonInput{
 			mConfig,
 			telemetry,
 			mHttpServer.Port(),
 			mVideoOutputEnabled,
-			mVideoOutputStatus
+			mVideoOutputStatus,
+			mShaderCatalog.Shaders(),
+			runtimeState.compileSucceeded,
+			runtimeState.compileMessage,
+			runtimeState.activeShaderPackage
 		});
 	}
 
@@ -217,21 +226,69 @@ private:
 		}
 
 		Log("runtime-shader", "Starting background Slang build for shader '" + mConfig.runtimeShaderId + "'.");
+		SetRuntimeDisplayState(true, "Runtime Slang build started for shader '" + mConfig.runtimeShaderId + "'.", mConfig.runtimeShaderId);
 		mShaderBridge.Start(
 			mConfig.runtimeShaderId,
 			[this](const RuntimeShaderArtifact& artifact) {
+				SetRuntimeDisplayState(true, artifact.message.empty() ? "Runtime shader artifact is ready." : artifact.message, artifact.shaderId);
 				mRenderThread.SubmitRuntimeShaderArtifact(artifact);
 			},
-			[](const std::string& message) {
+			[this](const std::string& message) {
+				SetRuntimeDisplayState(false, message);
 				LogError("runtime-shader", "Runtime Slang build failed: " + message);
 			});
 	}
 
+	void LoadSupportedShaderCatalog()
+	{
+		const std::filesystem::path shaderRoot = FindRepoPath(mConfig.shaderLibrary);
+		std::string error;
+		if (!mShaderCatalog.Load(shaderRoot, static_cast<unsigned>(mConfig.maxTemporalHistoryFrames), error))
+		{
+			LogWarning("runtime-shader", "Supported shader catalog is empty: " + error);
+			return;
+		}
+
+		Log("runtime-shader", "Supported shader catalog loaded with " + std::to_string(mShaderCatalog.Shaders().size()) + " shader(s).");
+	}
+
 	void StopRuntimeShaderBuild()
 	{
 		mShaderBridge.Stop();
 	}
 
+	struct RuntimeDisplayState
+	{
+		bool compileSucceeded = true;
+		std::string compileMessage;
+		const ShaderPackage* activeShaderPackage = nullptr;
+	};
+
+	void SetRuntimeDisplayState(bool compileSucceeded, const std::string& compileMessage, const std::string& activeShaderId = std::string())
+	{
+		std::lock_guard<std::mutex> lock(mRuntimeDisplayMutex);
+		mRuntimeCompileSucceeded = compileSucceeded;
+		mRuntimeCompileMessage = compileMessage;
+		if (!activeShaderId.empty())
+			mActiveShaderId = activeShaderId;
+	}
+
+	RuntimeDisplayState CopyRuntimeDisplayState(const CadenceTelemetrySnapshot& telemetry) const
+	{
+		std::lock_guard<std::mutex> lock(mRuntimeDisplayMutex);
+		RuntimeDisplayState state;
+		state.compileSucceeded = mRuntimeCompileSucceeded && telemetry.shaderBuildFailures == 0;
+		state.compileMessage = mRuntimeCompileMessage;
+		if (telemetry.shaderBuildFailures > 0)
+			state.compileMessage = "Runtime shader GL commit failed; see logs for details.";
+		if (state.compileMessage.empty())
+			state.compileMessage = mConfig.runtimeShaderId.empty()
+				? "Runtime shader build disabled."
+				: "Runtime shader build has not completed yet.";
+		state.activeShaderPackage = mShaderCatalog.FindPackage(mActiveShaderId);
+		return state;
+	}
+
 	RenderThread& mRenderThread;
 	SystemFrameExchange& mFrameExchange;
 	AppConfig mConfig;
@@ -241,6 +298,11 @@ private:
 	CadenceTelemetry mHttpTelemetry;
 	HttpControlServer mHttpServer;
 	RuntimeShaderBridge mShaderBridge;
+	SupportedShaderCatalog mShaderCatalog;
+	mutable std::mutex mRuntimeDisplayMutex;
+	bool mRuntimeCompileSucceeded = true;
+	std::string mRuntimeCompileMessage;
+	std::string mActiveShaderId;
 	bool mStarted = false;
 	bool mVideoOutputEnabled = false;
 	std::string mVideoOutputStatus = "DeckLink output not started.";

apps/RenderCadenceCompositor/control/RuntimeStateJson.h

@@ -3,10 +3,12 @@
 #include "../app/AppConfig.h"
 #include "../app/AppConfigProvider.h"
 #include "../json/JsonWriter.h"
+#include "../runtime/SupportedShaderCatalog.h"
 #include "../telemetry/CadenceTelemetryJson.h"
 
 #include <cstdint>
 #include <string>
+#include <vector>
 
 namespace RenderCadenceCompositor
 {
@@ -17,6 +19,10 @@ struct RuntimeStateJsonInput
 	unsigned short serverPort = 0;
 	bool videoOutputEnabled = false;
 	std::string videoOutputStatus;
+	const std::vector<SupportedShaderSummary>& shaders;
+	bool runtimeCompileSucceeded = true;
+	std::string runtimeCompileMessage;
+	const ShaderPackage* activeShaderPackage = nullptr;
 };
 
 inline void WriteVideoIoStatusJson(JsonWriter& writer, const RuntimeStateJsonInput& input)
@@ -33,6 +39,153 @@ inline void WriteVideoIoStatusJson(JsonWriter& writer, const RuntimeStateJsonInp
 	writer.EndObject();
 }
 
+inline void OutputDimensions(const RuntimeStateJsonInput& input, unsigned& width, unsigned& height)
+{
+	VideoFormatDimensions(input.config.outputVideoFormat, width, height);
+}
+
+inline const char* ShaderParameterTypeName(ShaderParameterType type)
+{
+	switch (type)
+	{
+	case ShaderParameterType::Float: return "float";
+	case ShaderParameterType::Vec2: return "vec2";
+	case ShaderParameterType::Color: return "color";
+	case ShaderParameterType::Boolean: return "bool";
+	case ShaderParameterType::Enum: return "enum";
+	case ShaderParameterType::Text: return "text";
+	case ShaderParameterType::Trigger: return "trigger";
+	}
+	return "unknown";
+}
+
+inline void WriteNumberArray(JsonWriter& writer, const std::vector<double>& values)
+{
+	writer.BeginArray();
+	for (double value : values)
+		writer.Double(value);
+	writer.EndArray();
+}
+
+inline void WriteDefaultParameterValue(JsonWriter& writer, const ShaderParameterDefinition& parameter)
+{
+	switch (parameter.type)
+	{
+	case ShaderParameterType::Boolean:
+		writer.Bool(parameter.defaultBoolean);
+		return;
+	case ShaderParameterType::Enum:
+		writer.String(parameter.defaultEnumValue);
+		return;
+	case ShaderParameterType::Text:
+		writer.String(parameter.defaultTextValue);
+		return;
+	case ShaderParameterType::Trigger:
+		writer.Double(0.0);
+		return;
+	case ShaderParameterType::Float:
+		writer.Double(parameter.defaultNumbers.empty() ? 0.0 : parameter.defaultNumbers.front());
+		return;
+	case ShaderParameterType::Vec2:
+	case ShaderParameterType::Color:
+		WriteNumberArray(writer, parameter.defaultNumbers);
+		return;
+	}
+	writer.Null();
+}
+
+inline void WriteTemporalJson(JsonWriter& writer, const TemporalSettings& temporal)
+{
+	writer.BeginObject();
+	writer.KeyBool("enabled", temporal.enabled);
+	writer.KeyString("historySource", "none");
+	writer.KeyUInt("requestedHistoryLength", temporal.requestedHistoryLength);
+	writer.KeyUInt("effectiveHistoryLength", temporal.effectiveHistoryLength);
+	writer.EndObject();
+}
+
+inline void WriteFeedbackJson(JsonWriter& writer, const FeedbackSettings& feedback)
+{
+	writer.BeginObject();
+	writer.KeyBool("enabled", feedback.enabled);
+	writer.KeyString("writePass", feedback.writePassId);
+	writer.EndObject();
+}
+
+inline void WriteParameterDefinitionJson(JsonWriter& writer, const ShaderParameterDefinition& parameter)
+{
+	writer.BeginObject();
+	writer.KeyString("id", parameter.id);
+	writer.KeyString("label", parameter.label.empty() ? parameter.id : parameter.label);
+	writer.KeyString("description", parameter.description);
+	writer.KeyString("type", ShaderParameterTypeName(parameter.type));
+	writer.Key("defaultValue");
+	WriteDefaultParameterValue(writer, parameter);
+	writer.Key("value");
+	WriteDefaultParameterValue(writer, parameter);
+
+	if (!parameter.minNumbers.empty())
+	{
+		writer.Key("min");
+		WriteNumberArray(writer, parameter.minNumbers);
+	}
+	if (!parameter.maxNumbers.empty())
+	{
+		writer.Key("max");
+		WriteNumberArray(writer, parameter.maxNumbers);
+	}
+	if (!parameter.stepNumbers.empty())
+	{
+		writer.Key("step");
+		WriteNumberArray(writer, parameter.stepNumbers);
+	}
+	if (parameter.type == ShaderParameterType::Enum)
+	{
+		writer.Key("options");
+		writer.BeginArray();
+		for (const ShaderParameterOption& option : parameter.enumOptions)
+		{
+			writer.BeginObject();
+			writer.KeyString("value", option.value);
+			writer.KeyString("label", option.label.empty() ? option.value : option.label);
+			writer.EndObject();
+		}
+		writer.EndArray();
+	}
+	if (parameter.type == ShaderParameterType::Text)
+	{
+		writer.KeyUInt("maxLength", parameter.maxLength);
+		if (!parameter.fontId.empty())
+			writer.KeyString("font", parameter.fontId);
+	}
+	writer.EndObject();
+}
+
+inline void WriteLayersJson(JsonWriter& writer, const RuntimeStateJsonInput& input)
+{
+	writer.BeginArray();
+	if (input.activeShaderPackage)
+	{
+		const ShaderPackage& shaderPackage = *input.activeShaderPackage;
+		writer.BeginObject();
+		writer.KeyString("id", "runtime-layer-1");
+		writer.KeyString("shaderId", shaderPackage.id);
+		writer.KeyString("shaderName", shaderPackage.displayName.empty() ? shaderPackage.id : shaderPackage.displayName);
+		writer.KeyBool("bypass", false);
+		writer.Key("temporal");
+		WriteTemporalJson(writer, shaderPackage.temporal);
+		writer.Key("feedback");
+		WriteFeedbackJson(writer, shaderPackage.feedback);
+		writer.Key("parameters");
+		writer.BeginArray();
+		for (const ShaderParameterDefinition& parameter : shaderPackage.parameters)
+			WriteParameterDefinitionJson(writer, parameter);
+		writer.EndArray();
+		writer.EndObject();
+	}
+	writer.EndArray();
+}
+
 inline std::string RuntimeStateToJson(const RuntimeStateJsonInput& input)
 {
 	JsonWriter writer;
@@ -56,17 +209,20 @@ inline std::string RuntimeStateToJson(const RuntimeStateJsonInput& input)
 
 	writer.Key("runtime");
 	writer.BeginObject();
-	writer.KeyUInt("layerCount", 0);
-	writer.KeyBool("compileSucceeded", true);
-	writer.KeyString("compileMessage", "Runtime state is not ported into RenderCadenceCompositor yet.");
+	writer.KeyUInt("layerCount", input.activeShaderPackage ? 1 : 0);
+	writer.KeyBool("compileSucceeded", input.runtimeCompileSucceeded);
+	writer.KeyString("compileMessage", input.runtimeCompileMessage);
 	writer.EndObject();
 
 	writer.Key("video");
 	writer.BeginObject();
-	writer.KeyBool("hasSignal", false);
-	writer.KeyNull("width");
-	writer.KeyNull("height");
-	writer.KeyString("modeName", "output-only");
+	unsigned outputWidth = 0;
+	unsigned outputHeight = 0;
+	OutputDimensions(input, outputWidth, outputHeight);
+	writer.KeyBool("hasSignal", input.videoOutputEnabled);
+	writer.KeyUInt("width", outputWidth);
+	writer.KeyUInt("height", outputHeight);
+	writer.KeyString("modeName", input.config.outputVideoFormat + " output-only");
 	writer.EndObject();
 
 	writer.Key("decklink");
@@ -94,13 +250,23 @@ inline std::string RuntimeStateToJson(const RuntimeStateJsonInput& input)
 	writer.KeyNull("runtimeEvents");
 	writer.Key("shaders");
 	writer.BeginArray();
+	for (const SupportedShaderSummary& shader : input.shaders)
+	{
+		writer.BeginObject();
+		writer.KeyString("id", shader.id);
+		writer.KeyString("name", shader.name);
+		writer.KeyString("description", shader.description);
+		writer.KeyString("category", shader.category);
+		writer.KeyBool("available", true);
+		writer.KeyNull("error");
+		writer.EndObject();
+	}
 	writer.EndArray();
 	writer.Key("stackPresets");
 	writer.BeginArray();
 	writer.EndArray();
 	writer.Key("layers");
-	writer.BeginArray();
-	writer.EndArray();
+	WriteLayersJson(writer, input);
 
 	writer.EndObject();
 	return writer.StringValue();

apps/RenderCadenceCompositor/runtime/RuntimeSlangShaderCompiler.cpp

@@ -3,10 +3,10 @@
 #include "ShaderCompiler.h"
 #include "ShaderPackageRegistry.h"
 #include "ShaderTypes.h"
+#include "SupportedShaderCatalog.h"
 
 #include <chrono>
 #include <filesystem>
-#include <iostream>
 
 namespace
 {
@@ -28,43 +28,6 @@ std::filesystem::path FindRepoRoot()
 	}
 }
 
-bool IsStatelessSinglePassPackage(const ShaderPackage& shaderPackage, std::string& error)
-{
-	if (shaderPackage.passes.size() != 1)
-	{
-		error = "RenderCadenceCompositor currently supports only single-pass runtime shaders.";
-		return false;
-	}
-	if (shaderPackage.temporal.enabled)
-	{
-		error = "RenderCadenceCompositor currently supports only stateless shaders; temporal history is not enabled in this app.";
-		return false;
-	}
-	if (shaderPackage.feedback.enabled)
-	{
-		error = "RenderCadenceCompositor currently supports only stateless shaders; feedback storage is not enabled in this app.";
-		return false;
-	}
-	if (!shaderPackage.textureAssets.empty())
-	{
-		error = "RenderCadenceCompositor does not load shader texture assets on the render thread; texture-backed shaders need a CPU-prepared asset handoff first.";
-		return false;
-	}
-	if (!shaderPackage.fontAssets.empty())
-	{
-		error = "RenderCadenceCompositor does not load shader font assets on the render thread; text shaders need a CPU-prepared asset handoff first.";
-		return false;
-	}
-	for (const ShaderParameterDefinition& parameter : shaderPackage.parameters)
-	{
-		if (parameter.type == ShaderParameterType::Text)
-		{
-			error = "RenderCadenceCompositor currently skips text parameters because they require per-shader text texture storage.";
-			return false;
-		}
-	}
-	return true;
-}
 }
 
 RuntimeSlangShaderCompiler::~RuntimeSlangShaderCompiler()
@@ -140,10 +103,12 @@ RuntimeSlangShaderBuild RuntimeSlangShaderCompiler::BuildShader(const std::strin
 			build.message = error.empty() ? "Shader manifest parse failed." : error;
 			return build;
 		}
-		if (!IsStatelessSinglePassPackage(shaderPackage, error))
+		const RenderCadenceCompositor::ShaderSupportResult support =
+			RenderCadenceCompositor::CheckStatelessSinglePassShaderSupport(shaderPackage);
+		if (!support.supported)
 		{
 			build.succeeded = false;
-			build.message = error;
+			build.message = support.reason;
 			return build;
 		}
 

apps/RenderCadenceCompositor/runtime/SupportedShaderCatalog.cpp

@@ -0,0 +1,83 @@
+#include "SupportedShaderCatalog.h"
+
+#include "ShaderPackageRegistry.h"
+
+#include <map>
+#include <utility>
+
+namespace RenderCadenceCompositor
+{
+ShaderSupportResult CheckStatelessSinglePassShaderSupport(const ShaderPackage& shaderPackage)
+{
+	if (shaderPackage.passes.size() != 1)
+		return { false, "RenderCadenceCompositor currently supports only single-pass runtime shaders." };
+
+	if (shaderPackage.temporal.enabled)
+		return { false, "RenderCadenceCompositor currently supports only stateless shaders; temporal history is not enabled in this app." };
+
+	if (shaderPackage.feedback.enabled)
+		return { false, "RenderCadenceCompositor currently supports only stateless shaders; feedback storage is not enabled in this app." };
+
+	if (!shaderPackage.textureAssets.empty())
+		return { false, "RenderCadenceCompositor does not load shader texture assets yet; texture-backed shaders need a CPU-prepared asset handoff first." };
+
+	if (!shaderPackage.fontAssets.empty())
+		return { false, "RenderCadenceCompositor does not load shader font assets yet; text shaders need a CPU-prepared asset handoff first." };
+
+	for (const ShaderParameterDefinition& parameter : shaderPackage.parameters)
+	{
+		if (parameter.type == ShaderParameterType::Text)
+			return { false, "RenderCadenceCompositor currently skips text parameters because they require per-shader text texture storage." };
+	}
+
+	return { true, std::string() };
+}
+
+bool SupportedShaderCatalog::Load(const std::filesystem::path& shaderRoot, unsigned maxTemporalHistoryFrames, std::string& error)
+{
+	mShaders.clear();
+	mPackagesById.clear();
+
+	if (shaderRoot.empty())
+	{
+		error = "Shader library path is empty.";
+		return false;
+	}
+
+	ShaderPackageRegistry registry(maxTemporalHistoryFrames);
+	std::map<std::string, ShaderPackage> packagesById;
+	std::vector<std::string> packageOrder;
+	std::vector<ShaderPackageStatus> packageStatuses;
+	if (!registry.Scan(shaderRoot, packagesById, packageOrder, packageStatuses, error))
+		return false;
+
+	for (const std::string& packageId : packageOrder)
+	{
+		const auto packageIt = packagesById.find(packageId);
+		if (packageIt == packagesById.end())
+			continue;
+
+		const ShaderPackage& shaderPackage = packageIt->second;
+		const ShaderSupportResult support = CheckStatelessSinglePassShaderSupport(shaderPackage);
+		if (!support.supported)
+			continue;
+
+		SupportedShaderSummary summary;
+		summary.id = shaderPackage.id;
+		summary.name = shaderPackage.displayName.empty() ? shaderPackage.id : shaderPackage.displayName;
+		summary.description = shaderPackage.description;
+		summary.category = shaderPackage.category;
+		mShaders.push_back(std::move(summary));
+		mPackagesById[shaderPackage.id] = shaderPackage;
+	}
+
+	error.clear();
+	return true;
+}
+
+const ShaderPackage* SupportedShaderCatalog::FindPackage(const std::string& shaderId) const
+{
+	const auto packageIt = mPackagesById.find(shaderId);
+	return packageIt == mPackagesById.end() ? nullptr : &packageIt->second;
+}
+}

apps/RenderCadenceCompositor/runtime/SupportedShaderCatalog.h

@@ -0,0 +1,39 @@
+#pragma once
+
+#include "ShaderTypes.h"
+
+#include <filesystem>
+#include <map>
+#include <string>
+#include <vector>
+
+namespace RenderCadenceCompositor
+{
+struct SupportedShaderSummary
+{
+	std::string id;
+	std::string name;
+	std::string description;
+	std::string category;
+};
+
+struct ShaderSupportResult
+{
+	bool supported = false;
+	std::string reason;
+};
+
+ShaderSupportResult CheckStatelessSinglePassShaderSupport(const ShaderPackage& shaderPackage);
+
+class SupportedShaderCatalog
+{
+public:
+	bool Load(const std::filesystem::path& shaderRoot, unsigned maxTemporalHistoryFrames, std::string& error);
+	const std::vector<SupportedShaderSummary>& Shaders() const { return mShaders; }
+	const ShaderPackage* FindPackage(const std::string& shaderId) const;
+
+private:
+	std::vector<SupportedShaderSummary> mShaders;
+	std::map<std::string, ShaderPackage> mPackagesById;
+};
+}