refactor: add shader pass and backend variants

tests/Resources/Shader/test_shader.cpp

@@ -100,4 +100,78 @@ TEST(Shader, AddGetAttributes) {
     EXPECT_EQ(attributes[0].name, "aPosition");
 }
 
+TEST(Shader, LegacySingleStageStateSyncsIntoDefaultPassVariant) {
+    Shader shader;
+    shader.SetShaderType(ShaderType::Vertex);
+    shader.SetShaderLanguage(ShaderLanguage::HLSL);
+    shader.SetSourceCode("float4 MainVS() : SV_POSITION { return 0; }");
+
+    ASSERT_EQ(shader.GetPassCount(), 1u);
+    const ShaderPass* pass = shader.FindPass("Default");
+    ASSERT_NE(pass, nullptr);
+    ASSERT_EQ(pass->variants.Size(), 1u);
+    EXPECT_EQ(pass->variants[0].stage, ShaderType::Vertex);
+    EXPECT_EQ(pass->variants[0].language, ShaderLanguage::HLSL);
+    EXPECT_EQ(pass->variants[0].backend, ShaderBackend::Generic);
+    EXPECT_EQ(pass->variants[0].sourceCode, "float4 MainVS() : SV_POSITION { return 0; }");
+}
+
+TEST(Shader, FindsBackendSpecificVariantAndFallsBackToGeneric) {
+    Shader shader;
+
+    ShaderStageVariant genericFragment = {};
+    genericFragment.stage = ShaderType::Fragment;
+    genericFragment.language = ShaderLanguage::GLSL;
+    genericFragment.backend = ShaderBackend::Generic;
+    genericFragment.sourceCode = "generic fragment";
+    shader.AddPassVariant("ForwardLit", genericFragment);
+
+    ShaderStageVariant d3d12Fragment = {};
+    d3d12Fragment.stage = ShaderType::Fragment;
+    d3d12Fragment.language = ShaderLanguage::HLSL;
+    d3d12Fragment.backend = ShaderBackend::D3D12;
+    d3d12Fragment.sourceCode = "d3d12 fragment";
+    shader.AddPassVariant("ForwardLit", d3d12Fragment);
+
+    const ShaderStageVariant* d3d12Variant =
+        shader.FindVariant("ForwardLit", ShaderType::Fragment, ShaderBackend::D3D12);
+    ASSERT_NE(d3d12Variant, nullptr);
+    EXPECT_EQ(d3d12Variant->sourceCode, "d3d12 fragment");
+
+    const ShaderStageVariant* openglVariant =
+        shader.FindVariant("ForwardLit", ShaderType::Fragment, ShaderBackend::OpenGL);
+    ASSERT_NE(openglVariant, nullptr);
+    EXPECT_EQ(openglVariant->sourceCode, "generic fragment");
+}
+
+TEST(Shader, StoresPerPassTags) {
+    Shader shader;
+    shader.SetPassTag("ForwardLit", "LightMode", "ForwardBase");
+    shader.SetPassTag("ForwardLit", "Queue", "Geometry");
+
+    const ShaderPass* pass = shader.FindPass("ForwardLit");
+    ASSERT_NE(pass, nullptr);
+    ASSERT_EQ(pass->tags.Size(), 2u);
+    EXPECT_EQ(pass->tags[0].name, "LightMode");
+    EXPECT_EQ(pass->tags[0].value, "ForwardBase");
+    EXPECT_EQ(pass->tags[1].name, "Queue");
+    EXPECT_EQ(pass->tags[1].value, "Geometry");
+}
+
+TEST(Shader, ReleaseClearsPassRuntimeData) {
+    Shader shader;
+    shader.SetSourceCode("void main() {}");
+    ShaderStageVariant variant = {};
+    variant.stage = ShaderType::Fragment;
+    variant.sourceCode = "fragment";
+    shader.AddPassVariant("ForwardLit", variant);
+
+    shader.Release();
+
+    EXPECT_EQ(shader.GetPassCount(), 0u);
+    EXPECT_EQ(shader.GetSourceCode(), "");
+    EXPECT_EQ(shader.GetCompiledBinary().Size(), 0u);
+    EXPECT_FALSE(shader.IsValid());
+}
+
 } // namespace

tests/Resources/Shader/test_shader_loader.cpp

@@ -3,6 +3,10 @@
 #include <XCEngine/Core/Asset/ResourceTypes.h>
 #include <XCEngine/Core/Containers/Array.h>
 
+#include <cstdio>
+#include <filesystem>
+#include <fstream>
+
 using namespace XCEngine::Resources;
 using namespace XCEngine::Containers;
 
@@ -35,4 +39,35 @@ TEST(ShaderLoader, LoadInvalidPath) {
     EXPECT_FALSE(result);
 }
 
+TEST(ShaderLoader, LoadLegacySingleStageShaderBuildsDefaultPassVariant) {
+    namespace fs = std::filesystem;
+
+    const fs::path shaderPath = fs::temp_directory_path() / "xc_shader_loader_stage.vert";
+    {
+        std::ofstream shaderFile(shaderPath);
+        ASSERT_TRUE(shaderFile.is_open());
+        shaderFile << "#version 430\nvoid main() {}";
+    }
+
+    ShaderLoader loader;
+    LoadResult result = loader.Load(shaderPath.string().c_str());
+    ASSERT_TRUE(result);
+    ASSERT_NE(result.resource, nullptr);
+
+    Shader* shader = static_cast<Shader*>(result.resource);
+    ASSERT_NE(shader, nullptr);
+    EXPECT_EQ(shader->GetShaderType(), ShaderType::Vertex);
+    ASSERT_EQ(shader->GetPassCount(), 1u);
+
+    const ShaderPass* pass = shader->FindPass("Default");
+    ASSERT_NE(pass, nullptr);
+    ASSERT_EQ(pass->variants.Size(), 1u);
+    EXPECT_EQ(pass->variants[0].stage, ShaderType::Vertex);
+    EXPECT_EQ(pass->variants[0].backend, ShaderBackend::Generic);
+    EXPECT_EQ(pass->variants[0].sourceCode, shader->GetSourceCode());
+
+    delete shader;
+    std::remove(shaderPath.string().c_str());
+}
+
 } // namespace