Close shader authoring pipeline and UsePass dependency tracking

tests/Resources/Shader/test_shader.cpp

@@ -10,8 +10,7 @@ namespace {
 
 TEST(Shader, DefaultConstructor) {
     Shader shader;
-    EXPECT_EQ(shader.GetShaderType(), ShaderType::Fragment);
-    EXPECT_EQ(shader.GetShaderLanguage(), ShaderLanguage::GLSL);
+    EXPECT_EQ(shader.GetPassCount(), 0u);
     EXPECT_FALSE(shader.IsValid());
     EXPECT_EQ(shader.GetMemorySize(), 0u);
 }
@@ -21,64 +20,42 @@ TEST(Shader, GetType) {
     EXPECT_EQ(shader.GetType(), ResourceType::Shader);
 }
 
-TEST(Shader, SetGetShaderType) {
+TEST(Shader, AddPassVariantStoresStageLanguageAndPayload) {
     Shader shader;
-    
-    shader.SetShaderType(ShaderType::Vertex);
-    EXPECT_EQ(shader.GetShaderType(), ShaderType::Vertex);
-    
-    shader.SetShaderType(ShaderType::Fragment);
-    EXPECT_EQ(shader.GetShaderType(), ShaderType::Fragment);
-    
-    shader.SetShaderType(ShaderType::Geometry);
-    EXPECT_EQ(shader.GetShaderType(), ShaderType::Geometry);
-    
-    shader.SetShaderType(ShaderType::Compute);
-    EXPECT_EQ(shader.GetShaderType(), ShaderType::Compute);
-}
+    ShaderStageVariant variant = {};
+    variant.stage = ShaderType::Vertex;
+    variant.language = ShaderLanguage::HLSL;
+    variant.backend = ShaderBackend::D3D12;
+    variant.entryPoint = "MainVS";
+    variant.profile = "vs_5_0";
+    variant.sourceCode = "float4 MainVS() : SV_POSITION { return 0; }";
+    variant.compiledBinary = { 0x00, 0x01, 0x02, 0x03 };
 
-TEST(Shader, SetGetShaderLanguage) {
-    Shader shader;
-    
-    shader.SetShaderLanguage(ShaderLanguage::GLSL);
-    EXPECT_EQ(shader.GetShaderLanguage(), ShaderLanguage::GLSL);
-    
-    shader.SetShaderLanguage(ShaderLanguage::HLSL);
-    EXPECT_EQ(shader.GetShaderLanguage(), ShaderLanguage::HLSL);
-    
-    shader.SetShaderLanguage(ShaderLanguage::SPIRV);
-    EXPECT_EQ(shader.GetShaderLanguage(), ShaderLanguage::SPIRV);
-}
+    shader.AddPassVariant("ForwardLit", variant);
 
-TEST(Shader, SetGetSourceCode) {
-    Shader shader;
-    const char* source = "#version 330 core\nvoid main() {}";
-    
-    shader.SetSourceCode(source);
-    EXPECT_EQ(shader.GetSourceCode(), source);
-}
-
-TEST(Shader, SetGetCompiledBinary) {
-    Shader shader;
-    XCEngine::Containers::Array<XCEngine::Core::uint8> binary = { 0x00, 0x01, 0x02, 0x03 };
-    
-    shader.SetCompiledBinary(binary);
-    EXPECT_EQ(shader.GetCompiledBinary().Size(), 4u);
-    EXPECT_EQ(shader.GetCompiledBinary()[0], 0x00);
-    EXPECT_EQ(shader.GetCompiledBinary()[3], 0x03);
+    const ShaderStageVariant* storedVariant =
+        shader.FindVariant("ForwardLit", ShaderType::Vertex, ShaderBackend::D3D12);
+    ASSERT_NE(storedVariant, nullptr);
+    EXPECT_EQ(storedVariant->stage, ShaderType::Vertex);
+    EXPECT_EQ(storedVariant->language, ShaderLanguage::HLSL);
+    EXPECT_EQ(storedVariant->entryPoint, "MainVS");
+    EXPECT_EQ(storedVariant->profile, "vs_5_0");
+    EXPECT_EQ(storedVariant->sourceCode, "float4 MainVS() : SV_POSITION { return 0; }");
+    ASSERT_EQ(storedVariant->compiledBinary.Size(), 4u);
+    EXPECT_EQ(storedVariant->compiledBinary[3], 0x03);
 }
 
 TEST(Shader, AddGetUniforms) {
     Shader shader;
-    
+
     ShaderUniform uniform1;
     uniform1.name = "uModelView";
     uniform1.location = 0;
     uniform1.size = 1;
     uniform1.type = 4;
-    
+
     shader.AddUniform(uniform1);
-    
+
     const auto& uniforms = shader.GetUniforms();
     EXPECT_EQ(uniforms.Size(), 1u);
     EXPECT_EQ(uniforms[0].name, "uModelView");
@@ -86,36 +63,20 @@ TEST(Shader, AddGetUniforms) {
 
 TEST(Shader, AddGetAttributes) {
     Shader shader;
-    
+
     ShaderAttribute attr1;
     attr1.name = "aPosition";
     attr1.location = 0;
     attr1.size = 1;
     attr1.type = 3;
-    
+
     shader.AddAttribute(attr1);
-    
+
     const auto& attributes = shader.GetAttributes();
     EXPECT_EQ(attributes.Size(), 1u);
     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;
 
@@ -309,7 +270,6 @@ TEST(Shader, StoresPassKeywordDeclarationsAndQueriesDeclaredKeywords) {
 
 TEST(Shader, ReleaseClearsPassRuntimeData) {
     Shader shader;
-    shader.SetSourceCode("void main() {}");
     ShaderPropertyDesc property = {};
     property.name = "_BaseColor";
     property.type = ShaderPropertyType::Color;
@@ -323,8 +283,6 @@ TEST(Shader, ReleaseClearsPassRuntimeData) {
 
     EXPECT_EQ(shader.GetProperties().Size(), 0u);
     EXPECT_EQ(shader.GetPassCount(), 0u);
-    EXPECT_EQ(shader.GetSourceCode(), "");
-    EXPECT_EQ(shader.GetCompiledBinary().Size(), 0u);
     EXPECT_FALSE(shader.IsValid());
 }