end point adjsutments

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;
+};
+}