Add API to query stage of varying parameter (#302)

Fixes #301

The problem here is that if you have input GLSL code like:

```glsl
// example.vs
in vec3 pos;
```

and:

```glsl
// example.fs
in vec3 worldPos;
```

Then both `pos` and `worldPos` are reflected as global variables (parameters of the *program*), which both get bound to "varying input" resources, but there is no way to tell through the API that `pos` is a vertex parameter while `worldPos` is a fragment one.

The original request in issue #301 was to expose parameters like this not as a global variables, but rather as parameters of the entry point in their specific file. That is, treat it as if the user had written, e.g.:

```glsl
// example.vs
void vsMain(in vec3 pos) { ... }
```

Doing that would unify the GLSL and HLSL/Slang cases a bit, but would require the Slang reflection API to lie about the structure of code the user wrote. At a more basic level, that would have been hard to implement because the current reflection API just exposes the underlying AST, and the AST *needs* to leave `pos` at the global scope so that when we go and spit GLSL back out we retain the original structure.

This PR implements a more simplistic solution, where the user is allowed to query the stage that a varying parameter "belongs" to. For right now I'm only enabling this to work for varying parameters (but it doesn't care if they are entry-point or global-scope varyings). Despite what I said on #301, this should work for both the top-level parameter's variable layout, *and* any variable layouts for fields within its type reflection.

In terms of implementation, I took the simple but wasteful route: every `VarLayout` now has a `stage` field that is by default initialized to `SLANG_STAGE_NONE`. When collecting varying parameters, I take advantage of the fact that everything bottlenecks through `processEntryPointParameter()` which takes an `EntryPointParameterState` so that I can set the `VarLayout::stage` field for any varying parameter in one place.

While I was making this change, I also did a bit of cleanup so that the "official" names for the varying parameter categories are `VARYING_INPUT` and `VARYING_OUTPUT`, with `VERTEX_INPUT` and `FRAGMENT_OUTPUT` being "deprecated" in principle. I didn't do the bulk rename inside the codebase yet.

1 files changed, 24 insertions, 2 deletions

diff --git a/tools/slang-reflection-test/main.cpp b/tools/slang-reflection-test/main.cpp
index b0d970ba3..219acbc76 100644
--- a/tools/slang-reflection-test/main.cpp
+++ b/tools/slang-reflection-test/main.cpp
@@ -109,8 +109,8 @@ static void emitReflectionVarBindingInfoJSON(
     CASE(CONSTANT_BUFFER, constantBuffer);
     CASE(SHADER_RESOURCE, shaderResource);
     CASE(UNORDERED_ACCESS, unorderedAccess);
-    CASE(VERTEX_INPUT, vertexInput);
-    CASE(FRAGMENT_OUTPUT, fragmentOutput);
+    CASE(VARYING_INPUT, varyingInput);
+    CASE(VARYING_OUTPUT, varyingOutput);
     CASE(SAMPLER_STATE, samplerState);
     CASE(UNIFORM, uniform);
     CASE(DESCRIPTOR_TABLE_SLOT, descriptorTableSlot);
@@ -146,6 +146,28 @@ static void emitReflectionVarBindingInfoJSON(
     PrettyWriter&                       writer,
     slang::VariableLayoutReflection*    var)
 {
+    auto stage = var->getStage();
+    if (stage != SLANG_STAGE_NONE)
+    {
+        char const* stageName = "UNKNOWN";
+        switch (stage)
+        {
+        case SLANG_STAGE_VERTEX:    stageName = "vertex";   break;
+        case SLANG_STAGE_HULL:      stageName = "hull";     break;
+        case SLANG_STAGE_DOMAIN:    stageName = "domain";   break;
+        case SLANG_STAGE_GEOMETRY:  stageName = "geometry"; break;
+        case SLANG_STAGE_FRAGMENT:  stageName = "fragment"; break;
+        case SLANG_STAGE_COMPUTE:   stageName = "compute";  break;
+
+        default:
+            break;
+        }
+
+        write(writer, "\"stage\": \"");
+        write(writer, stageName);
+        write(writer, "\",\n");
+    }
+
     auto typeLayout = var->getTypeLayout();
     auto categoryCount = var->getCategoryCount();