New rules based order

apps/RenderCadenceCompositor/runtime/RuntimeShaderArtifact.h

@@ -1,10 +1,15 @@
 #pragma once
 
+#include "ShaderTypes.h"
+
 #include <string>
+#include <vector>
 
 struct RuntimeShaderArtifact
 {
 	std::string shaderId;
+	std::string displayName;
 	std::string fragmentShaderSource;
 	std::string message;
+	std::vector<ShaderParameterDefinition> parameterDefinitions;
 };

apps/RenderCadenceCompositor/runtime/RuntimeShaderBridge.cpp

@@ -0,0 +1,53 @@
+#include "RuntimeShaderBridge.h"
+
+#include <chrono>
+
+RuntimeShaderBridge::~RuntimeShaderBridge()
+{
+	Stop();
+}
+
+void RuntimeShaderBridge::Start(const std::string& shaderId, ArtifactCallback onArtifactReady, ErrorCallback onError)
+{
+	Stop();
+	if (shaderId.empty())
+		return;
+
+	mOnArtifactReady = std::move(onArtifactReady);
+	mOnError = std::move(onError);
+	mStopping.store(false, std::memory_order_release);
+	mCompiler.StartShaderBuild(shaderId);
+	mThread = std::thread([this]() { ThreadMain(); });
+}
+
+void RuntimeShaderBridge::Stop()
+{
+	mStopping.store(true, std::memory_order_release);
+	if (mThread.joinable())
+		mThread.join();
+	mCompiler.Stop();
+	mOnArtifactReady = ArtifactCallback();
+	mOnError = ErrorCallback();
+}
+
+void RuntimeShaderBridge::ThreadMain()
+{
+	while (!mStopping.load(std::memory_order_acquire))
+	{
+		RuntimeSlangShaderBuild build;
+		if (mCompiler.TryConsume(build))
+		{
+			if (build.succeeded)
+			{
+				if (mOnArtifactReady)
+					mOnArtifactReady(build.artifact);
+			}
+			else if (mOnError)
+			{
+				mOnError(build.message);
+			}
+			return;
+		}
+		std::this_thread::sleep_for(std::chrono::milliseconds(5));
+	}
+}

apps/RenderCadenceCompositor/runtime/RuntimeShaderBridge.h

@@ -0,0 +1,33 @@
+#pragma once
+
+#include "RuntimeShaderArtifact.h"
+#include "RuntimeSlangShaderCompiler.h"
+
+#include <atomic>
+#include <functional>
+#include <string>
+#include <thread>
+
+class RuntimeShaderBridge
+{
+public:
+	using ArtifactCallback = std::function<void(const RuntimeShaderArtifact&)>;
+	using ErrorCallback = std::function<void(const std::string&)>;
+
+	RuntimeShaderBridge() = default;
+	RuntimeShaderBridge(const RuntimeShaderBridge&) = delete;
+	RuntimeShaderBridge& operator=(const RuntimeShaderBridge&) = delete;
+	~RuntimeShaderBridge();
+
+	void Start(const std::string& shaderId, ArtifactCallback onArtifactReady, ErrorCallback onError);
+	void Stop();
+
+private:
+	void ThreadMain();
+
+	RuntimeSlangShaderCompiler mCompiler;
+	std::thread mThread;
+	std::atomic<bool> mStopping{ false };
+	ArtifactCallback mOnArtifactReady;
+	ErrorCallback mOnError;
+};

apps/RenderCadenceCompositor/runtime/RuntimeSlangShaderCompiler.cpp

@@ -1,6 +1,7 @@
 #include "RuntimeSlangShaderCompiler.h"
 
 #include "ShaderCompiler.h"
+#include "ShaderPackageRegistry.h"
 #include "ShaderTypes.h"
 
 #include <chrono>
@@ -9,16 +10,6 @@
 
 namespace
 {
-ShaderParameterDefinition FloatParam(const std::string& id, double defaultValue)
-{
-	ShaderParameterDefinition parameter;
-	parameter.id = id;
-	parameter.label = id;
-	parameter.type = ShaderParameterType::Float;
-	parameter.defaultNumbers.push_back(defaultValue);
-	return parameter;
-}
-
 std::filesystem::path FindRepoRoot()
 {
 	std::filesystem::path current = std::filesystem::current_path();
@@ -36,6 +27,44 @@ std::filesystem::path FindRepoRoot()
 		current = parent;
 	}
 }
+
+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()
@@ -44,6 +73,11 @@ RuntimeSlangShaderCompiler::~RuntimeSlangShaderCompiler()
 }
 
 void RuntimeSlangShaderCompiler::StartHappyAccidentBuild()
+{
+	StartShaderBuild("happy-accident");
+}
+
+void RuntimeSlangShaderCompiler::StartShaderBuild(const std::string& shaderId)
 {
 	if (mRunning.load(std::memory_order_acquire))
 		return;
@@ -57,8 +91,8 @@ void RuntimeSlangShaderCompiler::StartHappyAccidentBuild()
 	}
 
 	mRunning.store(true, std::memory_order_release);
