Rework shader object specialization control interface. (#1857)

3 files changed, 56 insertions, 51 deletions

diff --git a/tools/render-test/render-test-main.cpp b/tools/render-test/render-test-main.cpp
index 5c8011889..ab73af5b5 100644
--- a/tools/render-test/render-test-main.cpp
+++ b/tools/render-test/render-test-main.cpp
@@ -340,29 +340,27 @@ struct AssignValsFromLayoutContext
         ComPtr<IShaderObject> shaderObject = device->createShaderObject(slangType);
 
         SLANG_RETURN_ON_FAIL(assign(ShaderCursor(shaderObject), srcVal->contentVal));
+        dstCursor.setObject(shaderObject);
+        return SLANG_OK;
+    }
 
-        if (srcVal->specializationArgs.getCount())
+    SlangResult assignValWithSpecializationArg(
+        ShaderCursor const& dstCursor,
+        ShaderInputLayout::SpecializeVal* srcVal)
+    {
+        assign(dstCursor, srcVal->contentVal);
+        List<slang::SpecializationArg> args;
+        for (auto& typeName : srcVal->typeArgs)
         {
-            List<slang::SpecializationArg> args;
-            for (auto srcArg : srcVal->specializationArgs)
+            auto slangType = slangReflection->findTypeByName(typeName.getBuffer());
+            if (!slangType)
             {
-                auto argType = slangReflection->findTypeByName(srcArg.getBuffer());
-                if (argType)
-                {
-                    slang::SpecializationArg arg = slang::SpecializationArg::fromType(argType);
-                    args.add(arg);
-                }
-                else
-                {
-                    StdWriters::getError().print(
-                        "error: could not find shader type '%s'\n", srcArg.getBuffer());
-                    return SLANG_E_INVALID_ARG;
-                }
+                StdWriters::getError().print("error: could not find shader type '%s'\n", typeName.getBuffer());
+                return SLANG_E_INVALID_ARG;
             }
-            shaderObject->setSpecializationArgs(args.getBuffer(), args.getCount());
+            args.add(slang::SpecializationArg::fromType(slangType));
         }
-        dstCursor.setObject(shaderObject);
-        return SLANG_OK;
+        return dstCursor.setSpecializationArgs(args.getBuffer(), (uint32_t)args.getCount());
     }
 
     SlangResult assignArray(ShaderCursor const& dstCursor, ShaderInputLayout::ArrayVal* srcVal)
@@ -399,6 +397,10 @@ struct AssignValsFromLayoutContext
         case ShaderInputType::Object:
             return assignObject(dstCursor, (ShaderInputLayout::ObjectVal*) srcVal.Ptr());
 
+        case ShaderInputType::Specialize:
+            return assignValWithSpecializationArg(
+                dstCursor, (ShaderInputLayout::SpecializeVal*)srcVal.Ptr());
+
         case ShaderInputType::Aggregate:
             return assignAggregate(dstCursor, (ShaderInputLayout::AggVal*) srcVal.Ptr());
 
diff --git a/tools/render-test/shader-input-layout.cpp b/tools/render-test/shader-input-layout.cpp
index af15d5f9f..3ab0366a5 100644
--- a/tools/render-test/shader-input-layout.cpp
+++ b/tools/render-test/shader-input-layout.cpp
@@ -346,37 +346,6 @@ namespace renderer_test
             return SLANG_OK;
         }
 
-        SlangResult parseObjectAttributes(ShaderInputLayout::ObjectVal* val, Misc::TokenReader& parser)
-        {
-            if (parser.AdvanceIf(":"))
-            {
-                while (!parser.IsEnd() && parser.NextToken().Type == Misc::TokenType::Identifier)
-                {
-                    if (parser.AdvanceIf("specialization_args"))
-                    {
-                        parser.Read(Misc::TokenType::LParent);
-                        while (!parser.IsEnd() &&
-                               parser.NextToken().Type != Misc::TokenType::RParent)
-                        {
-                            val->specializationArgs.add(parseTypeName(parser));
-                            if (!parser.AdvanceIf(","))
-                                break;
-                        }
-                        parser.Read(Misc::TokenType::RParent);
-                    }
-                    else
-                    {
-                        throw ShaderInputLayoutFormatException(
-                            StringBuilder() << "Unknown attribute \'" << parser.NextToken().Content << "\' ("
-                                            << parser.NextToken().Position.Line << ")");
-
-                        return SLANG_FAIL;
-                    }
-                }
-            }
-            return SLANG_OK;
-        }
-
         Format parseFormatOption(Misc::TokenReader& parser)
         {
             parser.Read("=");
@@ -542,7 +511,6 @@ namespace renderer_test
                         }
 
                         val->contentVal = parseValExpr(parser);
-                        parseObjectAttributes(val, parser);
                         return val;
                     }
                     else if( parser.AdvanceIf("out") )
@@ -551,6 +519,31 @@ namespace renderer_test
                         val->isOutput = true;
                         return val;
                     }
+                    else if (parser.AdvanceIf("specialize"))
+                    {
+                        RefPtr<ShaderInputLayout::SpecializeVal> val =
+                            new ShaderInputLayout::SpecializeVal();
+
+                        parser.Read(Misc::TokenType::LParent);
+                        while (!parser.IsEnd() &&
+                               parser.NextToken().Type != Misc::TokenType::RParent)
+                        {
+                            val->typeArgs.add(parseTypeName(parser));
+                            if (!parser.AdvanceIf(","))
+                                break;
+                        }
+                        parser.Read(Misc::TokenType::RParent);
+                        val->contentVal = parseValExpr(parser);
+                        return val;
+                    }
+                    else if (parser.AdvanceIf("dynamic"))
+                    {
+                        RefPtr<ShaderInputLayout::SpecializeVal> val =
+                            new ShaderInputLayout::SpecializeVal();
+                        val->typeArgs.add("__Dynamic");
+                        val->contentVal = parseValExpr(parser);
+                        return val;
+                    }
                     else
                     {
                         // We assume that any other word is introducing one of the other
diff --git a/tools/render-test/shader-input-layout.h b/tools/render-test/shader-input-layout.h
index 86e7641f0..ed2f57370 100644
--- a/tools/render-test/shader-input-layout.h
+++ b/tools/render-test/shader-input-layout.h
@@ -22,6 +22,7 @@ enum class ShaderInputType
     UniformData,
     Object,
     Aggregate,
+    Specialize,
 };
 
 enum class InputTextureContent
@@ -248,7 +249,16 @@ public:
 
         Slang::String typeName;
         ValPtr contentVal;
-        Slang::List<Slang::String> specializationArgs;
+    };
+
+    class SpecializeVal : public Val
+    {
+    public:
+        ValPtr contentVal;
+        Slang::List<Slang::String> typeArgs;
+        SpecializeVal()
+            : Val(ShaderInputType::Specialize)
+        {}
     };
 
     class ArrayVal : public ParentVal