Add support for Vulkan raytraicng "shader record" (#735)

The syntax for this is a placeholder for now, since we will probably want to migrate to whatever gets decided on for dxc. To declare that some data should be part of the "shader record" use `layout(shaderRecordNV)` to mirror the GLSL raytracing extension:

```hlsl
layout(shaderRecordNV)
cbuffer MyShaderRecord
{
    float4 someColor;
    uint   someValue;
}
```

The intention (not enforced) is that an application would map `MyShaderRecord` to "root constants" in the "local root signature" when compiling for DXR, while the output code in GLSL will always map to the shader record in Vulkan raytracing:

```glsl
layout(shaderRecordNV)
buffer MyShaderRecord
{
    float4 someColor;
    uint   someValue;
};
```

This change does *not* support declaring a global value of `struct` type with `layout(shaderRecordNV)` (or a `ParameterBlock` with the modifiers, although that would be a nice-to-have feature) and it does *not* support having the contents of the shader record be mutable (even if GLSL/Vulkan allows it). Those can/should be added in future changes.

In terms of implementation, this closely mirrors the way that `layout(push_constant)` buffers were being handled, where the data inside the `ConstantBuffer<X>` (the value of type `X`) gets laid out using ordinary rules (and consuming ordinary `UNIFORM` storage, while the buffer itself is given a different layout resource to reflect that fact that it does not consume a VK `binding` any more, but a different conceptual resource.

Note: an alternative design here (that might actually be preferrable) would be to have both push-constant and shader-record buffers be handled as alternative aliases for `ConstantBuffer` (or maybe `ParameterBlock`) so that you have, e.g.:

```hlsl
PushConstantBuffer<X> myPushConstants;
ShaderRecord<Y> myShaderRecord;
```

This alternative design avoids API-specific decorations on the declarations, and reflects the intent of the programmer very directly, even when they are compiling for a target like D3D that doesn't reflect these choices at the IL level (it could still be exposed through the Slang reflection API).

1 files changed, 13 insertions, 4 deletions

diff --git a/source/slang/emit.cpp b/source/slang/emit.cpp
index 187ef29bc..fb9968232 100644
--- a/source/slang/emit.cpp
+++ b/source/slang/emit.cpp
@@ -1753,14 +1753,14 @@ struct EmitVisitor
         emitHLSLParameterGroupFieldLayoutSemantics(&chain);
     }
 
-    void emitGLSLLayoutQualifier(
+    bool emitGLSLLayoutQualifier(
         LayoutResourceKind  kind,
         EmitVarChain*       chain)
     {
         if(!chain)
-            return;
+            return false;
         if(!chain->varLayout->FindResourceInfo(kind))
-            return;
+            return false;
 
         UInt index = getBindingOffset(chain, kind);
         UInt space = getBindingSpace(chain, kind);
@@ -1828,8 +1828,12 @@ struct EmitVisitor
         case LayoutResourceKind::PushConstantBuffer:
             Emit("layout(push_constant)\n");
             break;
+        case LayoutResourceKind::ShaderRecord:
+            Emit("layout(shaderRecordNV)\n");
+            break;
 
         }
+        return true;
     }
 
     void emitGLSLLayoutQualifiers(
@@ -5821,8 +5825,13 @@ struct EmitVisitor
 
         emitGLSLLayoutQualifier(LayoutResourceKind::DescriptorTableSlot, &containerChain);
         emitGLSLLayoutQualifier(LayoutResourceKind::PushConstantBuffer, &containerChain);
+        bool isShaderRecord = emitGLSLLayoutQualifier(LayoutResourceKind::ShaderRecord, &containerChain);
 
-        if(as<IRGLSLShaderStorageBufferType>(type))
+        if( isShaderRecord )
+        {
+            emit("buffer ");
+        }
+        else if(as<IRGLSLShaderStorageBufferType>(type))
         {
             emit("layout(std430) buffer ");
         }