Reflection: allow querying of semantics on varying input/output (#224)

This is functionality required to support a Falcor bug fix.

Most of the code to compute the right semantic name/index for a parameter was already present.
This change adds:

- Storage for semantic name/index on every `VarLayout`
  - Note: this is wasteful and should be optimized later

- A public API to query the semantic name/index
  - The contract is that this API returns `NULL` if the parameter had no semantic

- A bit of work in `parameter-binding.cpp` to attach semantics to varying input/output when traversing varying parameters.
  - Note: this is intentionally set up so that it associates semantics even with non-leaf parameters, so that an API user can query the semantic of a `struct` parameter and know that its members will be assigned sequential semantic indices from its starting value.

- Support for dumping this information in reflection tests

One notable thing that I did *not* change here is that the reflection test fixture doesn't report information on the output of an entry point, even though it really should. That should be fixed in a separate change, though, because it would affect many of the expected outputs.

3 files changed, 186 insertions, 0 deletions

diff --git a/tests/reflection/thread-group-size.hlsl.expected b/tests/reflection/thread-group-size.hlsl.expected
index d139c5b64..a41c66248 100644
--- a/tests/reflection/thread-group-size.hlsl.expected
+++ b/tests/reflection/thread-group-size.hlsl.expected
@@ -24,6 +24,7 @@ standard output = {
                     "bindings": [
 
                     ],
+                    "semanticName": "SV_DISPATCHTHREADID",
                     "type": {
                         "kind": "vector",
                         "elementCount": 3,
diff --git a/tests/reflection/vertex-input-semantics.hlsl b/tests/reflection/vertex-input-semantics.hlsl
new file mode 100644
index 000000000..87a8431bc
--- /dev/null
+++ b/tests/reflection/vertex-input-semantics.hlsl
@@ -0,0 +1,33 @@
+//TEST:REFLECTION:-profile vs_4_0 -target hlsl
+
+// Confirm that we can generate reflection info for
+// vertex shader input parameters, including those
+// that have semantics, and including nesting
+// via struct types.
+
+struct X
+{
+	float4 x0;
+	float4 x1;
+};
+
+struct B
+{
+	int4 b0;
+	X b1;
+};
+
+struct C
+{
+	X c0 : CX;
+	int4 c1 : CY;
+};
+
+float4 main(
+	float4 a : A,
+	B b : B,
+	C c)
+	: SV_Position
+{
+	return 0.0;
+}
\ No newline at end of file
diff --git a/tests/reflection/vertex-input-semantics.hlsl.expected b/tests/reflection/vertex-input-semantics.hlsl.expected
new file mode 100644
index 000000000..014533fdb
--- /dev/null
+++ b/tests/reflection/vertex-input-semantics.hlsl.expected
@@ -0,0 +1,152 @@
+result code = 0
+standard error = {
+}
+standard output = {
+{
+    "parameters": [
+
+    ],
+    "entryPoints": [
+        {
+            "name": "main",
+            "stage:": "vertex",
+            "parameters": [
+                {
+                    "name": "a",
+                    "binding": {"kind": "vertexInput", "index": 0},
+                    "semanticName": "A",
+                    "type": {
+                        "kind": "vector",
+                        "elementCount": 4,
+                        "elementType": {
+                            "kind": "scalar",
+                            "scalarType": "float32"
+                        }
+                    }
+                },
+                {
+                    "name": "b",
+                    "binding": {"kind": "vertexInput", "index": 1, "count": 3},
+                    "semanticName": "B",
+                    "type": {
+                        "kind": "struct",
+                        "fields": [
+                            {
+                                "name": "b0",
+                                "type": {
+                                    "kind": "vector",
+                                    "elementCount": 4,
+                                    "elementType": {
+                                        "kind": "scalar",
+                                        "scalarType": "int32"
+                                    }
+                                },
+                                "binding": {"kind": "vertexInput", "index": 0},
+                                "semanticName": "B"
+                            },
+                            {
+                                "name": "b1",
+                                "type": {
+                                    "kind": "struct",
+                                    "fields": [
+                                        {
+                                            "name": "x0",
+                                            "type": {
+                                                "kind": "vector",
+                                                "elementCount": 4,
+                                                "elementType": {
+                                                    "kind": "scalar",
+                                                    "scalarType": "float32"
+                                                }
+                                            },
+                                            "binding": {"kind": "vertexInput", "index": 0},
+                                            "semanticName": "B",
+                                            "semanticIndex": 1
+                                        },
+                                        {
+                                            "name": "x1",
+                                            "type": {
+                                                "kind": "vector",
+                                                "elementCount": 4,
+                                                "elementType": {
+                                                    "kind": "scalar",
+                                                    "scalarType": "float32"
+                                                }
+                                            },
+                                            "binding": {"kind": "vertexInput", "index": 1},
+                                            "semanticName": "B",
+                                            "semanticIndex": 2
+                                        }
+                                    ]
+                                },
+                                "binding": {"kind": "vertexInput", "index": 1, "count": 2},
+                                "semanticName": "B",
+                                "semanticIndex": 1
+                            }
+                        ]
+                    }
+                },
+                {
+                    "name": "c",
+                    "binding": {"kind": "vertexInput", "index": 4, "count": 3},
+                    "type": {
+                        "kind": "struct",
+                        "fields": [
+                            {
+                                "name": "c0",
+                                "type": {
+                                    "kind": "struct",
+                                    "fields": [
+                                        {
+                                            "name": "x0",
+                                            "type": {
+                                                "kind": "vector",
+                                                "elementCount": 4,
+                                                "elementType": {
+                                                    "kind": "scalar",
+                                                    "scalarType": "float32"
+                                                }
+                                            },
+                                            "binding": {"kind": "vertexInput", "index": 0},
+                                            "semanticName": "CX"
+                                        },
+                                        {
+                                            "name": "x1",
+                                            "type": {
+                                                "kind": "vector",
+                                                "elementCount": 4,
+                                                "elementType": {
+                                                    "kind": "scalar",
+                                                    "scalarType": "float32"
+                                                }
+                                            },
+                                            "binding": {"kind": "vertexInput", "index": 1},
+                                            "semanticName": "CX",
+                                            "semanticIndex": 1
+                                        }
+                                    ]
+                                },
+                                "binding": {"kind": "vertexInput", "index": 0, "count": 2},
+                                "semanticName": "CX"
+                            },
+                            {
+                                "name": "c1",
+                                "type": {
+                                    "kind": "vector",
+                                    "elementCount": 4,
+                                    "elementType": {
+                                        "kind": "scalar",
+                                        "scalarType": "int32"
+                                    }
+                                },
+                                "binding": {"kind": "vertexInput", "index": 2},
+                                "semanticName": "CY"
+                            }
+                        ]
+                    }
+                }
+            ]
+        }
+    ]
+}
+}