-	mThread = std::thread([this]() {
-		RuntimeSlangShaderBuild build = BuildHappyAccident();
+	mThread = std::thread([this, shaderId]() {
+		RuntimeSlangShaderBuild build = BuildShader(shaderId);
 		{
 			std::lock_guard<std::mutex> lock(mMutex);
 			mReadyBuild = std::move(build);
@@ -86,57 +120,57 @@ bool RuntimeSlangShaderCompiler::TryConsume(RuntimeSlangShaderBuild& build)
 	return true;
 }
 
-RuntimeSlangShaderBuild RuntimeSlangShaderCompiler::BuildHappyAccident() const
+RuntimeSlangShaderBuild RuntimeSlangShaderCompiler::BuildShader(const std::string& shaderId) const
 {
 	RuntimeSlangShaderBuild build;
-	build.artifact.shaderId = "happy-accident";
+	build.artifact.shaderId = shaderId;
 
 	try
 	{
 		const std::filesystem::path repoRoot = FindRepoRoot();
-		const std::filesystem::path shaderDir = repoRoot / "shaders" / "happy-accident";
+		const std::filesystem::path shaderDir = repoRoot / "shaders" / shaderId;
 		const std::filesystem::path runtimeBuildDir = repoRoot / "runtime" / "generated" / "render-cadence-compositor";
 
+		ShaderPackageRegistry registry(0);
 		ShaderPackage shaderPackage;
-		shaderPackage.id = "happy-accident";
-		shaderPackage.displayName = "Happy Accident";
-		shaderPackage.entryPoint = "shadeVideo";
-		shaderPackage.directoryPath = shaderDir;
-		shaderPackage.shaderPath = shaderDir / "shader.slang";
-		shaderPackage.manifestPath = shaderDir / "shader.json";
-		shaderPackage.parameters.push_back(FloatParam("speed", 1.0));
-		shaderPackage.parameters.push_back(FloatParam("scale", 1.0));
-		shaderPackage.parameters.push_back(FloatParam("raySteps", 77.0));
-		shaderPackage.parameters.push_back(FloatParam("intensity", 1.0));
-		shaderPackage.parameters.push_back(FloatParam("sourceMix", 0.0));
+		std::string error;
+		if (!registry.ParseManifest(shaderDir / "shader.json", shaderPackage, error))
+		{
+			build.succeeded = false;
+			build.message = error.empty() ? "Shader manifest parse failed." : error;
+			return build;
+		}
+		if (!IsStatelessSinglePassPackage(shaderPackage, error))
+		{
+			build.succeeded = false;
+			build.message = error;
+			return build;
+		}
 
-		ShaderPassDefinition pass;
-		pass.id = "main";
-		pass.entryPoint = shaderPackage.entryPoint;
-		pass.sourcePath = shaderPackage.shaderPath;
-		pass.outputName = "output";
-		shaderPackage.passes.push_back(pass);
+		const ShaderPassDefinition& pass = shaderPackage.passes.front();
 
 		ShaderCompiler compiler(
 			repoRoot,
-			runtimeBuildDir / "happy_accident_wrapper.slang",
-			runtimeBuildDir / "happy_accident.generated.glsl",
-			runtimeBuildDir / "happy_accident.patched.glsl",
+			runtimeBuildDir / (shaderId + ".wrapper.slang"),
+			runtimeBuildDir / (shaderId + ".generated.glsl"),
+			runtimeBuildDir / (shaderId + ".patched.glsl"),
 			0);
 
-		std::string error;
 		const auto start = std::chrono::steady_clock::now();
 		if (!compiler.BuildPassFragmentShaderSource(shaderPackage, pass, build.artifact.fragmentShaderSource, error))
 		{
 			build.succeeded = false;
-			build.message = error.empty() ? "Happy Accident Slang compile failed." : error;
+			build.message = error.empty() ? "Slang compile failed." : error;
 			return build;
 		}
 
 		const auto end = std::chrono::steady_clock::now();
 		const double milliseconds = std::chrono::duration_cast<std::chrono::duration<double, std::milli>>(end - start).count();
 		build.succeeded = true;
-		build.artifact.message = "Happy Accident Slang compile completed in " + std::to_string(milliseconds) + " ms.";
+		build.artifact.shaderId = shaderPackage.id;
+		build.artifact.displayName = shaderPackage.displayName;
+		build.artifact.parameterDefinitions = shaderPackage.parameters;
+		build.artifact.message = shaderPackage.displayName + " Slang compile completed in " + std::to_string(milliseconds) + " ms.";
 		build.message = build.artifact.message;
 		return build;
 	}

apps/RenderCadenceCompositor/runtime/RuntimeSlangShaderCompiler.h

@@ -24,12 +24,13 @@ public:
 	~RuntimeSlangShaderCompiler();
 
 	void StartHappyAccidentBuild();
+	void StartShaderBuild(const std::string& shaderId);
 	void Stop();
 	bool TryConsume(RuntimeSlangShaderBuild& build);
 	bool Running() const { return mRunning.load(std::memory_order_acquire); }
 
 private:
-	RuntimeSlangShaderBuild BuildHappyAccident() const;
+	RuntimeSlangShaderBuild BuildShader(const std::string& shaderId) const;
 
 	std::thread mThread;
 	std::atomic<bool> mRunning{ false };