A number of updates/fixes to PSO refactor merge

4 files changed, 37 insertions, 48 deletions

diff --git a/Graphics/ShaderTools/include/SPIRVShaderResources.hpp b/Graphics/ShaderTools/include/SPIRVShaderResources.hpp
index 338bf602..7e75fb07 100644
--- a/Graphics/ShaderTools/include/SPIRVShaderResources.hpp
+++ b/Graphics/ShaderTools/include/SPIRVShaderResources.hpp
@@ -75,6 +75,8 @@ struct SPIRVShaderResourceAttribs
         NumResourceTypes
     };
 
+    static SHADER_RESOURCE_TYPE GetShaderResourceType(ResourceType Type);
+
     // clang-format off
 
     static constexpr const Uint32   InvalidSepSmplrOrImgInd = static_cast<Uint32>(-1);
@@ -147,7 +149,10 @@ public:
         // clang-format on
     }
 
-    ShaderResourceDesc GetResourceDesc() const;
+    ShaderResourceDesc GetResourceDesc() const
+    {
+        return ShaderResourceDesc{Name, GetShaderResourceType(Type), ArraySize};
+    }
 
     RESOURCE_DIMENSION GetResourceDimension() const
     {
diff --git a/Graphics/ShaderTools/src/DXCompiler.cpp b/Graphics/ShaderTools/src/DXCompiler.cpp
index 75782aaa..237d7cea 100644
--- a/Graphics/ShaderTools/src/DXCompiler.cpp
+++ b/Graphics/ShaderTools/src/DXCompiler.cpp
@@ -589,7 +589,7 @@ void DXCompilerImpl::GetD3D12ShaderReflection(IDxcBlob*                pShaderBy
         if (FAILED(hr))
             LOG_ERROR_AND_THROW("Failed to load shader reflection from bytecode");
 
-        UINT32 shaderIdx;
+        UINT32 shaderIdx = 0;
 
         hr = pReflection->FindFirstPartKind(DXC_PART_DXIL, &shaderIdx);
         if (SUCCEEDED(hr))
@@ -598,7 +598,7 @@ void DXCompilerImpl::GetD3D12ShaderReflection(IDxcBlob*                pShaderBy
             if (SUCCEEDED(hr))
                 return;
 
-            // for ray tracing shaders
+            // Try to get the reflection via library reflection
             CComPtr<ID3D12LibraryReflection> pLib;
 
             hr = pReflection->GetPartReflection(shaderIdx, IID_PPV_ARGS(&pLib));
diff --git a/Graphics/ShaderTools/src/GLSLangUtils.cpp b/Graphics/ShaderTools/src/GLSLangUtils.cpp
index 75d97528..85a3efa1 100644
--- a/Graphics/ShaderTools/src/GLSLangUtils.cpp
+++ b/Graphics/ShaderTools/src/GLSLangUtils.cpp
@@ -456,9 +456,9 @@ std::vector<unsigned int> HLSLtoSPIRV(const ShaderCreateInfo& ShaderCI,
     VERIFY_EXPR(ShaderCI.SourceLanguage == SHADER_SOURCE_LANGUAGE_HLSL);
 
     VERIFY(ShLang != EShLangRayGen && ShLang != EShLangIntersect && ShLang != EShLangAnyHit && ShLang != EShLangClosestHit && ShLang != EShLangMiss && ShLang != EShLangCallable,
-           "ray tracing shaders are not supported, use DXCompiler to build SPIRV from HLSL");
+           "Ray tracing shaders are not supported, use DXCompiler to build SPIRV from HLSL");
     VERIFY(ShLang != EShLangTaskNV && ShLang != EShLangMeshNV,
-           "mesh shaders are not supported, use DXCompiler to build SPIRV from HLSL");
+           "Mesh shaders are not supported, use DXCompiler to build SPIRV from HLSL");
 
     Shader.setEnvInput(::glslang::EShSourceHlsl, ShLang, ::glslang::EShClientVulkan, 100);
     Shader.setEnvClient(::glslang::EShClientVulkan, ::glslang::EShTargetVulkan_1_0);
diff --git a/Graphics/ShaderTools/src/SPIRVShaderResources.cpp b/Graphics/ShaderTools/src/SPIRVShaderResources.cpp
index 7f1d78d5..bb15cc06 100644
--- a/Graphics/ShaderTools/src/SPIRVShaderResources.cpp
+++ b/Graphics/ShaderTools/src/SPIRVShaderResources.cpp
@@ -127,70 +127,54 @@ SPIRVShaderResourceAttribs::SPIRVShaderResourceAttribs(const diligent_spirv_cros
 }
 
 
-ShaderResourceDesc SPIRVShaderResourceAttribs::GetResourceDesc() const
+SHADER_RESOURCE_TYPE SPIRVShaderResourceAttribs::GetShaderResourceType(ResourceType Type)
 {
-    ShaderResourceDesc ResourceDesc;
-    ResourceDesc.Name      = Name;
-    ResourceDesc.ArraySize = ArraySize;
-
     static_assert(SPIRVShaderResourceAttribs::ResourceType::NumResourceTypes == 12, "Please handle the new resource type below");
     switch (Type)
     {
         case SPIRVShaderResourceAttribs::ResourceType::UniformBuffer:
-            ResourceDesc.Type = SHADER_RESOURCE_TYPE_CONSTANT_BUFFER;
-            break;
+            return SHADER_RESOURCE_TYPE_CONSTANT_BUFFER;
 
         case SPIRVShaderResourceAttribs::ResourceType::ROStorageBuffer:
             // Read-only storage buffers map to buffer SRV
             // https://github.com/KhronosGroup/SPIRV-Cross/wiki/Reflection-API-user-guide#read-write-vs-read-only-resources-for-hlsl
-            ResourceDesc.Type = SHADER_RESOURCE_TYPE_BUFFER_SRV;
-            break;
+            return SHADER_RESOURCE_TYPE_BUFFER_SRV;
 
         case SPIRVShaderResourceAttribs::ResourceType::RWStorageBuffer:
-            ResourceDesc.Type = SHADER_RESOURCE_TYPE_BUFFER_UAV;
-            break;
+            return SHADER_RESOURCE_TYPE_BUFFER_UAV;
 
         case SPIRVShaderResourceAttribs::ResourceType::UniformTexelBuffer:
-            ResourceDesc.Type = SHADER_RESOURCE_TYPE_BUFFER_SRV;
-            break;
+            return SHADER_RESOURCE_TYPE_BUFFER_SRV;
 
         case SPIRVShaderResourceAttribs::ResourceType::StorageTexelBuffer:
-            ResourceDesc.Type = SHADER_RESOURCE_TYPE_BUFFER_UAV;
-            break;
+            return SHADER_RESOURCE_TYPE_BUFFER_UAV;
 
         case SPIRVShaderResourceAttribs::ResourceType::StorageImage:
-            ResourceDesc.Type = SHADER_RESOURCE_TYPE_TEXTURE_UAV;
-            break;
+            return SHADER_RESOURCE_TYPE_TEXTURE_UAV;
 
         case SPIRVShaderResourceAttribs::ResourceType::SampledImage:
-            ResourceDesc.Type = SHADER_RESOURCE_TYPE_TEXTURE_SRV;
-            break;
+            return SHADER_RESOURCE_TYPE_TEXTURE_SRV;
 
         case SPIRVShaderResourceAttribs::ResourceType::AtomicCounter:
-            LOG_WARNING_MESSAGE("There is no appropriate shader resource type for atomic counter resource '", Name, "'");
-            ResourceDesc.Type = SHADER_RESOURCE_TYPE_BUFFER_UAV;
-            break;
+            LOG_WARNING_MESSAGE("There is no appropriate shader resource type for atomic counter");
+            return SHADER_RESOURCE_TYPE_BUFFER_UAV;
 
         case SPIRVShaderResourceAttribs::ResourceType::SeparateImage:
-            ResourceDesc.Type = SHADER_RESOURCE_TYPE_TEXTURE_SRV;
-            break;
+            return SHADER_RESOURCE_TYPE_TEXTURE_SRV;
 
         case SPIRVShaderResourceAttribs::ResourceType::SeparateSampler:
-            ResourceDesc.Type = SHADER_RESOURCE_TYPE_SAMPLER;
-            break;
+            return SHADER_RESOURCE_TYPE_SAMPLER;
 
         case SPIRVShaderResourceAttribs::ResourceType::InputAttachment:
-            ResourceDesc.Type = SHADER_RESOURCE_TYPE_INPUT_ATTACHMENT;
-            break;
+            return SHADER_RESOURCE_TYPE_INPUT_ATTACHMENT;
 
         case SPIRVShaderResourceAttribs::ResourceType::AccelerationStructure:
-            ResourceDesc.Type = SHADER_RESOURCE_TYPE_ACCEL_STRUCT;
-            break;
+            return SHADER_RESOURCE_TYPE_ACCEL_STRUCT;
 
         default:
             UNEXPECTED("Unknown SPIRV resource type");
+            return SHADER_RESOURCE_TYPE_UNKNOWN;
     }
-    return ResourceDesc;
 }
 
 
@@ -692,12 +676,12 @@ SPIRVShaderResources::~SPIRVShaderResources()
     for (Uint32 n = 0; n < GetNumInptAtts(); ++n)
         GetInptAtt(n).~SPIRVShaderResourceAttribs();
 
-    for (Uint32 n = 0; n < GetNumAccelStructs(); ++n)
-        GetAccelStruct(n).~SPIRVShaderResourceAttribs();
-
     for (Uint32 n = 0; n < GetNumShaderStageInputs(); ++n)
         GetShaderStageInputAttribs(n).~SPIRVShaderStageInputAttribs();
 
+    for (Uint32 n = 0; n < GetNumAccelStructs(); ++n)
+        GetAccelStruct(n).~SPIRVShaderResourceAttribs();
+
     static_assert(SPIRVShaderResourceAttribs::ResourceType::NumResourceTypes == 12, "Please add destructor for the new resource");
 }
 
@@ -755,12 +739,12 @@ std::string SPIRVShaderResources::DumpResources()
             if (Img.Type == SPIRVShaderResourceAttribs::ResourceType::StorageImage)
             {
                 ss << std::endl
-                   << std::setw(3) << ResNum << " Storage Image      ";
+                   << std::setw(3) << ResNum << " Storage Image    ";
             }
             else if (Img.Type == SPIRVShaderResourceAttribs::ResourceType::StorageTexelBuffer)
             {
                 ss << std::endl
-                   << std::setw(3) << ResNum << " Storage Txl Buff   ";
+                   << std::setw(3) << ResNum << " Storage Txl Buff ";
             }
             else
                 UNEXPECTED("Unexpected resource type");
@@ -771,12 +755,12 @@ std::string SPIRVShaderResources::DumpResources()
             if (SmplImg.Type == SPIRVShaderResourceAttribs::ResourceType::SampledImage)
             {
                 ss << std::endl
-                   << std::setw(3) << ResNum << " Sampled Image      ";
+                   << std::setw(3) << ResNum << " Sampled Image    ";
             }
             else if (SmplImg.Type == SPIRVShaderResourceAttribs::ResourceType::UniformTexelBuffer)
             {
                 ss << std::endl
-                   << std::setw(3) << ResNum << " Uniform Txl Buff   ";
+                   << std::setw(3) << ResNum << " Uniform Txl Buff ";
             }
             else
                 UNEXPECTED("Unexpected resource type");
@@ -786,35 +770,35 @@ std::string SPIRVShaderResources::DumpResources()
         {
             VERIFY(AC.Type == SPIRVShaderResourceAttribs::ResourceType::AtomicCounter, "Unexpected resource type");
             ss << std::endl
-               << std::setw(3) << ResNum << " Atomic Cntr        ";
+               << std::setw(3) << ResNum << " Atomic Cntr      ";
             DumpResource(AC);
         },
         [&](const SPIRVShaderResourceAttribs& SepSmpl, Uint32) //
         {
             VERIFY(SepSmpl.Type == SPIRVShaderResourceAttribs::ResourceType::SeparateSampler, "Unexpected resource type");
             ss << std::endl
-               << std::setw(3) << ResNum << " Separate Smpl      ";
+               << std::setw(3) << ResNum << " Separate Smpl    ";
             DumpResource(SepSmpl);
         },
         [&](const SPIRVShaderResourceAttribs& SepImg, Uint32) //
         {
             VERIFY(SepImg.Type == SPIRVShaderResourceAttribs::ResourceType::SeparateImage, "Unexpected resource type");
             ss << std::endl
-               << std::setw(3) << ResNum << " Separate Img       ";
+               << std::setw(3) << ResNum << " Separate Img     ";
             DumpResource(SepImg);
         },
         [&](const SPIRVShaderResourceAttribs& InptAtt, Uint32) //
         {
             VERIFY(InptAtt.Type == SPIRVShaderResourceAttribs::ResourceType::InputAttachment, "Unexpected resource type");
             ss << std::endl
-               << std::setw(3) << ResNum << " Input Attachment   ";
+               << std::setw(3) << ResNum << " Input Attachment ";
             DumpResource(InptAtt);
         },
         [&](const SPIRVShaderResourceAttribs& AccelStruct, Uint32) //
         {
             VERIFY(AccelStruct.Type == SPIRVShaderResourceAttribs::ResourceType::AccelerationStructure, "Unexpected resource type");
             ss << std::endl
-               << std::setw(3) << ResNum << " Acceleration Struct";
+               << std::setw(3) << ResNum << " Accel Struct     ";
             DumpResource(AccelStruct);
         } //
     );