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, 30 insertions, 0 deletions

diff --git a/source/slang/reflection.cpp b/source/slang/reflection.cpp
index 14199f126..a1ea3ff72 100644
--- a/source/slang/reflection.cpp
+++ b/source/slang/reflection.cpp
@@ -666,6 +666,36 @@ SLANG_API size_t spReflectionVariableLayout_GetSemanticIndex(SlangReflectionVari
     return varLayout->semanticIndex;
 }
 
+SLANG_API SlangStage spReflectionVariableLayout_getStage(
+    SlangReflectionVariableLayout* inVarLayout)
+{
+    auto varLayout = convert(inVarLayout);
+    if(!varLayout) return SLANG_STAGE_NONE;
+
+    // A parameter that is not a varying input or output is
+    // not considered to belong to a single stage.
+    //
+    // TODO: We might need to reconsider this for, e.g., entry
+    // point parameters, where they might be stage-specific even
+    // if they are uniform.
+    if (!varLayout->FindResourceInfo(Slang::LayoutResourceKind::VaryingInput)
+        && !varLayout->FindResourceInfo(Slang::LayoutResourceKind::VaryingOutput))
+    {
+        return SLANG_STAGE_NONE;
+    }
+
+    // TODO: We should find the stage for a variable layout by
+    // walking up the tree of layout information, until we find
+    // something that has a definitive stage attached to it (e.g.,
+    // either an entry point or a GLSL translation unit).
+    //
+    // We don't currently have parent links in the reflection layout
+    // information, so doing that walk would be tricky right now, so
+    // it is easier to just bloat the representation and store yet another
+    // field on every variable layout.
+    return (SlangStage) varLayout->stage;
+}
+
 
 // Shader Parameter Reflection